Server : Apache System : Linux webd348.cluster026.gra.hosting.ovh.net 5.15.148-ovh-vps-grsec-zfs-classid #1 SMP Thu Feb 8 09:41:04 UTC 2024 x86_64 User : hednacluml ( 122243) PHP Version : 8.3.9 Disable Function : _dyuweyrj4,_dyuweyrj4r,dl Directory : /home/hednacluml/chretien/ecrire/public/ |
<?php use Spip\Compilateur\Noeud\Boucle; /***************************************************************************\ * SPIP, Système de publication pour l'internet * * * * Copyright © avec tendresse depuis 2001 * * Arnaud Martin, Antoine Pitrou, Philippe Rivière, Emmanuel Saint-James * * * * Ce programme est un logiciel libre distribué sous licence GNU/GPL. * \***************************************************************************/ /** * Déduction automatique d'une chaîne de jointures * * @package SPIP\Core\Compilateur\Jointures **/ if (!defined('_ECRIRE_INC_VERSION')) { return; } /** * Décomposer un champ id_truc en (id_objet,objet,truc) * * Exemple : décompose id_article en (id_objet,objet,article) * * @param string $champ * Nom du champ à décomposer * @return array|string * Tableau si décomposable : 'id_objet', 'objet', Type de l'objet * Chaine sinon : le nom du champ (non décomposable donc) */ function decompose_champ_id_objet($champ) { if (($champ !== 'id_objet') and preg_match(',^id_([a-z_]+)$,', $champ, $regs)) { return ['id_objet', 'objet', objet_type($champ)]; } return $champ; } /** * Mapping d'un champ d'une jointure en deux champs id_objet,objet si nécessaire * * Si le champ demandé existe dans la table, on l'utilise, sinon on * regarde si le champ se décompose en objet/id_objet et si la table * possède ces champs, et dans ce cas, on les retourne. * * @uses decompose_champ_id_objet() * @param string $champ Nom du champ à tester (ex. id_article) * @param array $desc Description de la table * @return array * Liste du/des champs. Soit * - array($champ), si le champ existe dans la table ou si on ne peut décomposer. * - array(id_objet, objet), si le champ n'existe pas mais qu'on peut décomposer */ function trouver_champs_decomposes($champ, $desc) { if ( !is_array($desc) // on ne se risque pas en conjectures si on ne connait pas la table or array_key_exists($champ, $desc['field']) ) { return [$champ]; } // si le champ se décompose, tester que les colonnes décomposées sont présentes if (is_array($decompose = decompose_champ_id_objet($champ))) { array_pop($decompose); if (count(array_intersect($decompose, array_keys($desc['field']))) == count($decompose)) { return $decompose; } } return [$champ]; } /** * Calculer et construite une jointure entre $depart et $arrivee * * L'objet boucle est modifié pour compléter la requête. * La fonction retourne l'alias d'arrivée une fois la jointure construire, * en general un "Lx" * * @uses calculer_chaine_jointures() * @uses fabrique_jointures() * * @param Boucle $boucle * Description de la boucle * @param array $depart * Table de départ, sous la forme (nom de la table, description de la table) * @param array $arrivee * Table d'arrivée, sous la forme (nom de la table, description de la table) * @param string $col * Colonne cible de la jointure * @param bool $cond * Flag pour savoir si le critère est conditionnel ou non * @param int $max_liens * Nombre maximal de liaisons possibles pour trouver la jointure. * @return string * Alias de la table de jointure (Lx) */ function calculer_jointure(&$boucle, $depart, $arrivee, $col = '', $cond = false, $max_liens = 5) { // les jointures minimales sont optimales : // on contraint le nombre d'etapes en l'augmentant // jusqu'a ce qu'on trouve une jointure ou qu'on atteigne la limite maxi $max = 1; $res = false; $milieu_exclus = ($col ?: []); while ($max <= $max_liens and !$res) { $res = calculer_chaine_jointures($boucle, $depart, $arrivee, [], $milieu_exclus, $max); $max++; } if (!$res) { return ''; } [$nom, $desc] = $depart; return fabrique_jointures($boucle, $res, $cond, $desc, $nom, $col); } /** * Fabriquer une jointure à l'aide d'une liste descriptive d'étapes * * Ajoute * - la jointure dans le tableau $boucle->join, * - la table de jointure dans le from * - un modificateur 'lien' * * @uses nogroupby_if() * @uses liste_champs_jointures() * * @param Boucle $boucle * Description de la boucle * @param array $res * Chaîne des jointures * $res = array( * array(table_depart,array(table_arrivee,desc),jointure), * ... * ) * Jointure peut être un tableau pour les jointures sur champ decomposé * array('id_article','id_objet','objet','article') * array('id_objet','id_article','objet','article') * @param bool $cond * Flag pour savoir si le critère est conditionnel ou non * @param array $desc * Description de la table de départ * @param string $nom * Nom de la table de départ * @param string $col * Colonne cible de la jointure * @param bool $echap * Écrire les valeurs dans boucle->join en les échappant ou non ? * @return string * Alias de la table de jointure (Lx) */ function fabrique_jointures(&$boucle, $res, $cond = false, $desc = [], $nom = '', $col = '', $echap = true) { $a = []; $j = null; $n = null; static $num = []; $id_table = ''; $cpt = &$num[$boucle->descr['nom']][$boucle->descr['gram']][$boucle->id_boucle]; foreach ($res as $cle => $r) { [$d, $a, $j] = $r; if (!$id_table) { $id_table = $d; } $n = ++$cpt; if (is_array($j)) { // c'est un lien sur un champ du type id_objet,objet,'article' [$j1, $j2, $obj, $type] = $j; // trouver de quel cote est (id_objet,objet) if ($j1 == "id_$obj") { $obj = "$id_table.$obj"; } else { $obj = "L$n.$obj"; } // le where complementaire est envoye dans la jointure et dans le where // on utilise une clé qui le relie a la jointure pour que l'optimiseur // sache qu'il peut enlever ce where si il enleve la jointure $boucle->where["JOIN-L$n"] = $echap ? ["'='","'$obj'","sql_quote('$type')"] : ['=',"$obj",sql_quote($type)]; $boucle->join["L$n"] = $echap ? ["'$id_table'", "'$j2'", "'$j1'", "'$obj='.sql_quote('$type')"] : [$id_table, $j2, $j1, "$obj=" . sql_quote($type)]; } else { $boucle->join["L$n"] = $echap ? ["'$id_table'", "'$j'"] : [$id_table, $j]; } $boucle->from[$id_table = "L$n"] = $a[0]; } // pas besoin de group by // (cf http://article.gmane.org/gmane.comp.web.spip.devel/30555) // si une seule jointure et sur une table avec primary key formee // de l'index principal et de l'index de jointure (non conditionnel! [6031]) // et operateur d'egalite (https://core.spip.net/issues/477) if ($pk = (isset($a[1]) && (count($boucle->from) == 2) && !$cond)) { $pk = nogroupby_if($desc, $a[1], $col); } // pas de group by // si une seule jointure // et si l'index de jointure est une primary key a l'arrivee ! if ( !$pk and (count($boucle->from) == 2) and isset($a[1]['key']['PRIMARY KEY']) and ($j == $a[1]['key']['PRIMARY KEY']) ) { $pk = true; } // la clause Group by est en conflit avec ORDER BY, a completer $groups = liste_champs_jointures($nom, $desc, true); if (!$pk) { foreach ($groups as $id_prim) { $id_field = $nom . '.' . $id_prim; if (!in_array($id_field, $boucle->group)) { $boucle->group[] = $id_field; } } } $boucle->modificateur['lien'] = true; return "L$n"; } /** * Condition suffisante pour qu'un Group-By ne soit pas nécéssaire * * À améliorer, notamment voir si calculer_select ne pourrait pas la réutiliser * lorsqu'on sait si le critere conditionnel est finalement present * * @param array $depart * @param array $arrivee * @param string|array $col * @return bool */ function nogroupby_if($depart, $arrivee, $col) { if ( empty($arrivee['key']['PRIMARY KEY']) or !($pk = $arrivee['key']['PRIMARY KEY']) or empty($depart['key']['PRIMARY KEY']) ) { return false; } $id_primary = $depart['key']['PRIMARY KEY']; if (is_array($col)) { $col = implode(', *', $col); } // cas id_objet, objet return (preg_match("/^$id_primary, *$col$/", $pk) or preg_match("/^$col, *$id_primary$/", $pk)); } /** * Lister les champs candidats a une jointure, sur une table * si un join est fourni dans la description, c'est lui qui l'emporte * sauf si cle primaire explicitement demandee par $primary * * sinon on construit une liste des champs a partir de la liste des cles de la table * * @uses split_key() * @param string $nom * @param array $desc * @param bool $primary * @return array */ function liste_champs_jointures($nom, $desc, $primary = false) { static $nojoin = ['idx', 'maj', 'date', 'statut']; // si cle primaire demandee, la privilegier if ($primary && isset($desc['key']['PRIMARY KEY'])) { return split_key($desc['key']['PRIMARY KEY']); } // les champs declares explicitement pour les jointures if (isset($desc['join'])) { return $desc['join']; } /*elseif (isset($GLOBALS['tables_principales'][$nom]['join'])) return $GLOBALS['tables_principales'][$nom]['join']; elseif (isset($GLOBALS['tables_auxiliaires'][$nom]['join'])) return $GLOBALS['tables_auxiliaires'][$nom]['join'];*/ // si pas de cle, c'est fichu if (!isset($desc['key'])) { return []; } // si cle primaire if (isset($desc['key']['PRIMARY KEY'])) { return split_key($desc['key']['PRIMARY KEY']); } // ici on se rabat sur les cles secondaires, // en eliminant celles qui sont pas pertinentes (idx, maj) // si jamais le resultat n'est pas pertinent pour une table donnee, // il faut declarer explicitement le champ 'join' de sa description $join = []; foreach ($desc['key'] as $v) { $join = split_key($v, $join); } foreach ($join as $k) { if (in_array($k, $nojoin)) { unset($join[$k]); } } return $join; } /** * Eclater une cle composee en plusieurs champs * * @param string $v * @param array $join * @return array */ function split_key($v, $join = []) { foreach (preg_split('/,\s*/', $v) as $k) { if (strpos($k, '(') !== false) { $k = explode('(', $k); $k = trim(reset($k)); } $join[$k] = $k; } return $join; } /** * Constuire la chaine de jointures, de proche en proche * * @uses liste_champs_jointures() * @uses trouver_champs_decomposes() * * @param objetc $boucle * @param array $depart * sous la forme array(nom de la table, description) * @param array $arrivee * sous la forme array(nom de la table, description) * @param array $vu * tables deja vues dans la jointure, pour ne pas y repasser * @param array $milieu_exclus * cles deja utilisees, pour ne pas les reutiliser * @param int $max_liens * nombre maxi d'etapes * @return array */ function calculer_chaine_jointures( &$boucle, $depart, $arrivee, $vu = [], $milieu_exclus = [], $max_liens = 5 ) { static $trouver_table; if (!$trouver_table) { $trouver_table = charger_fonction('trouver_table', 'base'); } if (is_string($milieu_exclus)) { $milieu_exclus = [$milieu_exclus]; } // quand on a exclus id_objet comme cle de jointure, il faut aussi exclure objet // faire une jointure sur objet tout seul n'a pas de sens if (in_array('id_objet', $milieu_exclus) and !in_array('objet', $milieu_exclus)) { $milieu_exclus[] = 'objet'; } [$dnom, $ddesc] = $depart; [$anom, $adesc] = $arrivee; if (!count($vu)) { $vu[] = $dnom; // ne pas oublier la table de depart $vu[] = $anom; // ne pas oublier la table d'arrivee } $akeys = []; foreach ($adesc['key'] as $k) { // respecter l'ordre de $adesc['key'] pour ne pas avoir id_trad en premier entre autres... $akeys = array_merge($akeys, preg_split('/,\s*/', $k)); } // enlever les cles d'arrivee exclues par l'appel $akeys = array_diff($akeys, $milieu_exclus); // cles candidates au depart $keys = liste_champs_jointures($dnom, $ddesc); // enlever les cles dde depart exclues par l'appel $keys = array_diff($keys, $milieu_exclus); $v = !$keys ? false : array_intersect(array_values($keys), $akeys); if ($v) { return [[$dnom, [$adesc['table'], $adesc], array_shift($v)]]; } // regarder si l'on a (id_objet,objet) au depart et si on peut le mapper sur un id_xx if (count(array_intersect(['id_objet', 'objet'], $keys)) == 2) { // regarder si l'une des cles d'arrivee peut se decomposer en // id_objet,objet // si oui on la prend foreach ($akeys as $key) { $v = decompose_champ_id_objet($key); if (is_array($v)) { $objet = array_shift($v); // objet,'article' array_unshift($v, $key); // id_article,objet,'article' array_unshift($v, $objet); // id_objet,id_article,objet,'article' return [[$dnom, [$adesc['table'], $adesc], $v]]; } } } else { // regarder si l'une des cles de depart peut se decomposer en // id_objet,objet a l'arrivee // si oui on la prend foreach ($keys as $key) { if (count($v = trouver_champs_decomposes($key, $adesc)) > 1) { if (count($v) == count(array_intersect($v, $akeys))) { $v = decompose_champ_id_objet($key); // id_objet,objet,'article' array_unshift($v, $key); // id_article,id_objet,objet,'article' return [[$dnom, [$adesc['table'], $adesc], $v]]; } } } } // si l'on voulait une jointure direct, c'est rate ! if ($max_liens <= 1) { return []; } // sinon essayer de passer par une autre table $new = $vu; foreach ($boucle->jointures as $v) { if ( $v and !in_array($v, $vu) and $def = $trouver_table($v, $boucle->sql_serveur) and !in_array($def['table_sql'], $vu) ) { // ne pas tester les cles qui sont exclues a l'appel // ie la cle de la jointure precedente $test_cles = $milieu_exclus; $new[] = $v; $max_iter = 50; // securite while ( count($jointure_directe_possible = calculer_chaine_jointures( $boucle, $depart, [$v, $def], $vu, $test_cles, 1 )) and $max_iter-- ) { $jointure_directe_possible = reset($jointure_directe_possible); $milieu = end($jointure_directe_possible); $exclure_fin = $milieu_exclus; if (is_string($milieu)) { $exclure_fin[] = $milieu; $test_cles[] = $milieu; } else { $exclure_fin = array_merge($exclure_fin, $milieu); $test_cles = array_merge($test_cles, $milieu); } // essayer de rejoindre l'arrivee a partir de cette etape intermediaire // sans repasser par la meme cle milieu, ni une cle deja vue ! $r = calculer_chaine_jointures($boucle, [$v, $def], $arrivee, $new, $exclure_fin, $max_liens - 1); if ($r) { array_unshift($r, $jointure_directe_possible); return $r; } } } } return []; } /** * applatit les cles multiples * redondance avec split_key() ? a mutualiser * * @param $keys * @return array */ function trouver_cles_table($keys) { $res = []; foreach ($keys as $v) { if (!strpos($v, ',')) { $res[$v] = 1; } else { foreach (preg_split('/\s*,\s*/', $v) as $k) { $res[$k] = 1; } } } return array_keys($res); } /** * Indique si une colonne (ou plusieurs colonnes) est présente dans l'une des tables indiquée. * * @param string|array $cle * Nom de la ou des colonnes à trouver dans les tables indiquées * @param array $tables * Liste de noms de tables ou des couples (alias => nom de table). * - `$boucle->from` (alias => nom de table) : les tables déjà utilisées dans une boucle * - `$boucle->jointures` : les tables utilisables en tant que jointure * - `$boucle->jointures_explicites` les jointures explicitement indiquées à l'écriture de la boucle * @param string $connect * Nom du connecteur SQL * @param bool|string $checkarrivee * false : peu importe la table, si on trouve le/les champs, c'est bon. * string : nom de la table où on veut trouver le champ. * @return array|false * false : on n'a pas trouvé * array : infos sur la table trouvée. Les clés suivantes sont retournés : * - 'desc' : tableau de description de la table, * - 'table' : nom de la table * - 'alias' : alias utilisé pour la table (si pertinent. ie: avec `$boucle->from` transmis par exemple) */ function chercher_champ_dans_tables($cle, $tables, $connect, $checkarrivee = false) { static $trouver_table = ''; if (!$trouver_table) { $trouver_table = charger_fonction('trouver_table', 'base'); } if (!is_array($cle)) { $cle = [$cle]; } foreach ($tables as $k => $table) { if ($table && $desc = $trouver_table($table, $connect)) { if ( isset($desc['field']) // verifier que toutes les cles cherchees sont la and (count(array_intersect($cle, array_keys($desc['field']))) == count($cle)) // si on sait ou on veut arriver, il faut que ca colle and ($checkarrivee == false || $checkarrivee == $desc['table']) ) { return [ 'desc' => $desc, 'table' => $desc['table'], 'alias' => $k, ]; } } } return false; } /** * Cherche une colonne (ou plusieurs colonnes) dans les tables de jointures * possibles indiquées. * * @uses chercher_champ_dans_tables() * @uses decompose_champ_id_objet() * @uses liste_champs_jointures() * * @param string|array $cle * Nom de la ou des colonnes à trouver dans les tables de jointures * @param array $joints * Liste des jointures possibles (ex: $boucle->jointures ou $boucle->jointures_explicites) * @param Boucle $boucle * Description de la boucle * @param bool|string $checkarrivee * false : peu importe la table, si on trouve le/les champs, c'est bon. * string : nom de la table jointe où on veut trouver le champ. * @return array|string * chaîne vide : on n'a pas trouvé * liste si trouvé : nom de la table, description de la table, clé(s) de la table */ function trouver_champ_exterieur($cle, $joints, &$boucle, $checkarrivee = false) { // support de la recherche multi champ : // si en seconde etape on a decompose le champ id_xx en id_objet,objet // on reentre ici soit en cherchant une table les 2 champs id_objet,objet // soit une table avec les 3 champs id_xx, id_objet, objet if (!is_array($cle)) { $cle = [$cle]; } if ($infos = chercher_champ_dans_tables($cle, $joints, $boucle->sql_serveur, $checkarrivee)) { return [$infos['table'], $infos['desc'], $cle]; } // au premier coup, on essaye de decomposer, si possible if ( count($cle) == 1 and $c = reset($cle) and is_array($decompose = decompose_champ_id_objet($c)) ) { $desc = $boucle->show; // cas 1 : la cle id_xx est dans la table de depart // -> on cherche uniquement id_objet,objet a l'arrivee if (isset($desc['field'][$c])) { $cle = []; $cle[] = array_shift($decompose); // id_objet $cle[] = array_shift($decompose); // objet return trouver_champ_exterieur($cle, $joints, $boucle, $checkarrivee); } // cas 2 : la cle id_xx n'est pas dans la table de depart // -> il faut trouver une cle de depart zzz telle que // id_objet,objet,zzz soit a l'arrivee else { $depart = liste_champs_jointures(($desc['table'] ?? ''), $desc); foreach ($depart as $d) { $cle = []; $cle[] = array_shift($decompose); // id_objet $cle[] = array_shift($decompose); // objet $cle[] = $d; if ($ext = trouver_champ_exterieur($cle, $joints, $boucle, $checkarrivee)) { return $ext; } } } } return ''; } /** * Cherche a ajouter la possibilite d'interroger un champ sql dans une boucle. * * Cela construira les jointures necessaires * si une possibilite est trouve et retournera le nom de * l'alias de la table contenant ce champ * (L2 par exemple pour 'spip_mots AS L2' dans le FROM), * * @uses trouver_champ_exterieur() * @uses calculer_jointure() * * @param string $champ * Nom du champ cherche (exemple id_article) * @param object $boucle * Informations connues de la boucle * @param array $jointures * Liste des tables parcourues (articles, mots) pour retrouver le champ sql * et calculer la jointure correspondante. * En son absence et par defaut, on utilise la liste des jointures connues * par SPIP pour la table en question ($boucle->jointures) * @param bool $cond * flag pour savoir si le critere est conditionnel ou non * @param bool|string $checkarrivee * false : peu importe la table, si on trouve le/les champs, c'est bon. * string : nom de la table jointe où on veut trouver le champ. * * @return string */ function trouver_jointure_champ($champ, &$boucle, $jointures = false, $cond = false, $checkarrivee = false) { if ($jointures === false) { $jointures = $boucle->jointures; } // TODO : aberration, on utilise $jointures pour trouver le champ // mais pas poour construire la jointure ensuite $arrivee = trouver_champ_exterieur($champ, $jointures, $boucle, $checkarrivee); if ($arrivee) { $desc = $boucle->show; array_pop($arrivee); // enlever la cle en 3eme argument $cle = calculer_jointure($boucle, [$desc['id_table'], $desc], $arrivee, '', $cond); if ($cle) { return $cle; } } spip_log("trouver_jointure_champ: $champ inconnu"); return ''; }