3 /***************************************************************************\
4 * SPIP, Systeme de publication pour l'internet *
6 * Copyright (c) 2001-2016 *
7 * Arnaud Martin, Antoine Pitrou, Philippe Riviere, Emmanuel Saint-James *
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 \***************************************************************************/
13 if (!defined('_ECRIRE_INC_VERSION')) return;
15 // deduction automatique d'une chaine de jointures
18 * decomposer un champ id_article en (id_objet,objet,'article') si necessaire
20 * @param string $champ
21 * @return array ou string
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
29 * @param string $champ
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]));
40 * mapping d'un champ d'une jointure en deux champs id_objet,objet si necessaire
42 * http://doc.spip.org/@trouver_champs_decomposes
44 * @param string $champ
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'])
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))
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
68 * http://doc.spip.org/@calculer_jointure
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)
76 * colonne cible de la jointure
78 * flag pour savoir si le critere est conditionnel ou non
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
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);
94 list($nom, $desc) = $depart;
96 return fabrique_jointures($boucle, $res, $cond, $desc, $nom, $col);
100 * Fabriquer une jointure a l'aide d'une liste descriptive d'etapes
102 * http://doc.spip.org/@fabrique_jointures
105 * array(table_depart,array(table_arrivee,desc),jointure
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')
112 * @param object $boucle
115 * chaine des jointures
117 * flag pour savoir si le critere est conditionnel ou non
119 * description de la table de depart
121 * nom de la table de depart
123 * colonne cible de la jointure
127 function fabrique_jointures(&$boucle, $res, $cond = false, $desc = array(), $nom = '', $col = '', $echap = true){
128 static $num = array();
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;
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)
139 $obj = "$id_table.$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"] =
147 array("'$id_table'", "'$j2'", "'$j1'", "'$obj='.sql_quote('$type')")
149 array($id_table, $j2, $j1, "$obj=".sql_quote($type));
152 $boucle->join
["L$n"] = $echap ?
array("'$id_table'", "'$j'") : array($id_table, $j);
153 $boucle->from
[$id_table = "L$n"] = $a[0];
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)
163 if ($pk = (isset($a[1]) && (count($boucle->from
)==2) && !$cond)){
164 $pk = nogroupby_if($desc, $a[1], $col);
168 // si une seule jointure
169 // et si l'index de jointure est une primary key a l'arrivee !
171 AND (count($boucle->from
)==2)
172 AND isset($a[1]['key']['PRIMARY KEY'])
173 AND ($j==$a[1]['key']['PRIMARY KEY'])
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;
186 $boucle->modificateur
['lien'] = true;
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
195 * http://doc.spip.org/@nogroupby_if
197 * @param array $depart
198 * @param array $arrivee
199 * @param string|array $col
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));
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
216 * sinon on construit une liste des champs a partir de la liste des cles de la table
218 * http://doc.spip.org/@liste_champs_jointures
222 * @param bool $primary
225 function liste_champs_jointures($nom, $desc, $primary = false){
227 static $nojoin = array('idx', 'maj', 'date', 'statut');
229 // si cle primaire demandee, la privilegier
230 if ($primary && isset($desc['key']['PRIMARY KEY']))
231 return split_key($desc['key']['PRIMARY KEY']);
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'];*/
238 // si pas de cle, c'est fichu
239 if (!isset($desc['key'])) return array();
242 if (isset($desc['key']['PRIMARY KEY']))
243 return split_key($desc['key']['PRIMARY KEY']);
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
251 foreach ($desc['key'] as $v) $join = split_key($v, $join);
252 foreach ($join as $k) if (in_array($k, $nojoin)) unset($join[$k]);
257 * Eclater une cle composee en plusieurs champs
259 * http://doc.spip.org/@split_key
265 function split_key($v, $join = array()){
266 foreach (preg_split('/,\s*/', $v) as $k) $join[$k] = $k;
271 * Constuire la chaine de jointures, de proche en proche
273 * http://doc.spip.org/@calculer_chaine_jointures
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)
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
288 function calculer_chaine_jointures(&$boucle, $depart, $arrivee, $vu = array(), $milieu_exclus = array(), $max_liens = 5){
289 static $trouver_table;
291 $trouver_table = charger_fonction('trouver_table', 'base');
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';
300 list($dnom, $ddesc) = $depart;
301 list($anom, $adesc) = $arrivee;
303 $vu[] = $dnom; // ne pas oublier la table de depart
304 $vu[] = $anom; // ne pas oublier la table d'arrivee
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));
313 // enlever les cles d'arrivee exclues par l'appel
314 $akeys = array_diff($akeys, $milieu_exclus);
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);
321 $v = !$keys ?
false : array_intersect(array_values($keys), $akeys);
324 return array(array($dnom, array($adesc['table'], $adesc), array_shift($v)));
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
330 // si oui on la prend
331 foreach ($akeys as $key){
332 $v = decompose_champ_id_objet($key);
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));
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));
355 // si l'on voulait une jointure direct, c'est rate !
356 if ($max_liens<=1) return array();
358 // sinon essayer de passer par une autre table
360 foreach ($boucle->jointures
as $v){
362 AND !in_array($v, $vu)
363 AND $def = $trouver_table($v, $boucle->sql_serveur
)
364 AND !in_array($def['table_sql'], $vu)
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;
370 $max_iter = 50; // securite
371 while (count($jointure_directe_possible = calculer_chaine_jointures($boucle, $depart, array($v, $def), $vu, $test_cles, 1))
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;
381 $exclure_fin = array_merge($exclure_fin, $milieu);
382 $test_cles = array_merge($test_cles, $milieu);
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);
388 array_unshift($r, $jointure_directe_possible);
398 * applatit les cles multiples
399 * redondance avec split_key() ? a mutualiser
401 * http://doc.spip.org/@trouver_cles_table
406 function trouver_cles_table($keys){
408 foreach ($keys as $v){
409 if (!strpos($v, ","))
412 foreach (preg_split("/\s*,\s*/", $v) as $k){
417 return array_keys($res);
421 * http://doc.spip.org/@trouver_champ_exterieur
423 * @param string|array $cle
424 * @param array $joints
425 * @param object $boucle
426 * @param bool $checkarrivee
427 * @return array|string
429 function trouver_champ_exterieur($cle, $joints, &$boucle, $checkarrivee = false){
430 static $trouver_table = '';
432 $trouver_table = charger_fonction('trouver_table', 'base');
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
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'])
449 return array($table['table'], $table);
453 // au premier coup, on essaye de decomposer, si possible
456 AND is_array($decompose = decompose_champ_id_objet($c))
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])){
464 $cle[] = array_shift($decompose); // id_objet
465 $cle[] = array_shift($decompose); // objet
466 return trouver_champ_exterieur($cle, $joints, $boucle, $checkarrivee);
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
472 $depart = liste_champs_jointures($desc['table'], $desc);
473 foreach ($depart as $d){
475 $cle[] = array_shift($decompose); // id_objet
476 $cle[] = array_shift($decompose); // objet
478 if ($ext = trouver_champ_exterieur($cle, $joints, $boucle, $checkarrivee))
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),
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)
504 * flag pour savoir si le critere est conditionnel ou non
508 function trouver_jointure_champ($champ, &$boucle, $jointures = false, $cond = false) {
509 if ($jointures === false) {
510 $jointures = $boucle->jointures
;
512 $cle = trouver_champ_exterieur($champ, $jointures, $boucle);
514 $desc = $boucle->show
;
515 $cle = calculer_jointure($boucle, array($desc['id_table'], $desc), $cle, '', $cond);
517 if ($cle) return $cle;
518 spip_log("trouver_jointure_champ: $champ inconnu");