www/ecrire/public/jointures.php

   1 <?php
   2
   3 /***************************************************************************\
   4  *  SPIP, Systeme de publication pour l'internet                           *
   5  *                                                                         *
   6  *  Copyright (c) 2001-2016                                                *
   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 /**
  25  * Decomposer un champ id_truc en (id_objet,objet,truc)
  26  * fonction factorisee ici pour ne pas dupliquer ce code N fois
  27  * http://doc.spip.org/@decompose_champ_id_objet
  28  *
  29  * @param string $champ
  30  * @return array
  31  */
  32 function decompose_champ_id_objet($champ){
  33         if (($champ!=='id_objet') AND preg_match(',^id_([a-z_]+)$,', $champ, $regs)){
  34                 return array('id_objet', 'objet', objet_type($regs[1]));
  35         }
  36         return $champ;
  37 }
  38
  39 /**
  40  * mapping d'un champ d'une jointure en deux champs id_objet,objet si necessaire
  41  *
  42  * http://doc.spip.org/@trouver_champs_decomposes
  43  *
  44  * @param string $champ
  45  * @param array $desc
  46  * @return array
  47  */
  48 function trouver_champs_decomposes($champ, $desc){
  49         if (!is_array($desc) // on ne se risque pas en conjectures si on ne connait pas la table
  50             OR array_key_exists($champ, $desc['field'])
  51         )
  52                 return array($champ);
  53         if (is_array($decompose = decompose_champ_id_objet($champ))){
  54                 array_pop($decompose);
  55                 if (count(array_intersect($decompose, array_keys($desc['field'])))==count($decompose))
  56                         return $decompose;
  57         }
  58         return array($champ);
  59 }
  60
  61
  62 /**
  63  * Calculer et construite une jointure entre depart et arrivee
  64  * L'objet boucle est modifie pour completer la requete
  65  * la fonction retourne l'alias d'arrivee une fois la jointure construire
  66  * en general un "Lx"
  67  *
  68  * http://doc.spip.org/@calculer_jointure
  69  *
  70  * @param object $boucle
  71  * @param array $depart
  72  *   sous la forme (nom de la table, description de la table)
  73  * @param array $arrivee
  74  *   sous la forme (nom de la table, description de la table)
  75  * @param string $col
  76  *      colonne cible de la jointure
  77  * @param bool $cond
  78  *     flag pour savoir si le critere est conditionnel ou non
  79  * @return string
  80  */
  81 function calculer_jointure(&$boucle, $depart, $arrivee, $col = '', $cond = false, $max_liens=5){
  82         // les jointures minimales sont optimales :
  83         // on contraint le nombre d'etapes en l'augmentant
  84         // jusqu'a ce qu'on trouve une jointure ou qu'on atteigne la limite maxi
  85         $max = 1;
  86         $res = false;
  87         $milieu_exclus = ($col?$col:array());
  88         while ($max<=$max_liens AND !$res){
  89                 $res = calculer_chaine_jointures($boucle, $depart, $arrivee, array(), $milieu_exclus, $max);
  90                 $max++;
  91         }
  92         if (!$res) return "";
  93
  94         list($nom, $desc) = $depart;
  95
  96         return fabrique_jointures($boucle, $res, $cond, $desc, $nom, $col);
  97 }
  98
  99 /**
 100  * Fabriquer une jointure a l'aide d'une liste descriptive d'etapes
 101  *
 102  * http://doc.spip.org/@fabrique_jointures
 103  *
 104  * $res = array(
 105  * array(table_depart,array(table_arrivee,desc),jointure
 106  * ...
 107  * )
 108  * jointure peut etre un tableau pour les jointures sur champ decomposr
 109  * array('id_article','id_objet','objet','article')
 110  * array('id_objet','id_article','objet','article')
 111  *
 112  * @param object $boucle
 113  *   objet boucle
 114  * @param array $res
 115  *   chaine des jointures
 116  * @param bool $cond
 117  *   flag pour savoir si le critere est conditionnel ou non
 118  * @param array $desc
 119  *   description de la table de depart
 120  * @param string $nom
 121  *   nom de la table de depart
 122  * @param string $col
 123  *   colonne cible de la jointure
 124  * @param bool $echap
 125  * @return string
 126  */
 127 function fabrique_jointures(&$boucle, $res, $cond = false, $desc = array(), $nom = '', $col = '', $echap = true){
 128         static $num = array();
 129         $id_table = "";
 130         $cpt = &$num[$boucle->descr['nom']][$boucle->descr['gram']][$boucle->id_boucle];
 131         foreach ($res as $cle => $r){
 132                 list($d, $a, $j) = $r;
 133                 if (!$id_table) $id_table = $d;
 134                 $n = ++$cpt;
 135                 if (is_array($j)){ // c'est un lien sur un champ du type id_objet,objet,'article'
 136                         list($j1, $j2, $obj, $type) = $j;
 137                         // trouver de quel cote est (id_objet,objet)
 138                         if ($j1=="id_$obj")
 139                                 $obj = "$id_table.$obj";
 140                         else
 141                                 $obj = "L$n.$obj";
 142                         // le where complementaire est envoye dans la jointure pour pouvoir etre elimine avec la jointure
 143                         // en cas d'optimisation
 144                         //$boucle->where[] = array("'='","'$obj'","sql_quote('$type')");
 145                         $boucle->join["L$n"] =
 146                                 $echap ?
 147                                         array("'$id_table'", "'$j2'", "'$j1'", "'$obj='.sql_quote('$type')")
 148                                         :
 149                                         array($id_table, $j2, $j1, "$obj=".sql_quote($type));
 150                 }
 151                 else
 152                         $boucle->join["L$n"] = $echap ? array("'$id_table'", "'$j'") : array($id_table, $j);
 153                 $boucle->from[$id_table = "L$n"] = $a[0];
 154         }
 155
 156
 157         // pas besoin de group by
 158         // (cf http://article.gmane.org/gmane.comp.web.spip.devel/30555)
 159         // si une seule jointure et sur une table avec primary key formee
 160         // de l'index principal et de l'index de jointure (non conditionnel! [6031])
 161         // et operateur d'egalite (http://trac.rezo.net/trac/spip/ticket/477)
 162
 163         if ($pk = (isset($a[1]) && (count($boucle->from)==2) && !$cond)){
 164                 $pk = nogroupby_if($desc, $a[1], $col);
 165         }
 166
 167         // pas de group by
 168         // si une seule jointure
 169         // et si l'index de jointure est une primary key a l'arrivee !
 170         if (!$pk
 171             AND (count($boucle->from)==2)
 172                 AND isset($a[1]['key']['PRIMARY KEY'])
 173                     AND ($j==$a[1]['key']['PRIMARY KEY'])
 174         )
 175                 $pk = true;
 176
 177         // la clause Group by est en conflit avec ORDER BY, a completer
 178         $groups = liste_champs_jointures($nom, $desc, true);
 179         if (!$pk) foreach ($groups as $id_prim){
 180                 $id_field = $nom.'.'.$id_prim;
 181                 if (!in_array($id_field, $boucle->group)){
 182                         $boucle->group[] = $id_field;
 183                 }
 184         }
 185
 186         $boucle->modificateur['lien'] = true;
 187         return "L$n";
 188 }
 189
 190 /**
 191  * condition suffisante pour qu'un Group-By ne soit pas necessaire
 192  * A ameliorer, notamment voir si calculer_select ne pourrait pas la reutiliser
 193  * lorsqu'on sait si le critere conditionnel est finalement present
 194  *
 195  * http://doc.spip.org/@nogroupby_if
 196  *
 197  * @param array $depart
 198  * @param array $arrivee
 199  * @param string|array $col
 200  * @return bool
 201  */
 202 function nogroupby_if($depart, $arrivee, $col){
 203         $pk = $arrivee['key']['PRIMARY KEY'];
 204         if (!$pk) return false;
 205         $id_primary = $depart['key']['PRIMARY KEY'];
 206         if (is_array($col)) $col = implode(', *', $col); // cas id_objet, objet
 207         return (preg_match("/^$id_primary, *$col$/", $pk) OR
 208                 preg_match("/^$col, *$id_primary$/", $pk));
 209 }
 210
 211 /**
 212  * Lister les champs candidats a une jointure, sur une table
 213  * si un join est fourni dans la description, c'est lui qui l'emporte
 214  * sauf si cle primaire explicitement demandee par $primary
 215  *
 216  * sinon on construit une liste des champs a partir de la liste des cles de la table
 217  *
 218  * http://doc.spip.org/@liste_champs_jointures
 219  *
 220  * @param string $nom
 221  * @param array $desc
 222  * @param bool $primary
 223  * @return array
 224  */
 225 function liste_champs_jointures($nom, $desc, $primary = false){
 226
 227         static $nojoin = array('idx', 'maj', 'date', 'statut');
 228
 229         // si cle primaire demandee, la privilegier
 230         if ($primary && isset($desc['key']['PRIMARY KEY']))
 231                 return split_key($desc['key']['PRIMARY KEY']);
 232
 233         // les champs declares explicitement pour les jointures
 234         if (isset($desc['join'])) return $desc['join'];
 235         /*elseif (isset($GLOBALS['tables_principales'][$nom]['join'])) return $GLOBALS['tables_principales'][$nom]['join'];
 236         elseif (isset($GLOBALS['tables_auxiliaires'][$nom]['join'])) return $GLOBALS['tables_auxiliaires'][$nom]['join'];*/
 237
 238         // si pas de cle, c'est fichu
 239         if (!isset($desc['key'])) return array();
 240
 241         // si cle primaire
 242         if (isset($desc['key']['PRIMARY KEY']))
 243                 return split_key($desc['key']['PRIMARY KEY']);
 244
 245         // ici on se rabat sur les cles secondaires,
 246         // en eliminant celles qui sont pas pertinentes (idx, maj)
 247         // si jamais le resultat n'est pas pertinent pour une table donnee,
 248         // il faut declarer explicitement le champ 'join' de sa description
 249
 250         $join = array();
 251         foreach ($desc['key'] as $v) $join = split_key($v, $join);
 252         foreach ($join as $k) if (in_array($k, $nojoin)) unset($join[$k]);
 253         return $join;
 254 }
 255
 256 /**
 257  * Eclater une cle composee en plusieurs champs
 258  *
 259  * http://doc.spip.org/@split_key
 260  *
 261  * @param string $v
 262  * @param array $join
 263  * @return array
 264  */
 265 function split_key($v, $join = array()){
 266         foreach (preg_split('/,\s*/', $v) as $k) $join[$k] = $k;
 267         return $join;
 268 }
 269
 270 /**
 271  * Constuire la chaine de jointures, de proche en proche
 272  *
 273  * http://doc.spip.org/@calculer_chaine_jointures
 274  *
 275  * @param objetc $boucle
 276  * @param array $depart
 277  *  sous la forme array(nom de la table, description)
 278  * @param array $arrivee
 279  *  sous la forme array(nom de la table, description)
 280  * @param array $vu
 281  *  tables deja vues dans la jointure, pour ne pas y repasser
 282  * @param array $milieu_exclus
 283  *  cles deja utilisees, pour ne pas les reutiliser
 284  * @param int $max_liens
 285  *  nombre maxi d'etapes
 286  * @return array
 287  */
 288 function calculer_chaine_jointures(&$boucle, $depart, $arrivee, $vu = array(), $milieu_exclus = array(), $max_liens = 5){
 289         static $trouver_table;
 290         if (!$trouver_table)
 291                 $trouver_table = charger_fonction('trouver_table', 'base');
 292
 293         if (is_string($milieu_exclus))
 294                 $milieu_exclus = array($milieu_exclus);
 295         // quand on a exclus id_objet comme cle de jointure, il faut aussi exclure objet
 296         // faire une jointure sur objet tout seul n'a pas de sens
 297         if (in_array('id_objet',$milieu_exclus) AND !in_array('objet',$milieu_exclus))
 298                 $milieu_exclus[] = 'objet';
 299
 300         list($dnom, $ddesc) = $depart;
 301         list($anom, $adesc) = $arrivee;
 302         if (!count($vu)){
 303                 $vu[] = $dnom; // ne pas oublier la table de depart
 304                 $vu[] = $anom; // ne pas oublier la table d'arrivee
 305         }
 306
 307         $akeys = array();
 308         foreach ($adesc['key'] as $k) {
 309                 // respecter l'ordre de $adesc['key'] pour ne pas avoir id_trad en premier entre autres...
 310                 $akeys = array_merge($akeys, preg_split('/,\s*/', $k));
 311         }
 312
 313         // enlever les cles d'arrivee exclues par l'appel
 314         $akeys = array_diff($akeys, $milieu_exclus);
 315
 316         // cles candidates au depart
 317         $keys = liste_champs_jointures($dnom, $ddesc);
 318         // enlever les cles dde depart exclues par l'appel
 319         $keys = array_diff($keys, $milieu_exclus);
 320
 321         $v = !$keys ? false : array_intersect(array_values($keys), $akeys);
 322
 323         if ($v)
 324                 return array(array($dnom, array($adesc['table'], $adesc), array_shift($v)));
 325
 326         // regarder si l'on a (id_objet,objet) au depart et si on peut le mapper sur un id_xx
 327         if (count(array_intersect(array('id_objet', 'objet'), $keys))==2){
 328                 // regarder si l'une des cles d'arrivee peut se decomposer en
 329                 // id_objet,objet
 330                 // si oui on la prend
 331                 foreach ($akeys as $key){
 332                         $v = decompose_champ_id_objet($key);
 333                         if (is_array($v)){
 334                                 $objet = array_shift($v); // objet,'article'
 335                                 array_unshift($v, $key); // id_article,objet,'article'
 336                                 array_unshift($v, $objet); // id_objet,id_article,objet,'article'
 337                                 return array(array($dnom, array($adesc['table'], $adesc), $v));
 338                         }
 339                 }
 340         }
 341         else {
 342                 // regarder si l'une des cles de depart peut se decomposer en
 343                 // id_objet,objet a l'arrivee
 344                 // si oui on la prend
 345                 foreach ($keys as $key){
 346                         if (count($v = trouver_champs_decomposes($key, $adesc))>1){
 347                                 if (count($v)==count(array_intersect($v, $akeys))){
 348                                         $v = decompose_champ_id_objet($key); // id_objet,objet,'article'
 349                                         array_unshift($v, $key); // id_article,id_objet,objet,'article'
 350                                         return array(array($dnom, array($adesc['table'], $adesc), $v));
 351                                 }
 352                         }
 353                 }
 354         }
 355         // si l'on voulait une jointure direct, c'est rate !
 356         if ($max_liens<=1) return array();
 357
 358         // sinon essayer de passer par une autre table
 359         $new = $vu;
 360         foreach ($boucle->jointures as $v){
 361                 if ($v
 362                     AND !in_array($v, $vu)
 363                     AND $def = $trouver_table($v, $boucle->sql_serveur)
 364                           AND !in_array($def['table_sql'], $vu)
 365                 ){
 366                         // ne pas tester les cles qui sont exclues a l'appel
 367                         // ie la cle de la jointure precedente
 368                         $test_cles = $milieu_exclus;
 369                         $new[] = $v;
 370                         $max_iter = 50; // securite
 371                         while (count($jointure_directe_possible = calculer_chaine_jointures($boucle, $depart, array($v, $def), $vu, $test_cles, 1))
 372                                AND $max_iter--){
 373                                 $jointure_directe_possible = reset($jointure_directe_possible);
 374                                 $milieu = end($jointure_directe_possible);
 375                                 $exclure_fin = $milieu_exclus;
 376                                 if (is_string($milieu)){
 377                                         $exclure_fin[] = $milieu;
 378                                         $test_cles[] = $milieu;
 379                                 }
 380                                 else{
 381                                         $exclure_fin = array_merge($exclure_fin, $milieu);
 382                                         $test_cles = array_merge($test_cles, $milieu);
 383                                 }
 384                                 // essayer de rejoindre l'arrivee a partir de cette etape intermediaire
 385                                 // sans repasser par la meme cle milieu, ni une cle deja vue !
 386                                 $r = calculer_chaine_jointures($boucle, array($v, $def), $arrivee, $new, $exclure_fin, $max_liens-1);
 387                                 if ($r){
 388                                         array_unshift($r, $jointure_directe_possible);
 389                                         return $r;
 390                                 }
 391                         }
 392                 }
 393         }
 394         return array();
 395 }
 396
 397 /**
 398  * applatit les cles multiples
 399  * redondance avec split_key() ? a mutualiser
 400  *
 401  * http://doc.spip.org/@trouver_cles_table
 402  *
 403  * @param $keys
 404  * @return array
 405  */
 406 function trouver_cles_table($keys){
 407         $res = array();
 408         foreach ($keys as $v){
 409                 if (!strpos($v, ","))
 410                         $res[$v] = 1;
 411                 else {
 412                         foreach (preg_split("/\s*,\s*/", $v) as $k){
 413                                 $res[$k] = 1;
 414                         }
 415                 }
 416         }
 417         return array_keys($res);
 418 }
 419
 420 /**
 421  * http://doc.spip.org/@trouver_champ_exterieur
 422  *
 423  * @param string|array $cle
 424  * @param array $joints
 425  * @param object $boucle
 426  * @param bool $checkarrivee
 427  * @return array|string
 428  */
 429 function trouver_champ_exterieur($cle, $joints, &$boucle, $checkarrivee = false){
 430         static $trouver_table = '';
 431         if (!$trouver_table)
 432                 $trouver_table = charger_fonction('trouver_table', 'base');
 433
 434         // support de la recherche multi champ :
 435         // si en seconde etape on a decompose le champ id_xx en id_objet,objet
 436         // on reentre ici soit en cherchant une table les 2 champs id_objet,objet
 437         // soit une table avec les 3 champs id_xx, id_objet, objet
 438         if (!is_array($cle))
 439                 $cle = array($cle);
 440
 441         foreach ($joints as $k => $join){
 442                 if ($join && $table = $trouver_table($join, $boucle->sql_serveur)){
 443                         if (isset($table['field'])
 444                             // verifier que toutes les cles cherchees sont la
 445                             AND (count(array_intersect($cle, array_keys($table['field'])))==count($cle))
 446                                 // si on sait ou on veut arriver, il faut que ca colle
 447                                 AND ($checkarrivee==false || $checkarrivee==$table['table'])
 448                         )
 449                                 return array($table['table'], $table);
 450                 }
 451         }
 452
 453         // au premier coup, on essaye de decomposer, si possible
 454         if (count($cle)==1
 455             AND $c = reset($cle)
 456                 AND is_array($decompose = decompose_champ_id_objet($c))
 457         ){
 458
 459                 $desc = $boucle->show;
 460                 // cas 1 : la cle id_xx est dans la table de depart
 461                 // -> on cherche uniquement id_objet,objet a l'arrivee
 462                 if (isset($desc['field'][$c])){
 463                         $cle = array();
 464                         $cle[] = array_shift($decompose); // id_objet
 465                         $cle[] = array_shift($decompose); // objet
 466                         return trouver_champ_exterieur($cle, $joints, $boucle, $checkarrivee);
 467                 }
 468                         // cas 2 : la cle id_xx n'est pas dans la table de depart
 469                         // -> il faut trouver une cle de depart zzz telle que
 470                         // id_objet,objet,zzz soit a l'arrivee
 471                 else {
 472                         $depart = liste_champs_jointures($desc['table'], $desc);
 473                         foreach ($depart as $d){
 474                                 $cle = array();
 475                                 $cle[] = array_shift($decompose); // id_objet
 476                                 $cle[] = array_shift($decompose); // objet
 477                                 $cle[] = $d;
 478                                 if ($ext = trouver_champ_exterieur($cle, $joints, $boucle, $checkarrivee))
 479                                         return $ext;
 480                         }
 481                 }
 482         }
 483         return "";
 484 }
 485
 486 /**
 487  * Cherche a ajouter la possibilite d'interroger un champ sql
 488  * dans une boucle. Cela construira les jointures necessaires
 489  * si une possibilite est trouve et retournera le nom de
 490  * l'alias de la table contenant ce champ
 491  * (L2 par exemple pour 'spip_mots AS L2' dans le FROM),
 492  *
 493  *
 494  * @param string $champ
 495  *              Nom du champ cherche (exemple id_article)
 496  * @param object $boucle
 497  *              Informations connues de la boucle
 498  * @param array $jointures
 499  *              Liste des tables parcourues (articles, mots) pour retrouver le champ sql
 500  *              et calculer la jointure correspondante.
 501  *              En son absence et par defaut, on utilise la liste des jointures connues
 502  *              par SPIP pour la table en question ($boucle->jointures)
 503  * @param bool $cond
 504  *     flag pour savoir si le critere est conditionnel ou non
 505  *
 506  * @return string
 507  */
 508 function trouver_jointure_champ($champ, &$boucle, $jointures = false, $cond = false) {
 509         if ($jointures === false) {
 510                 $jointures = $boucle->jointures;
 511         }
 512         $cle = trouver_champ_exterieur($champ, $jointures, $boucle);
 513         if ($cle){
 514                 $desc = $boucle->show;
 515                 $cle = calculer_jointure($boucle, array($desc['id_table'], $desc), $cle, '', $cond);
 516         }
 517         if ($cle) return $cle;
 518         spip_log("trouver_jointure_champ: $champ inconnu");
 519         return '';
 520 }
 521
 522 ?>