spip / SPIP

ecrire/public/jointures.php

Indentation +396 added lines, -396 removed lines

@@ -17,7 +17,7 @@ 
  **/
 
 if (!defined('_ECRIRE_INC_VERSION')) {
-	return;
+    return;
 }
 
 
@@ -33,11 +33,11 @@ 
  *     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)];
-	}
+    if (($champ !== 'id_objet') and preg_match(',^id_([a-z_]+)$,', $champ, $regs)) {
+        return ['id_objet', 'objet', objet_type($champ)];
+    }
 
-	return $champ;
+    return $champ;
 }
 
 /**
@@ -56,21 +56,21 @@ 
  *     - 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];
+    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];
 }
 
 
@@ -100,23 +100,23 @@ 
  *     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 ? $col : []);
-	while ($max <= $max_liens and !$res) {
-		$res = calculer_chaine_jointures($boucle, $depart, $arrivee, [], $milieu_exclus, $max);
-		$max++;
-	}
-	if (!$res) {
-		return '';
-	}
-
-	list($nom, $desc) = $depart;
-
-	return fabrique_jointures($boucle, $res, $cond, $desc, $nom, $col);
+    // 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 : []);
+    while ($max <= $max_liens and !$res) {
+        $res = calculer_chaine_jointures($boucle, $depart, $arrivee, [], $milieu_exclus, $max);
+        $max++;
+    }
+    if (!$res) {
+        return '';
+    }
+
+    list($nom, $desc) = $depart;
+
+    return fabrique_jointures($boucle, $res, $cond, $desc, $nom, $col);
 }
 
 /**
@@ -155,79 +155,79 @@ 
  *     Alias de la table de jointure (Lx)
  */
 function fabrique_jointures(&$boucle, $res, $cond = false, $desc = [], $nom = '', $col = '', $echap = true) {
-	static $num = [];
-	$id_table = '';
-	$cpt = &$num[$boucle->descr['nom']][$boucle->descr['gram']][$boucle->id_boucle];
-	foreach ($res as $cle => $r) {
-		list($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'
-			list($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";
+    static $num = [];
+    $id_table = '';
+    $cpt = &$num[$boucle->descr['nom']][$boucle->descr['gram']][$boucle->id_boucle];
+    foreach ($res as $cle => $r) {
+        list($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'
+            list($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";
 }
 
 /**
@@ -242,17 +242,17 @@ 
  * @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));
+    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));
 }
 
 /**
@@ -270,46 +270,46 @@ 
  */
 function liste_champs_jointures($nom, $desc, $primary = false) {
 
-	static $nojoin = ['idx', 'maj', 'date', 'statut'];
+    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']);
-	}
+    // 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'];
+    // 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;
+    // 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;
 }
 
 /**
@@ -320,14 +320,14 @@ 
  * @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;
+    foreach (preg_split('/,\s*/', $v) as $k) {
+        if (strpos($k, '(') !== false) {
+            $k = explode('(', $k);
+            $k = trim(reset($k));
+        }
+        $join[$k] = $k;
+    }
+    return $join;
 }
 
 /**
@@ -350,135 +350,135 @@ 
  * @return array
  */
 function calculer_chaine_jointures(
-	&$boucle,
-	$depart,
-	$arrivee,
-	$vu = [],
-	$milieu_exclus = [],
-	$max_liens = 5
+    &$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';
-	}
-
-	list($dnom, $ddesc) = $depart;
-	list($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 [];
+    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';
+    }
+
+    list($dnom, $ddesc) = $depart;
+    list($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 [];
 }
 
 /**
@@ -489,18 +489,18 @@ 
  * @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);
+    $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);
 }
 
 
@@ -527,34 +527,34 @@ 
  *     - '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;
+    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;
 }
 
 /**
@@ -580,52 +580,52 @@ 
  */
 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((isset($desc['table']) ? $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 '';
+    // 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((isset($desc['table']) ? $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 '';
 }
 
 /**
@@ -657,21 +657,21 @@ 
  * @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 '';
+    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 '';
 }