/***************************************************************************\
* SPIP, Systeme de publication pour l'internet *
* *
- * Copyright (c) 2001-2016 *
+ * Copyright (c) 2001-2017 *
* Arnaud Martin, Antoine Pitrou, Philippe Riviere, Emmanuel Saint-James *
* *
* Ce programme est un logiciel libre distribue sous licence GNU/GPL. *
* Pour plus de details voir le fichier COPYING.txt ou l'aide en ligne. *
\***************************************************************************/
-if (!defined('_ECRIRE_INC_VERSION')) return;
-
-// deduction automatique d'une chaine de jointures
-
/**
- * decomposer un champ id_article en (id_objet,objet,'article') si necessaire
+ * Déduction automatique d'une chaîne de jointures
*
- * @param string $champ
- * @return array ou string
- */
+ * @package SPIP\Core\Compilateur\Jointures
+ **/
+
+if (!defined('_ECRIRE_INC_VERSION')) {
+ return;
+}
+
/**
- * Decomposer un champ id_truc en (id_objet,objet,truc)
- * fonction factorisee ici pour ne pas dupliquer ce code N fois
- * http://doc.spip.org/@decompose_champ_id_objet
+ * Décomposer un champ id_truc en (id_objet,objet,truc)
+ *
+ * Exemple : décompose id_article en (id_objet,objet,article)
*
* @param string $champ
- * @return array
+ * 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)){
+function decompose_champ_id_objet($champ) {
+ if (($champ !== 'id_objet') and preg_match(',^id_([a-z_]+)$,', $champ, $regs)) {
return array('id_objet', 'objet', objet_type($regs[1]));
}
+
return $champ;
}
/**
- * mapping d'un champ d'une jointure en deux champs id_objet,objet si necessaire
+ * Mapping d'un champ d'une jointure en deux champs id_objet,objet si nécessaire
*
- * http://doc.spip.org/@trouver_champs_decomposes
+ * 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.
*
- * @param string $champ
- * @param array $desc
+ * @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){
+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'])
- )
+ or array_key_exists($champ, $desc['field'])
+ ) {
return array($champ);
- if (is_array($decompose = decompose_champ_id_objet($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))
+ if (count(array_intersect($decompose, array_keys($desc['field']))) == count($decompose)) {
return $decompose;
+ }
}
+
return array($champ);
}
/**
- * Calculer et construite une jointure entre depart et arrivee
- * L'objet boucle est modifie pour completer la requete
- * la fonction retourne l'alias d'arrivee une fois la jointure construire
+ * 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"
*
- * http://doc.spip.org/@calculer_jointure
+ * @uses calculer_chaine_jointures()
+ * @uses fabrique_jointures()
*
- * @param object $boucle
+ * @param Boucle $boucle
+ * Description de la boucle
* @param array $depart
- * sous la forme (nom de la table, description de la table)
+ * Table de départ, sous la forme (nom de la table, description de la table)
* @param array $arrivee
- * sous la forme (nom de la table, description de la table)
+ * Table d'arrivée, sous la forme (nom de la table, description de la table)
* @param string $col
- * colonne cible de la jointure
+ * Colonne cible de la jointure
* @param bool $cond
- * flag pour savoir si le critere est conditionnel ou non
+ * 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){
+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?$col:array());
- while ($max<=$max_liens AND !$res){
+ $milieu_exclus = ($col ? $col : array());
+ while ($max <= $max_liens and !$res) {
$res = calculer_chaine_jointures($boucle, $depart, $arrivee, array(), $milieu_exclus, $max);
$max++;
}
- if (!$res) return "";
+ if (!$res) {
+ return "";
+ }
list($nom, $desc) = $depart;
}
/**
- * Fabriquer une jointure a l'aide d'une liste descriptive d'etapes
+ * Fabriquer une jointure à l'aide d'une liste descriptive d'étapes
*
- * http://doc.spip.org/@fabrique_jointures
+ * Ajoute
+ * - la jointure dans le tableau $boucle->join,
+ * - la table de jointure dans le from
+ * - un modificateur 'lien'
*
- * $res = array(
- * array(table_depart,array(table_arrivee,desc),jointure
- * ...
- * )
- * jointure peut etre un tableau pour les jointures sur champ decomposr
- * array('id_article','id_objet','objet','article')
- * array('id_objet','id_article','objet','article')
+ * @uses nogroupby_if()
+ * @uses liste_champs_jointures()
*
- * @param object $boucle
- * objet boucle
+ * @param Boucle $boucle
+ * Description de la boucle
* @param array $res
- * chaine des jointures
+ * 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 critere est conditionnel ou non
+ * Flag pour savoir si le critère est conditionnel ou non
* @param array $desc
- * description de la table de depart
+ * Description de la table de départ
* @param string $nom
- * nom de la table de depart
+ * Nom de la table de départ
* @param string $col
- * colonne cible de la jointure
+ * 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 = array(), $nom = '', $col = '', $echap = true){
+function fabrique_jointures(&$boucle, $res, $cond = false, $desc = array(), $nom = '', $col = '', $echap = true) {
static $num = array();
$id_table = "";
$cpt = &$num[$boucle->descr['nom']][$boucle->descr['gram']][$boucle->id_boucle];
- foreach ($res as $cle => $r){
+ foreach ($res as $cle => $r) {
list($d, $a, $j) = $r;
- if (!$id_table) $id_table = $d;
+ 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'
+ if (is_array($j)) { // c'est un lien sur un champ du type id_objet,objet,'article'
list($j1, $j2, $obj, $type) = $j;
// trouver de quel cote est (id_objet,objet)
- if ($j1=="id_$obj")
+ if ($j1 == "id_$obj") {
$obj = "$id_table.$obj";
- else
+ } else {
$obj = "L$n.$obj";
+ }
// le where complementaire est envoye dans la jointure pour pouvoir etre elimine avec la jointure
// en cas d'optimisation
//$boucle->where[] = array("'='","'$obj'","sql_quote('$type')");
$echap ?
array("'$id_table'", "'$j2'", "'$j1'", "'$obj='.sql_quote('$type')")
:
- array($id_table, $j2, $j1, "$obj=".sql_quote($type));
- }
- else
+ array($id_table, $j2, $j1, "$obj=" . sql_quote($type));
+ } else {
$boucle->join["L$n"] = $echap ? array("'$id_table'", "'$j'") : array($id_table, $j);
+ }
$boucle->from[$id_table = "L$n"] = $a[0];
}
// de l'index principal et de l'index de jointure (non conditionnel! [6031])
// et operateur d'egalite (http://trac.rezo.net/trac/spip/ticket/477)
- if ($pk = (isset($a[1]) && (count($boucle->from)==2) && !$cond)){
+ if ($pk = (isset($a[1]) && (count($boucle->from) == 2) && !$cond)) {
$pk = nogroupby_if($desc, $a[1], $col);
}
// 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'])
- )
+ 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;
+ 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 necessaire
- * A ameliorer, notamment voir si calculer_select ne pourrait pas la reutiliser
- * lorsqu'on sait si le critere conditionnel est finalement present
+ * Condition suffisante pour qu'un Group-By ne soit pas nécéssaire
*
- * http://doc.spip.org/@nogroupby_if
+ * À 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){
+function nogroupby_if($depart, $arrivee, $col) {
$pk = $arrivee['key']['PRIMARY KEY'];
- if (!$pk) return false;
+ if (!$pk) {
+ 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));
+ 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));
}
/**
* 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
- *
- * http://doc.spip.org/@liste_champs_jointures
*
+ * @uses split_key()
* @param string $nom
* @param array $desc
* @param bool $primary
* @return array
*/
-function liste_champs_jointures($nom, $desc, $primary = false){
+function liste_champs_jointures($nom, $desc, $primary = false) {
static $nojoin = array('idx', 'maj', 'date', 'statut');
// si cle primaire demandee, la privilegier
- if ($primary && isset($desc['key']['PRIMARY KEY']))
+ 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'];
+ 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 array();
+ if (!isset($desc['key'])) {
+ return array();
+ }
// si cle primaire
- if (isset($desc['key']['PRIMARY KEY']))
+ 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)
// il faut declarer explicitement le champ 'join' de sa description
$join = array();
- foreach ($desc['key'] as $v) $join = split_key($v, $join);
- foreach ($join as $k) if (in_array($k, $nojoin)) unset($join[$k]);
+ 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
*
- * http://doc.spip.org/@split_key
- *
* @param string $v
* @param array $join
* @return array
*/
-function split_key($v, $join = array()){
- foreach (preg_split('/,\s*/', $v) as $k) $join[$k] = $k;
+function split_key($v, $join = array()) {
+ 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
*
- * http://doc.spip.org/@calculer_chaine_jointures
+ * @uses liste_champs_jointures()
+ * @uses trouver_champs_decomposes()
*
* @param objetc $boucle
* @param array $depart
* nombre maxi d'etapes
* @return array
*/
-function calculer_chaine_jointures(&$boucle, $depart, $arrivee, $vu = array(), $milieu_exclus = array(), $max_liens = 5){
+function calculer_chaine_jointures(
+ &$boucle,
+ $depart,
+ $arrivee,
+ $vu = array(),
+ $milieu_exclus = array(),
+ $max_liens = 5
+) {
static $trouver_table;
- if (!$trouver_table)
+ if (!$trouver_table) {
$trouver_table = charger_fonction('trouver_table', 'base');
+ }
- if (is_string($milieu_exclus))
+ if (is_string($milieu_exclus)) {
$milieu_exclus = array($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))
+ if (in_array('id_objet', $milieu_exclus) and !in_array('objet', $milieu_exclus)) {
$milieu_exclus[] = 'objet';
+ }
list($dnom, $ddesc) = $depart;
list($anom, $adesc) = $arrivee;
- if (!count($vu)){
+ if (!count($vu)) {
$vu[] = $dnom; // ne pas oublier la table de depart
$vu[] = $anom; // ne pas oublier la table d'arrivee
}
$v = !$keys ? false : array_intersect(array_values($keys), $akeys);
- if ($v)
+ if ($v) {
return array(array($dnom, array($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(array('id_objet', 'objet'), $keys))==2){
+ if (count(array_intersect(array('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){
+ foreach ($akeys as $key) {
$v = decompose_champ_id_objet($key);
- if (is_array($v)){
+ 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 array(array($dnom, array($adesc['table'], $adesc), $v));
}
}
- }
- else {
+ } 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))){
+ 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 array(array($dnom, array($adesc['table'], $adesc), $v));
}
}
// si l'on voulait une jointure direct, c'est rate !
- if ($max_liens<=1) return array();
+ if ($max_liens <= 1) {
+ return array();
+ }
// sinon essayer de passer par une autre table
$new = $vu;
- foreach ($boucle->jointures as $v){
+ 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)
- ){
+ 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, array($v, $def), $vu, $test_cles, 1))
- AND $max_iter--){
+ while (count($jointure_directe_possible = calculer_chaine_jointures($boucle, $depart, array($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)){
+ if (is_string($milieu)) {
$exclure_fin[] = $milieu;
$test_cles[] = $milieu;
- }
- else{
+ } 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, array($v, $def), $arrivee, $new, $exclure_fin, $max_liens-1);
- if ($r){
+ $r = calculer_chaine_jointures($boucle, array($v, $def), $arrivee, $new, $exclure_fin, $max_liens - 1);
+ if ($r) {
array_unshift($r, $jointure_directe_possible);
+
return $r;
}
}
}
}
+
return array();
}
* applatit les cles multiples
* redondance avec split_key() ? a mutualiser
*
- * http://doc.spip.org/@trouver_cles_table
- *
* @param $keys
* @return array
*/
-function trouver_cles_table($keys){
+function trouver_cles_table($keys) {
$res = array();
- foreach ($keys as $v){
- if (!strpos($v, ","))
+ foreach ($keys as $v) {
+ if (!strpos($v, ",")) {
$res[$v] = 1;
- else {
- foreach (preg_split("/\s*,\s*/", $v) as $k){
+ } else {
+ foreach (preg_split("/\s*,\s*/", $v) as $k) {
$res[$k] = 1;
}
}
}
+
return array_keys($res);
}
+
/**
- * http://doc.spip.org/@trouver_champ_exterieur
+ * Indique si une colonne (ou plusieurs colonnes) est présente dans l'une des tables indiquée.
*
* @param string|array $cle
- * @param array $joints
- * @param object $boucle
- * @param bool $checkarrivee
- * @return array|string
+ * 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 trouver_champ_exterieur($cle, $joints, &$boucle, $checkarrivee = false){
+function chercher_champ_dans_tables($cle, $tables, $connect, $checkarrivee = false) {
static $trouver_table = '';
- if (!$trouver_table)
+ if (!$trouver_table) {
$trouver_table = charger_fonction('trouver_table', 'base');
+ }
+
+ if (!is_array($cle)) {
+ $cle = array($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 array(
+ '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))
+ if (!is_array($cle)) {
$cle = array($cle);
+ }
- foreach ($joints as $k => $join){
- if ($join && $table = $trouver_table($join, $boucle->sql_serveur)){
- if (isset($table['field'])
- // verifier que toutes les cles cherchees sont la
- AND (count(array_intersect($cle, array_keys($table['field'])))==count($cle))
- // si on sait ou on veut arriver, il faut que ca colle
- AND ($checkarrivee==false || $checkarrivee==$table['table'])
- )
- return array($table['table'], $table);
- }
+ if ($infos = chercher_champ_dans_tables($cle, $joints, $boucle->sql_serveur, $checkarrivee)) {
+ return array($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))
- ){
+ 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])){
+ if (isset($desc['field'][$c])) {
$cle = array();
$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
+ // 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){
+ $depart = liste_champs_jointures((isset($desc['table']) ? $desc['table'] : ''), $desc);
+ foreach ($depart as $d) {
$cle = array();
$cle[] = array_shift($decompose); // id_objet
$cle[] = array_shift($decompose); // objet
$cle[] = $d;
- if ($ext = trouver_champ_exterieur($cle, $joints, $boucle, $checkarrivee))
+ 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
+ * 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)
+ * Nom du champ cherche (exemple id_article)
* @param object $boucle
- * Informations connues de la 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)
+ * 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) {
+function trouver_jointure_champ($champ, &$boucle, $jointures = false, $cond = false, $checkarrivee = false) {
if ($jointures === false) {
$jointures = $boucle->jointures;
}
- $cle = trouver_champ_exterieur($champ, $jointures, $boucle);
- if ($cle){
+ // 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;
- $cle = calculer_jointure($boucle, array($desc['id_table'], $desc), $cle, '', $cond);
+ array_pop($arrivee); // enlever la cle en 3eme argument
+ $cle = calculer_jointure($boucle, array($desc['id_table'], $desc), $arrivee, '', $cond);
+ if ($cle) {
+ return $cle;
+ }
}
- if ($cle) return $cle;
spip_log("trouver_jointure_champ: $champ inconnu");
+
return '';
}
-
-?>
dépôts / lhc / web / www.git / blobdiff