Subversion Repositories Sites.tela-botanica.org

<?php

/***************************************************************************\

 *  SPIP, Systeme de publication pour l'internet                           *

 *                                                                         *

 *  Copyright (c) 2001-2005                                                *

 *  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.   *

\***************************************************************************/

//

// Definition des {criteres} d'une boucle

//

// Ce fichier ne sera execute qu'une fois

if (defined("_INC_CRITERES")) return;

define("_INC_CRITERES", "1");

// {racine}

// http://www.spip.net/@racine

function critere_racine_dist($idb, &$boucles, $crit) {

	$not = $crit->not;

	$boucle = &$boucles[$idb];

	if ($not)

		erreur_squelette(_T('zbug_info_erreur_squelette'), $param);

	$boucle->where[] = $boucle->id_table.".id_parent='0'";

}

// {exclus}

// http://www.spip.net/@exclus

function critere_exclus_dist($idb, &$boucles, $crit) {

	$param = $crit->op;

	$not = $crit->not;

	$boucle = &$boucles[$idb];

	$id = $boucle->primary;

	if ($not OR !$id)

		erreur_squelette(_T('zbug_info_erreur_squelette'), $param);

	$arg = calculer_argument_precedent($idb,$id, $boucles);

	$boucle->where[] = $boucle->id_table . '.' . $id."!='\"." . $arg . ".\"'";

}

// {doublons} ou {unique}

// http://www.spip.net/@doublons

// attention: boucle->doublons designe une variable qu'on affecte

function critere_doublons_dist($idb, &$boucles, $crit) {

	$boucle = &$boucles[$idb];

	$boucle->where[] = '" .' .

	  "calcul_mysql_in('".$boucle->id_table . '.' . $boucle->primary .

	  "', " .

	  '"0".$doublons[' .

	  $boucle->doublons .

	  " = ('" .

	  $boucle->type_requete .

	  "' . " .

	  calculer_liste($crit->param[0], array(), $boucles, $boucles[$idb]->id_parent) .

	  ')], \'' .

	  ($crit->not ? '' : 'NOT') .

	  "') . \"";

	if ($crit->not) $boucle->doublons = "";

}

// {lang_select}

// http://www.spip.net/@lang_select

function critere_lang_select_dist($idb, &$boucles, $crit) {

	if (!($param = $crit->param[1][0]->texte)) $param = 'oui';

	if ($crit->not)	$param = ($param=='oui') ? 'non' : 'oui';

	$boucle = &$boucles[$idb];

	$boucle->lang_select = $param;

}

// {debut_xxx}

// http://www.spip.net/@debut_

function critere_debut_dist($idb, &$boucles, $crit) {

	$boucle = &$boucles[$idb];

	$boucle->limit = 'intval($GLOBALS["debut' .

	  $crit->param[0][0]->texte .

	  '"]) . ",' .

	  $crit->param[1][0]->texte .

	  '"' ;

}

// {recherche}

// http://www.spip.net/@recherche

function critere_recherche_dist($idb, &$boucles, $crit) {

	$boucle = &$boucles[$idb];

	// Ne pas executer la requete en cas de hash vide

	$boucle->hash =  '

	// RECHERCHE

	list($rech_select, $rech_where) = prepare_recherche($GLOBALS["recherche"], "'.$boucle->primary.'", "'.$boucle->id_table.'");

	if ($rech_where) ';

	$boucle->select[]= $boucle->id_table . '.' . $boucle->primary; # pour postgres, neuneu ici

	$boucle->select[]= '$rech_select as points';

	// et la recherche trouve

	$boucle->where[] = '$rech_where';

}

// {traduction}

// http://www.spip.net/@traduction

//   (id_trad>0 AND id_trad=id_trad(precedent))

//    OR id_article=id_article(precedent)

