| New file |
|---|
| 0,0 → 1,736 |
|---|
| <?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 . |
| ")))"; |
| } |
| |
| ?> |