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/univers/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 '';
}