function critere_traduction_dist($idb, &$boucles, $crit) {

	$boucle = &$boucles[$idb];

	$boucle->where[] = "((".$boucle->id_table.".id_trad > 0 AND "

			. $boucle->id_table.".id_trad ='\"."

			. calculer_argument_precedent($idb, 'id_trad',

				$boucles)

			. ".\"')

		OR

			(" . $boucle->id_table.".".$boucle->primary." ='\"."

			. calculer_argument_precedent($idb, $boucle->primary,

				$boucles)

			. ".\"'))";

}

// {origine_traduction}

// http://www.spip.net/@origine_traduction

function critere_origine_traduction_dist($idb, &$boucles, $crit) {

	$boucle = &$boucles[$idb];

	$boucle->where[] = $boucle->id_table.".id_trad = "

	  . $boucle->id_table . '.' . $boucle->primary;

}

// {meme_parent}

// http://www.spip.net/@meme_parent

function critere_meme_parent_dist($idb, &$boucles, $crit) {

	$boucle = &$boucles[$idb];

	if ($boucle->type_requete == 'rubriques') {

			$boucle->where[] = $boucle->id_table.".id_parent='\"."

			. calculer_argument_precedent($idb, 'id_parent',

			$boucles)

			. ".\"'";

		} else if ($boucle->type_requete == 'forums') {

			$boucle->where[] = $boucle->id_table.".id_parent='\"."

			. calculer_argument_precedent($idb, 'id_parent',

			$boucles)

			. ".\"'";

			$boucle->where[] = $boucle->id_table.".id_parent > 0";

			$boucle->plat = true;

	}

}

// {branche ?}

// http://www.spip.net/@branche

function critere_branche_dist($idb, &$boucles, $crit) {

	$not = $crit->not;

	$boucle = &$boucles[$idb];

	$c = "calcul_mysql_in('".$boucle->id_table.".id_rubrique',

		calcul_branche(" . calculer_argument_precedent($idb,

		'id_rubrique', $boucles) . "), '')";

	if (!$crit->cond)

			$where = "\". $c .\"" ;

	else

			$where = "\".("

			. calculer_argument_precedent($idb, 'id_rubrique',

			$boucles)."? $c : 1).\"";

	if ($not)

			$boucle->where[] = "NOT($where)";

	else

			$boucle->where[] = $where;

}

// Tri : {par xxxx}

// http://www.spip.net/@par

function critere_par_dist($idb, &$boucles, $crit) {

  critere_parinverse($idb, $boucles, $crit, '') ;

}

function critere_parinverse($idb, &$boucles, $crit, $sens) {

	$boucle = &$boucles[$idb];

	if ($crit->not) $sens = $sens ? "" : " . ' DESC'";

	foreach ($crit->param as $tri) {

	// tris specifies dynamiquement

	  if ($tri[0]->type != 'texte') {

	      $order =

		calculer_liste($tri, array(), $boucles, $boucles[$idb]->id_parent);

	      $order =

		"((\$x = preg_replace(\"/\\W/\",'',$order)) ? ('$boucle->id_table.' . \$x$sens) : '')";

	  }

	    else {

	      $par = array_shift($tri);

	      $par = $par->texte;

	// par hasard

		if ($par == 'hasard') {

		// tester si cette version de MySQL accepte la commande RAND()

		// sinon faire un gloubi-boulga maison avec de la mayonnaise.

		  if (spip_query("SELECT RAND()"))

			$par = "RAND()";

		  else

			$par = "MOD(".$boucle->id_table.'.'.$boucle->primary

			  ." * UNIX_TIMESTAMP(),32767) & UNIX_TIMESTAMP()";

		  $boucle->select[]= $par . " AS alea";

		  $order = "'alea'";

		}

	// par titre_mot

		else if ($par == 'titre_mot') {

		  $order= "'mots.titre'";

		}

	// par type_mot

		else if ($par == 'type_mot'){

		  $order= "'mots.type'";

		}

	// par num champ(, suite)

		else if (ereg("^num[[:space:]]*(.*)$",$par, $m)) {

		  $texte = '0+' . $boucle->id_table . '.' . trim($m[1]);

		  $suite = calculer_liste($tri, array(), $boucles, $boucle->id_parent);

		  if ($suite !== "''")

		    $texte = "\" . ((\$x = $suite) ? ('$texte' . \$x) : '0')" . " . \"";

		  $as = 'num' .($boucle->order ? count($boucle->order) : "");

		  $boucle->select[] = $texte . " AS $as";

		  $order = "'$as'";

	}

	// par champ. Verifier qu'ils sont presents.

		elseif (ereg("^[a-z][a-z0-9_]*$", $par)) {

		    if ($par == 'date')

		      $order = "'".$boucle->id_table.".".

			$GLOBALS['table_date'][$boucle->type_requete]

			."'";

		    else {

			global $table_des_tables, $tables_des_serveurs_sql;

			$r = $boucle->type_requete;

			$s = $boucles[$idb]->sql_serveur;

			if (!$s) $s = 'localhost';

			$t = $table_des_tables[$r];

			// pour les tables non Spip

			if (!$t) $t = $r; else $t = "spip_$t";

			$desc = $tables_des_serveurs_sql[$s][$t];

			if ($desc['field'][$par])

				$order = "'".$boucle->id_table.".".$par."'";

			else {

			  // tri sur les champs synthetises (cf points)

				$order = "'".$par."'";

			}

		    }

		} else

		    erreur_squelette(_T('zbug_info_erreur_squelette'), "{par $par} BOUCLE$idb");

	    }

	    if ($order)

	      $boucle->order[] = $order . (($order[0]=="'") ? $sens : "");

	  }

}

// {inverse}

// http://www.spip.net/@inverse

// obsolete. utiliser {!par ...}

function critere_inverse_dist($idb, &$boucles, $crit) {

	$boucle = &$boucles[$idb];

	// Classement par ordre inverse

	if ($crit->not || $crit->param)

		critere_parinverse($idb, $boucles, $crit, " . ' DESC'");

	else

	  {

	    $n = count($boucle->order);

	    if ($n)

	      $boucle->order[$n-1] .= " . ' DESC'";

	    else

	      erreur_squelette(_T('zbug_info_erreur_squelette'), "{inverse ?} BOUCLE$idb");

	  }

}

function critere_agenda($idb, &$boucles, $crit)

{

	$params = $crit->param;

	if (count($params) < 1)

	      erreur_squelette(_T('zbug_info_erreur_squelette'),

			       "{agenda ?} BOUCLE$idb");

	$parent = $boucles[$idb]->id_parent;

	// les valeur $date et $type doivent etre connus à la compilation

	// autrement dit ne pas être des champs

	$date = array_shift($params);

	$date = $date[0]->texte;

	$type = array_shift($params);

	$type = $type[0]->texte;

	$annee = $params ? array_shift($params) : "";

	$annee = "\n" . 'sprintf("%04d", ($x = ' .

		calculer_liste($annee, array(), $boucles, $parent) .

		') ? $x : date("Y"))';

	$mois =  $params ? array_shift($params) : "";

	$mois = "\n" . 'sprintf("%02d", ($x = ' .

		calculer_liste($mois, array(), $boucles, $parent) .

		') ? $x : date("m"))';

	$jour =  $params ? array_shift($params) : "";

	$jour = "\n" . 'sprintf("%02d", ($x = ' .

		calculer_liste($jour, array(), $boucles, $parent) .

		') ? $x : date("d"))';

	$annee2 = $params ? array_shift($params) : "";

	$annee2 = "\n" . 'sprintf("%04d", ($x = ' .

		calculer_liste($annee2, array(), $boucles, $parent) .

		') ? $x : date("Y"))';

	$mois2 =  $params ? array_shift($params) : "";

	$mois2 = "\n" . 'sprintf("%02d", ($x = ' .

		calculer_liste($mois2, array(), $boucles, $parent) .

		') ? $x : date("m"))';

	$jour2 =  $params ? array_shift($params) : "";

	$jour2 = "\n" .  'sprintf("%02d", ($x = ' .

		calculer_liste($jour2, array(), $boucles, $parent) .

		') ? $x : date("d"))';

	$boucle = &$boucles[$idb];

	$date = $boucle->id_table . ".$date";

	if ($type == 'jour')

	  $boucle->where[] =  "DATE_FORMAT($date, '%Y%m%d') = '\" .  $annee . $mois . $jour .\"'";

	elseif ($type == 'mois')

	  $boucle->where[] =  "DATE_FORMAT($date, '%Y%m') = '\" .  $annee . $mois .\"'";

	elseif ($type == 'semaine')

	  $boucle->where[] =

	  "DATE_FORMAT($date, '%Y%m%d') >= '\" .

		date_debut_semaine($annee, $mois, $jour) . \"' AND

	  DATE_FORMAT($date, '%Y%m%d') <= '\" .

		date_fin_semaine($annee, $mois, $jour) . \"'";

	elseif (count($crit->param) > 2)

	  $boucle->where[] =

	  "DATE_FORMAT($date, '%Y%m%d') >= '\" . $annee . $mois . $jour .\"' AND

	  DATE_FORMAT($date, '%Y%m%d') <= '\" . $annee2 . $mois2 . $jour2 .\"'";

	// sinon on prend tout

}

function calculer_critere_parties($idb, &$boucles, $crit) {

	$boucle = &$boucles[$idb];

	$a1 = $crit->param[0];

	$a2 = $crit->param[1];

	$op = $crit->op;

	list($a11,$a12) = calculer_critere_parties_aux($idb, $boucles, $a1);

	list($a21,$a22) = calculer_critere_parties_aux($idb, $boucles, $a2);

	if (($op== ',')&&(is_numeric($a11) && (is_numeric($a21))))

	    $boucle->limit = $a11 .',' . $a21;

	else {

		$boucle->partie = ($a11 != 'n') ? $a11 : $a12;

		$boucle->total_parties =  ($a21 != 'n') ? $a21 : $a22;

		$boucle->mode_partie = (($op == '/') ? '/' :

			(($a11=='n') ? '-' : '+').(($a21=='n') ? '-' : '+'));

	}

}

function calculer_critere_parties_aux($idb, &$boucles, $param) {

	if ($param[0]->type != 'texte')

	  {

	  $a1 = calculer_liste(array($param[0]), array(), $boucles[$idb]->id_parent, $boucles);

	  ereg('^ *(-([0-9]+))? *$', $param[1]->texte, $m);

	  return array("intval($a1)", ($m[2] ? $m[2] : 0));

	  } else {

	    ereg('^ *(([0-9]+)|n) *(- *([0-9]+)? *)?$', $param[0]->texte, $m);

	    $a1 = $m[1];

	    if (!$m[3])

	      return array($a1, 0);

	    elseif ($m[4])

	      return array($a1, $m[4]);

	    else return array($a1,

			      calculer_liste(array($param[1]), array(), $boucles[$idb]->id_parent, $boucles));

	}

}

//

// La fonction d'aiguillage sur le nom du critere

//

function calculer_criteres ($idb, &$boucles) {

	foreach($boucles[$idb]->criteres as $crit) {

		$critere = $crit->op;

		// critere personnalise ?

		$f = "critere_".$critere;

		if (!function_exists($f))

			$f .= '_dist';

		// fonction critere standard ?

		if (!function_exists($f)) {

		  // double cas particulier repere a l'analyse lexicale

		  if (($critere == ",") OR ($critere == '/'))

		    $f = 'calculer_critere_parties';

		  else	$f = 'calculer_critere_DEFAUT';

		}

		// Applique le critere

		$res = $f($idb, $boucles, $crit);

		// Gestion d'erreur

		if (is_array($res)) erreur_squelette($res);

	}

}

# Criteres de comparaison

function calculer_critere_DEFAUT($idb, &$boucles, $crit) {

	global $table_date, $table_des_tables;

	global $tables_relations;

	$boucle = &$boucles[$idb];

	$type = $boucle->type_requete;

	$col_table = $id_table = $boucle->id_table;

	$primary = $boucle->primary;

	$id_field = $id_table . '.' . $primary;

	$fct = '';

	// cas d'une valeur comparee a elle-meme ou son referent

	if (count($crit->param) ==0)

	  { $op = '=';

	    $col = $crit->op;

	    $val = $crit->op;

	    // Cas special {lang} : aller chercher $GLOBALS['spip_lang']

	    if ($val == 'lang')

	      $val = array('$GLOBALS[\'spip_lang\']');

	    else {

	    // Si id_parent, comparer l'id_parent avec l'id_objet

	    // de la boucle superieure.... faudrait verifier qu'il existe

	      // pour eviter l'erreur SQL

	      if ($val == 'id_parent')

		$val = $primary;

	      // Si id_enfant, comparer l'id_objet avec l'id_parent

	      // de la boucle superieure

	      else if ($val == 'id_enfant')

		$val = 'id_parent';

	      $val = array("addslashes(" .calculer_argument_precedent($idb, $val, $boucles) .")");

	    }

	  }

	else

	  {

	    // comparaison explicite

	    // le phraseur impose que le premier param soit du texte

	    $params = $crit->param;

	    $op = $crit->op;

	    $col = array_shift($params);

	    $col = $col[0]->texte;

	    // fonction SQL ?

	    if (ereg("([A-Za-z_]+)\(([a-z_]+)\)", $col,$match3)) {

	      $col = $match3[2];

	      $fct = $match3[1];

	    }

	    $val = array();

	    foreach ((($op != 'IN') ? $params : calculer_vieux_in($params)) as $p) {

	      $val[] = "addslashes(" .

		calculer_liste($p, array(), $boucles, $boucles[$idb]->id_parent) .

		")";

	    }

	  }

	  // cas special: statut=

	  // si on l'invoque dans une boucle il faut interdire

	  // a la boucle de mettre ses propres criteres de statut

	  // http://www.spip.net/@statut (a documenter)

	if ($col == 'statut')

		  $boucle->where['statut'] = '1';

	// reperer les champs n'appartenant pas a la table de la boucle

	if ($ext_table =  $tables_relations[$type][$col])

		$col_table = $ext_table .

		  calculer_critere_externe($boucle, $id_field, $ext_table, $type, $col);

	// Cas particulier pour les raccourcis 'type_mot' et 'titre_mot'

	elseif ($type != 'mots' AND $table_des_tables[$type]

			AND ($col == 'type_mot' OR $col == 'titre_mot'

			OR $col == 'id_groupe')) {

		if ($type == 'forums')

		  $lien = "mots_forum";

		else if ($type == 'syndication')

		  $lien = "mots_syndic";

		else

		  $lien = "mots_$type";

		// jointure nouvelle a chaque comparaison

		$num_lien = calculer_critere_externe($boucle, $id_field, $lien, $type, $col);

		// jointure pour lier la table principale et la nouvelle

		$boucle->from[] = "spip_mots AS l_mots$num_lien";

		$boucle->where[] = "$lien$num_lien.id_mot=l_mots$num_lien.id_mot";

		$col_table = "l_mots$num_lien";

		if ($col == 'type_mot')

		  $col = 'type';

		else if ($col == 'titre_mot')

		  $col = 'titre';

	}

	// Cas particulier : selection des documents selon l'extension

	if ($type == 'documents' AND $col == 'extension')

	  $col_table = 'types_documents';

	// HACK : selection des documents selon mode 'image'

	// (a creer en dur dans la base)

	else if ($type == 'documents' AND $col == 'mode' AND $val[0] == "'image'")

	  $val[0] = "'vignette'";

	// Cas particulier : lier les articles syndiques

	// au site correspondant

	else if ($type == 'syndic_articles' AND

		 !ereg("^(id_syndic_article|titre|url|date|descriptif|lesauteurs|id_document)$",$col))

	  $col_table = 'syndic';

	// Cas particulier : id_enfant => utiliser la colonne id_objet

	if ($col == 'id_enfant')

	  $col = $primary;

	// Cas particulier : id_secteur = id_rubrique pour certaines tables

	if (($type == 'breves' OR $type == 'forums') AND $col == 'id_secteur')

	  $col = 'id_rubrique';

	// Cas particulier : expressions de date

	if (ereg("^(date|mois|annee|heure|age|age_relatif|jour_relatif|mois_relatif|annee_relatif)(_redac)?$", $col, $regs)) {

	  $col = $regs[1];

	  if ($regs[2]) {

	    $date_orig = $id_table . ".date_redac";

	    $date_compare = '\'" . normaliser_date(' .

	      calculer_argument_precedent($idb, 'date_redac', $boucles) .

	      ') . "\'';

	  }

	  else {

	    $date_orig = "$id_table." . $table_date[$type];

	    $date_compare = '\'" . normaliser_date(' .

	      calculer_argument_precedent($idb, 'date', $boucles) .

	      ') . "\'';

	  }

	  if ($col == 'date') {

			$col = $date_orig;

			$col_table = '';

		}

		else if ($col == 'mois') {

			$col = "MONTH($date_orig)";

			$col_table = '';

		}

		else if ($col == 'annee') {

			$col = "YEAR($date_orig)";

			$col_table = '';

		}

		else if ($col == 'heure') {

			$col = "DATE_FORMAT($date_orig, '%H:%i')";

			$col_table = '';

		}

		else if ($col == 'age') {

			$col = calculer_param_date("now()", $date_orig);

			$col_table = '';

		}

		else if ($col == 'age_relatif') {

			$col = calculer_param_date($date_compare, $date_orig);

			$col_table = '';

		}

		else if ($col == 'jour_relatif') {

			$col = "LEAST(TO_DAYS(" .$date_compare . ")-TO_DAYS(" .

			$date_orig . "), DAYOFMONTH(" . $date_compare .

			")-DAYOFMONTH(" . $date_orig . ")+30.4368*(MONTH(" .

			$date_compare . ")-MONTH(" . $date_orig .

			"))+365.2422*(YEAR(" . $date_compare . ")-YEAR(" .

			$date_orig . ")))";

			$col_table = '';

		}

		else if ($col == 'mois_relatif') {

			$col = "MONTH(" . $date_compare . ")-MONTH(" .

			$date_orig . ")+12*(YEAR(" . $date_compare .

			")-YEAR(" . $date_orig . "))";

			$col_table = '';

		}

		else if ($col == 'annee_relatif') {

			$col = "YEAR(" . $date_compare . ")-YEAR(" .

			$date_orig . ")";

			$col_table = '';

		}

	}

	if ($type == 'forums' AND

	($col == 'id_parent' OR $col == 'id_forum'))

		$boucle->plat = true;

	// Rajouter le nom de la table SQL devant le nom du champ

	if ($col_table) {

		if ($col[0] == "`")

		  $ct = "$col_table." . substr($col,1,-1);

		else $ct = "$col_table.$col";

	} else $ct = $col;

	// fonction SQL

	if ($fct) $ct = "$fct($ct)";

	//	if (($op != '=') || !calculer_critere_repete($boucle, $ct, $val[0])) # a revoir

	if (strtoupper($op) == 'IN') {

	      $where = "$ct IN ('\" . " . join(" .\n\"','\" . ", $val) . " . \"')";

	      if ($crit->not) {

		$where = "NOT ($where)";

	      } else {

			$boucle->default_order = array('rang');

			$boucle->select[]= "FIND_IN_SET($ct, '\" . " .

			  join(" .\n\",\" . ", $val) . ' . "\') AS rang';

	      }

	} else {

		  if ($op == '==') $op = 'REGEXP';

		  $where = "($ct $op '\" . " . $val[0] . ' . "\')';

		  if ($crit->not) $where = "NOT $where";

		// operateur optionnel {lang?}

		  if ($crit->cond) {

		    $champ = calculer_argument_precedent($idb, $col, $boucles) ;

		    $where = "\".($champ ? \"$where\" : 1).\"";

		  }

	    }

	$boucle->where[] = $where;

}

// compatibilite ancienne version

function calculer_vieux_in($params)

{

	      $deb = $params[0][0];

	      $k = count($params)-1;

	      $last = $params[$k];

	      $j = count($last)-1;

	      $last = $last[$j];

	      $n = strlen($last->texte);

	      // compatibilité ancienne version

	      if (!(($deb->texte[0] == '(') && ($last->texte[$n-1] == ')')))

		return $params;

	      $params[0][0]->texte = substr($deb->texte,1);

	      // attention, on peut avoir k=0,j=0 ==> recalculer

	      $last = $params[$k][$j];

	      $n = strlen($last->texte);

	      $params[$k][$j]->texte = substr($last->texte,0,$n-1);

	      $newp = array();

	      foreach($params as $v) {

		    if ($v[0]->type != 'texte')

		      $newp[] = $v;

		    else {

		      foreach(split(',', $v[0]->texte) as $x) {

			$t = new Texte;

			$t->texte = $x;

			$newp[] = array($t);

		      }

		    }

	      }

	      return  $newp;

}

// fonction provisoirement inutilisee

// reperer des repetitions comme {id_mot=1}{id_mot=2}

//  pour creer une clause HAVING

/*

function calculer_critere_repete(&$boucle, $col, $val)

{

	foreach ($boucle->where as $k => $v)  {

        	if (ereg(" *$col *(=|IN) *\(?'(.*)(\".*)[')]$",$v, $m)) {

                  $boucle->where[$k] = "$col IN ('$m[2] \"','\" . $val . $m[3])";

                  // esperons que c'est le meme !

                  $boucle->having++;

		  return true;}

              }

	return false;

}

*/

// traitement des relations externes par DES jointures.

function calculer_critere_externe(&$boucle, $id_field, $lien, $type, $col) {

	global $tables_relations_keys;

	static $num;

	$num++;

	$ref = $tables_relations_keys[$type][$col];

	$boucle->lien = true;

	$boucle->from[] = "spip_$lien AS $lien$num";

	$boucle->where[] = "$id_field=$lien$num." .

	  ($ref ? $ref : $boucle->primary);

	$boucle->group = $id_field;

	// postgres exige que le champ pour GROUP soit dans le SELECT

	$boucle->select[] = $id_field;

	return $num;

}

function calculer_param_date($date_compare, $date_orig) {

	if (ereg("'\" *\.(.*)\. *\"'", $date_compare, $r)) {

	  $init = "'\" . (\$x = $r[1]) . \"'";

	  $date_compare = '\'$x\'';

	}

	else

	  $init = $date_compare;

	return

	"LEAST((UNIX_TIMESTAMP(" .

	$init .

	")-UNIX_TIMESTAMP(" .

	$date_orig .

	"))/86400,\n\tTO_DAYS(" .

	$date_compare .

	")-TO_DAYS(" .

	$date_orig .

	"),\n\tDAYOFMONTH(" .

	$date_compare .

	")-DAYOFMONTH(" .

	$date_orig .

	")+30.4368*(MONTH(" .

	$date_compare .

	")-MONTH(" .

	$date_orig .

	"))+365.2422*(YEAR(" .

	$date_compare .

	")-YEAR(" .

	$date_orig .

	")))";

}

?>