www/ecrire/public/jointures.php

   1 <?php
   2
   3 /***************************************************************************\
   4  *  SPIP, Systeme de publication pour l'internet                           *
   5  *                                                                         *
   6  *  Copyright (c) 2001-2011                                                *
   7  *  Arnaud Martin, Antoine Pitrou, Philippe Riviere, Emmanuel Saint-James  *
   8  *                                                                         *
   9  *  Ce programme est un logiciel libre distribue sous licence GNU/GPL.     *
  10  *  Pour plus de details voir le fichier COPYING.txt ou l'aide en ligne.   *
  11 \***************************************************************************/
  12
  13 if (!defined('_ECRIRE_INC_VERSION')) return;
  14
  15 // deduction automatique d'une chaine de jointures
  16
  17 /**
  18  * decomposer un champ id_article en (id_objet,objet,'article') si necessaire
  19  *
  20  * @param string $champ
  21  * @return array ou string
  22  */
  23
  24 // http://doc.spip.org/@decompose_champ_id_objet
  25 function decompose_champ_id_objet($champ){
  26         if (($champ!=='id_objet') AND preg_match(',^id_([a-z_]+)$,',$champ,$regs)){
  27                 return array('id_objet','objet',$regs[1]);
  28         }
  29         return $champ;
  30 }
  31
  32 /**
  33  * mapping d'un champ d'une jointure en deux champs id_objet,objet si necessaire
  34  *
  35  * @param string $champ
  36  * @param array $desc
  37  * @return array
  38  */
  39 // http://doc.spip.org/@trouver_champs_decomposes
  40 function trouver_champs_decomposes($champ,$desc){
  41         if (!is_array($desc) // on ne se risque pas en conjectures si on ne connait pas la table
  42           OR array_key_exists($champ,$desc['field']))
  43                 return array($champ);
  44         if (is_array($decompose=decompose_champ_id_objet($champ))){
  45                 array_pop($decompose);
  46                 if (count(array_intersect($decompose,array_keys($desc['field'])))==count($decompose))
  47                         return $decompose;
  48         }
  49         return array($champ);
  50 }
  51
  52
  53 // http://doc.spip.org/@calculer_jointure
  54 function calculer_jointure(&$boucle, $depart, $arrivee, $col='', $cond=false)
  55 {
  56
  57   $res = calculer_chaine_jointures($boucle, $depart, $arrivee);
  58   if (!$res) return "";
  59
  60   list($nom,$desc) = $depart;
  61   return fabrique_jointures($boucle, $res, $cond, $desc, $nom, $col);
  62 }
  63
  64 // http://doc.spip.org/@fabrique_jointures
  65 function fabrique_jointures(&$boucle, $res, $cond=false, $desc=array(), $nom='', $col='')
  66 {
  67         static $num=array();
  68         $id_table = "";
  69         $cpt = &$num[$boucle->descr['nom']][$boucle->descr['gram']][$boucle->id_boucle];
  70         foreach($res as $cle=>$r) {
  71                 list($d, $a, $j) = $r;
  72                 if (!$id_table) $id_table = $d;
  73                 $n = ++$cpt;
  74                 if (is_array($j)){ // c'est un lien sur un champ du type id_objet,objet,'article'
  75                         list($j1,$j2,$obj,$type) = $j;
  76                         // trouver de quel cote est (id_objet,objet)
  77                         if ($j1=="id_$obj")
  78                                 $obj = "$id_table.$obj";
  79                         else
  80                                 $obj = "L$n.$obj";
  81                         // le where complementaire est envoye dans la jointure pour pouvoir etre elimine avec la jointure
  82                         // en cas d'optimisation
  83                         //$boucle->where[] = array("'='","'$obj'","sql_quote('$type')");
  84                         $boucle->join["L$n"]= array("'$id_table'","'$j2'","'$j1'","'$obj='.sql_quote('$type')");
  85                 }
  86                 else
  87                         $boucle->join["L$n"]= array("'$id_table'","'$j'");
  88                 $boucle->from[$id_table = "L$n"] = $a[0];
  89         }
  90
  91
  92   // pas besoin de group by
  93   // (cf http://article.gmane.org/gmane.comp.web.spip.devel/30555)
  94   // si une seule jointure et sur une table avec primary key formee
  95   // de l'index principal et de l'index de jointure (non conditionnel! [6031])
  96   // et operateur d'egalite (http://trac.rezo.net/trac/spip/ticket/477)
  97
  98         if ($pk = (isset($a[1]) && (count($boucle->from) == 2) && !$cond)) {
  99                 $pk = nogroupby_if($desc, $a[1], $col);
 100         }
 101
 102         // pas de group by
 103         // si une seule jointure
 104         // et si l'index de jointure est une primary key a l'arrivee !
 105         if (!$pk
 106           AND (count($boucle->from) == 2)
 107           AND isset($a[1]['key']['PRIMARY KEY'])
 108           AND ($j == $a[1]['key']['PRIMARY KEY'])
 109           )
 110           $pk = true;
 111
 112   // la clause Group by est en conflit avec ORDER BY, a completer
 113         $groups = liste_champs_jointures($nom,$desc,true);
 114         if (!$pk) foreach($groups as $id_prim){
 115                 $id_field = $nom . '.' . $id_prim;
 116                 if (!in_array($id_field, $boucle->group)) {
 117                         $boucle->group[] = $id_field;
 118                 }
 119         }
 120
 121         $boucle->modificateur['lien'] = true;
 122         return "L$n";
 123   }
 124
 125 // condition suffisante pour qu'un Group-By ne soit pas necessaire
 126 // A ameliorer, notamment voir si calculer_select ne pourrait pas la reutiliser
 127 // lorsqu'on sait si le critere conditionnel est finalement present
 128 // http://doc.spip.org/@nogroupby_if
 129 function nogroupby_if($depart, $arrivee, $col)
 130 {
 131         $pk = $arrivee['key']['PRIMARY KEY'];
 132         if (!$pk) return false;
 133         $id_primary = $depart['key']['PRIMARY KEY'];
 134         if (is_array($col)) $col = implode(', *',$col); // cas id_objet, objet
 135         return (preg_match("/^$id_primary, *$col$/", $pk) OR
 136                 preg_match("/^$col, *$id_primary$/", $pk));
 137 }
 138
 139 // http://doc.spip.org/@liste_champs_jointures
 140 function liste_champs_jointures($nom,$desc,$primary=false){
 141
 142         static $nojoin = array('idx','maj','date','statut');
 143
 144         // si cle primaire demandee, la privilegier
 145         if ($primary && isset($desc['key']['PRIMARY KEY']))
 146                 return split_key($desc['key']['PRIMARY KEY']);
 147
 148         // les champs declares explicitement pour les jointures
 149         if (isset($desc['join'])) return $desc['join'];
 150         /*elseif (isset($GLOBALS['tables_principales'][$nom]['join'])) return $GLOBALS['tables_principales'][$nom]['join'];
 151         elseif (isset($GLOBALS['tables_auxiliaires'][$nom]['join'])) return $GLOBALS['tables_auxiliaires'][$nom]['join'];*/
 152
 153         // si pas de cle, c'est fichu
 154         if (!isset($desc['key'])) return array();
 155
 156         // si cle primaire
 157         if (isset($desc['key']['PRIMARY KEY']))
 158                 return split_key($desc['key']['PRIMARY KEY']);
 159
 160         // ici on se rabat sur les cles secondaires,
 161         // en eliminant celles qui sont pas pertinentes (idx, maj)
 162         // si jamais le resultat n'est pas pertinent pour une table donnee,
 163         // il faut declarer explicitement le champ 'join' de sa description
 164
 165         $join = array();
 166         foreach($desc['key'] as $v) $join = split_key($v, $join);
 167         foreach($join as $k) if (in_array($k, $nojoin)) unset($join[$k]);
 168         return $join;
 169 }
 170
 171 // http://doc.spip.org/@split_key
 172 function split_key($v, $join = array())
 173 {
 174         foreach (preg_split('/,\s*/', $v) as $k) $join[$k] = $k;
 175         return $join;
 176 }
 177
 178 // http://doc.spip.org/@calculer_chaine_jointures
 179 function calculer_chaine_jointures(&$boucle, $depart, $arrivee, $vu=array(), $milieu_exclus = array(), $max_liens = 5)
 180 {
 181         static $trouver_table;
 182         if (!$trouver_table)
 183                 $trouver_table = charger_fonction('trouver_table', 'base');
 184
 185         if (is_string($milieu_exclus))
 186                 $milieu_exclus = array($milieu_exclus);
 187
 188         list($dnom,$ddesc) = $depart;
 189         list($anom,$adesc) = $arrivee;
 190         if (!count($vu))
 191                 $vu[] = $dnom; // ne pas oublier la table de depart
 192
 193         $akeys = $adesc['key'];
 194         if ($v = $akeys['PRIMARY KEY']) {
 195                 unset($akeys['PRIMARY KEY']);
 196                 $akeys = array_merge(preg_split('/,\s*/', $v), $akeys);
 197         }
 198         // enlever les cles d'arrivee exclues par l'appel
 199         $akeys = array_diff($akeys,$milieu_exclus);
 200
 201         // cles candidates au depart
 202         $keys = liste_champs_jointures($dnom,$ddesc);
 203         // enlever les cles dde depart exclues par l'appel
 204         $keys = array_diff($keys,$milieu_exclus);
 205
 206         $v = !$keys ? false : array_intersect(array_values($keys), $akeys);
 207
 208         if ($v)
 209                 return array(array($dnom, array($adesc['table'],$adesc), array_shift($v)));
 210
 211         // regarder si l'on a (id_objet,objet) au depart et si on peut le mapper sur un id_xx
 212         if (count(array_intersect(array('id_objet','objet'),$keys))==2){
 213                 // regarder si l'une des cles d'arrivee peut se decomposer en
 214                 // id_objet,objet
 215                 // si oui on la prend
 216                 foreach($akeys as $key){
 217                         $v = decompose_champ_id_objet($key);
 218                         if (is_array($v)){
 219                                 $objet = array_shift($v);// objet,'article'
 220                                 array_unshift($v,$key); // id_article,objet,'article'
 221                                 array_unshift($v,$objet); // id_objet,id_article,objet,'article'
 222                                 return array(array($dnom, array($adesc['table'],$adesc), $v));
 223                         }
 224                 }
 225         }
 226         else {
 227                 // regarder si l'une des cles de depart peut se decomposer en
 228                 // id_objet,objet a l'arrivee
 229                 // si oui on la prend
 230                 foreach($keys as $key){
 231                         if (count($v = trouver_champs_decomposes($key,$adesc))>1){
 232                                 if (count($v)==count(array_intersect($v, $akeys)))
 233                                         $v = decompose_champ_id_objet($key); // id_objet,objet,'article'
 234                                         array_unshift($v,$key); // id_article,id_objet,objet,'article'
 235                                         return array(array($dnom, array($adesc['table'],$adesc), $v));
 236                         }
 237                 }
 238         }
 239         // si l'on voulait une jointure direct, c'est rate !
 240         if ($max_liens<=1) return array();
 241
 242         // sinon essayer de passer par une autre table
 243         $new = $vu;
 244         foreach($boucle->jointures as $v) {
 245                 if ($v && (!in_array($v,$vu)) &&
 246                     ($def = $trouver_table($v, $boucle->sql_serveur))) {
 247                         // ne pas tester les cles qui sont exclues a l'appel
 248                         // ie la cle de la jointure precedente
 249                         $test_cles = $milieu_exclus;
 250                         $new[] = $v;
 251                         $max_iter = 50; // securite
 252                         while (count($jointure_directe_possible = calculer_chaine_jointures($boucle,$depart,array($v, $def),$vu,$test_cles,1))
 253                           AND $max_iter--) {
 254                                 $jointure_directe_possible = reset($jointure_directe_possible);
 255                                 $milieu = end($jointure_directe_possible);
 256                                 if (is_string($milieu))
 257                                         $test_cles[] = $milieu;
 258                                 else
 259                                         $test_cles = array_merge($test_cles,$milieu);
 260                                 // essayer de rejoindre l'arrivee a partir de cette etape intermediaire
 261                                 // sans repasser par la meme cle milieu
 262                           $r = calculer_chaine_jointures($boucle, array($v, $def), $arrivee, $new, $milieu,$max_liens-1);
 263                                 if ($r) {
 264                                   array_unshift($r, $jointure_directe_possible);
 265                                         return $r;
 266                                 }
 267                         }
 268                 }
 269         }
 270         return array();
 271 }
 272
 273 // applatit les cles multiples
 274
 275 // http://doc.spip.org/@trouver_cles_table
 276 function trouver_cles_table($keys)
 277 {
 278   $res =array();
 279   foreach ($keys as $v) {
 280     if (!strpos($v,","))
 281       $res[$v]=1;
 282     else {
 283       foreach (preg_split("/\s*,\s*/", $v) as $k) {
 284         $res[$k]=1;
 285       }
 286     }
 287   }
 288   return array_keys($res);
 289 }
 290
 291 // http://doc.spip.org/@trouver_champ_exterieur
 292 function trouver_champ_exterieur($cle, $joints, &$boucle, $checkarrivee = false)
 293 {
 294         static $trouver_table;
 295         if (!$trouver_table)
 296                 $trouver_table = charger_fonction('trouver_table', 'base');
 297
 298         // support de la recherche multi champ
 299         if (!is_array($cle))
 300                 $cle = array($cle);
 301         foreach($joints as $k => $join) {
 302           if ($join && $table = $trouver_table($join, $boucle->sql_serveur)) {
 303             if (isset($table['field'])
 304                 // verifier que toutes les cles cherchees sont la
 305                           AND (count(array_intersect($cle, array_keys($table['field'])))==count($cle))
 306                           // si on sait ou on veut arriver, il faut que ca colle
 307                           AND ($checkarrivee==false || $checkarrivee==$table['table']))
 308               return  array($table['table'], $table);
 309           }
 310         }
 311         // une cle id_xx peut etre implementee par un couple (id_objet,objet)
 312         foreach($cle as $k=>$c) {
 313                 if (is_array($decompose = decompose_champ_id_objet($c))){
 314                         unset($cle[$k]);
 315                         $cle[] = array_shift($decompose); // id_objet
 316                         $cle[] = array_shift($decompose); // objet
 317                         return trouver_champ_exterieur($cle,$joints,$boucle,$checkarrivee);
 318                 }
 319         }
 320         return "";
 321 }
 322
 323 // http://doc.spip.org/@trouver_jointure_champ
 324 function trouver_jointure_champ($champ, &$boucle)
 325 {
 326         $cle = trouver_champ_exterieur($champ, $boucle->jointures, $boucle);
 327         if ($cle) {
 328                 $desc = $boucle->show;
 329                 $cle = calculer_jointure($boucle, array($desc['id_table'], $desc), $cle, false);
 330         }
 331         if ($cle) return $cle;
 332         spip_log("trouver_jointure_champ: $champ inconnu");
 333         return '';
 334 }
 335 ?>