Esempio n. 1
0
 /**
  * selectionner les donnees, ie faire la requete SQL
  *
  * @return void
  */
 protected function select()
 {
     $this->row = null;
     $v =& $this->command;
     $this->sqlresult = calculer_select($v['select'], $v['from'], $v['type'], $v['where'], $v['join'], $v['groupby'], $v['orderby'], $v['limit'], $v['having'], $v['table'], $v['id'], $v['connect'], $this->info);
     $this->err = !$this->sqlresult;
     $this->firstseek = false;
     $this->pos = -1;
     // pas d'init a priori, le calcul ne sera fait qu'en cas de besoin (provoque une double requete souvent inutile en sqlite)
     //$this->total = $this->count();
 }
Esempio n. 2
0
/**
 * Determininer si un objet est publie ou non
 * 
 * On se base pour cela sur sa declaration de statut
 * pour des cas particuliers non declarables, on permet de fournir une fonction
 * base_xxxx_test_si_publie qui sera appele par la fonction
 *
 * @param string $objet
 * @param int $id_objet
 * @param string $serveur
 * @return bool
 */
function objet_test_si_publie($objet, $id_objet, $serveur = '')
{
    // voir si une fonction est definie pour faire le boulot
    // elle a la priorite dans ce cas
    if ($f = charger_fonction($objet . "_test_si_publie", "base", true)) {
        return $f($objet, $id_objet, $serveur);
    }
    // sinon on se fie a la declaration de l'objet si presente
    $id_table = $table_objet = table_objet($objet);
    $id_table_objet = id_table_objet($objet, $serveur);
    $trouver_table = charger_fonction('trouver_table', 'base');
    if ($desc = $trouver_table($table_objet, $serveur) and isset($desc['statut']) and $desc['statut']) {
        $boucle = new Boucle();
        $boucle->show = $desc;
        $boucle->nom = 'objet_test_si_publie';
        $boucle->id_boucle = $id_table;
        $boucle->id_table = $id_table;
        $boucle->sql_serveur = $serveur;
        $boucle->select[] = $id_table_objet;
        $boucle->from[$table_objet] = table_objet_sql($objet, $serveur);
        $boucle->where[] = $id_table . "." . $id_table_objet . '=' . intval($id_objet);
        include_spip('public/compiler');
        include_spip('public/composer');
        instituer_boucle($boucle, false);
        $res = calculer_select($boucle->select, $boucle->from, $boucle->from_type, $boucle->where, $boucle->join, $boucle->group, $boucle->order, $boucle->limit, $boucle->having, $table_objet, $id_table, $serveur);
        if (sql_fetch($res)) {
            return true;
        }
        return false;
    }
    // si pas d'info statut ni de fonction : l'objet est publie
    return true;
}
Esempio n. 3
0
/**
 * La fonction presente dans les squelettes compiles
 *
 * http://doc.spip.org/@calculer_select
 *
 * @param array $select
 * @param array $from
 * @param array $from_type
 * @param array $where
 * @param array $join
 * @param array $groupby
 * @param array $orderby
 * @param string $limit
 * @param array $having
 * @param string $table
 * @param string $id
 * @param string $serveur
 * @param bool $requeter
 * @return resource
 */
function calculer_select($select = array(), $from = array(), $from_type = array(), $where = array(), $join = array(), $groupby = array(), $orderby = array(), $limit = '', $having = array(), $table = '', $id = '', $serveur = '', $requeter = true)
{
    // retirer les criteres vides:
    // {X ?} avec X absent de l'URL
    // {par #ENV{X}} avec X absent de l'URL
    // IN sur collection vide (ce dernier devrait pouvoir etre fait a la compil)
    $menage = false;
    foreach ($where as $k => $v) {
        if (is_array($v)) {
            if (count($v) >= 2 && $v[0] == 'REGEXP' && $v[2] == "'.*'") {
                $op = false;
            } elseif (count($v) >= 2 && $v[0] == 'LIKE' && $v[2] == "'%'") {
                $op = false;
            } else {
                $op = $v[0] ? $v[0] : $v;
            }
        } else {
            $op = $v;
        }
        if (!$op or $op == 1 or $op == '0=0') {
            unset($where[$k]);
            $menage = true;
        }
    }
    // evacuer les eventuels groupby vide issus d'un calcul dynamique
    $groupby = array_diff($groupby, array(''));
    // remplacer les sous requetes recursives au calcul
    list($where_simples, $where_sous) = trouver_sous_requetes($where);
    foreach ($where_sous as $k => $w) {
        $menage = true;
        // on recupere la sous requete
        $sous = match_self($w);
        if ($sous[0] == 'SELF') {
            // c'est une sous requete identique a elle meme sous la forme (SELF,$select,$where)
            array_push($where_simples, $sous[2]);
            $wheresub = array($sous[2], '0=0');
            // pour accepter une string et forcer a faire le menage car on a surement simplifie select et where
            $jsub = $join;
            // trouver les jointures utiles a
            // reinjecter dans le where de la sous requete les conditions supplementaires des jointures qui y sont mentionnees
            // ie L1.objet='article'
            // on construit le where une fois, puis on ajoute les where complentaires si besoin, et on reconstruit le where en fonction
            $i = 0;
            do {
                $where[$k] = remplace_sous_requete($w, "(" . calculer_select(array($sous[1] . " AS id"), $from, $from_type, $wheresub, $jsub, array(), array(), '', $having, $table, $id, $serveur, false) . ")");
                if (!$i) {
                    $i = 1;
                    $wherestring = calculer_where_to_string($where[$k]);
                    foreach ($join as $cle => $wj) {
                        if (count($wj) == 4 and strpos($wherestring, "{$cle}.") !== FALSE) {
                            $i = 0;
                            $wheresub[] = $wj[3];
                            unset($jsub[$cle][3]);
                        }
                    }
                }
            } while ($i++ < 1);
        }
        if ($sous[0] == 'SUBSELECT') {
            // c'est une sous requete explicite sous la forme identique a sql_select : (SUBSELECT,$select,$from,$where,$groupby,$orderby,$limit,$having)
            array_push($where_simples, $sous[3]);
            // est-ce utile dans ce cas ?
            $where[$k] = remplace_sous_requete($w, "(" . calculer_select($sous[1], $sous[2], array(), $sous[3] ? is_array($sous[3]) ? $sous[3] : array($sous[3]) : array(), array(), $sous[4] ? $sous[4] : array(), $sous[5] ? $sous[5] : array(), $sous[6], $sous[7] ? $sous[7] : array(), $table, $id, $serveur, false) . ")");
        }
        array_pop($where_simples);
    }
    foreach ($having as $k => $v) {
        if (!$v or $v == 1 or $v == '0=0') {
            unset($having[$k]);
        }
    }
    // Installer les jointures.
    // Retirer celles seulement utiles aux criteres finalement absents mais
    // parcourir de la plus recente a la moins recente pour pouvoir eliminer Ln
    // si elle est seulement utile a Ln+1 elle meme inutile
    $afrom = array();
    $equiv = array();
    $k = count($join);
    foreach (array_reverse($join, true) as $cledef => $j) {
        $cle = $cledef;
        // le format de join est :
        // array(table depart, cle depart [,cle arrivee[,condition optionnelle and ...]])
        if (count($join[$cle]) == 2) {
            $join[$cle][] = $join[$cle][1];
        }
        if (count($join[$cle]) == 3) {
            $join[$cle][] = '';
        }
        list($t, $c, $carr, $and) = $join[$cle];
        // si le nom de la jointure n'a pas ete specifiee, on prend Lx avec x sont rang dans la liste
        // pour compat avec ancienne convention
        if (is_numeric($cle)) {
            $cle = "L{$k}";
        }
        if (!$menage or isset($afrom[$cle]) or calculer_jointnul($cle, $select) or calculer_jointnul($cle, array_diff_key($join, array($cle => $join[$cle]))) or calculer_jointnul($cle, $having) or calculer_jointnul($cle, $where_simples)) {
            // corriger les references non explicites dans select
            // ou groupby
            foreach ($select as $i => $s) {
                if ($s == $c) {
                    $select[$i] = "{$cle}.{$c} AS {$c}";
                    break;
                }
            }
            foreach ($groupby as $i => $g) {
                if ($g == $c) {
                    $groupby[$i] = "{$cle}.{$c}";
                    break;
                }
            }
            // on garde une ecriture decomposee pour permettre une simplification ulterieure si besoin
            // sans recours a preg_match
            // un implode(' ',..) est fait dans reinjecte_joint un peu plus bas
            $afrom[$t][$cle] = array("\n" . (isset($from_type[$cle]) ? $from_type[$cle] : "INNER") . " JOIN", $from[$cle], "AS {$cle}", "ON (", "{$cle}.{$c}", "=", "{$t}.{$carr}", ($and ? "AND " . $and : "") . ")");
            if (isset($afrom[$cle])) {
                $afrom[$t] = $afrom[$t] + $afrom[$cle];
                unset($afrom[$cle]);
            }
            $equiv[] = $carr;
        } else {
            unset($join[$cledef]);
        }
        unset($from[$cle]);
        $k--;
    }
    if (count($afrom)) {
        // Regarder si la table principale ne sert finalement a rien comme dans
        //<BOUCLE3(MOTS){id_article}{id_mot}> class='on'</BOUCLE3>
        //<BOUCLE2(MOTS){id_article} />#TOTAL_BOUCLE<//B2>
        //<BOUCLE5(RUBRIQUES){id_mot}{tout} />#TOTAL_BOUCLE<//B5>
        // ou dans
        //<BOUCLE8(HIERARCHIE){id_rubrique}{tout}{type='Squelette'}{inverse}{0,1}{lang_select=non} />#TOTAL_BOUCLE<//B8>
        // qui comporte plusieurs jointures
        // ou dans
        // <BOUCLE6(ARTICLES){id_mot=2}{statut==.*} />#TOTAL_BOUCLE<//B6>
        // <BOUCLE7(ARTICLES){id_mot>0}{statut?} />#TOTAL_BOUCLE<//B7>
        // penser a regarder aussi la clause orderby pour ne pas simplifier abusivement
        // <BOUCLE9(ARTICLES){recherche truc}{par titre}>#ID_ARTICLE</BOUCLE9>
        // penser a regarder aussi la clause groubpy pour ne pas simplifier abusivement
        // <BOUCLE10(EVENEMENTS){id_rubrique} />#TOTAL_BOUCLE<//B10>
        list($t, $c) = each($from);
        reset($from);
        $e = '/\\b(' . "{$t}\\." . join("|" . $t . '\\.', $equiv) . ')\\b/';
        if (!(strpos($t, ' ') or calculer_jointnul($t, $select, $e) or calculer_jointnul($t, $join, $e) or calculer_jointnul($t, $where, $e) or calculer_jointnul($t, $orderby, $e) or calculer_jointnul($t, $groupby, $e) or calculer_jointnul($t, $having, $e)) && count($afrom[$t])) {
            reset($afrom[$t]);
            list($nt, $nfrom) = each($afrom[$t]);
            unset($from[$t]);
            $from[$nt] = $nfrom[1];
            unset($afrom[$t][$nt]);
            $afrom[$nt] = $afrom[$t];
            unset($afrom[$t]);
            $e = '/\\b' . preg_quote($nfrom[6]) . '\\b/';
            $t = $nfrom[4];
            $alias = "";
            // verifier que les deux cles sont homonymes, sinon installer un alias dans le select
            $oldcle = explode('.', $nfrom[6]);
            $oldcle = end($oldcle);
            $newcle = explode('.', $nfrom[4]);
            $newcle = end($newcle);
            if ($newcle != $oldcle) {
                // si l'ancienne cle etait deja dans le select avec un AS
                // reprendre simplement ce AS
                $as = '/\\b' . preg_quote($nfrom[6]) . '\\s+(AS\\s+\\w+)\\b/';
                if (preg_match($as, implode(',', $select), $m)) {
                    $alias = "";
                } else {
                    $alias = ", " . $nfrom[4] . " AS {$oldcle}";
                }
            }
            $select = remplacer_jointnul($t . $alias, $select, $e);
            $join = remplacer_jointnul($t, $join, $e);
            $where = remplacer_jointnul($t, $where, $e);
            $having = remplacer_jointnul($t, $having, $e);
            $groupby = remplacer_jointnul($t, $groupby, $e);
            $orderby = remplacer_jointnul($t, $orderby, $e);
        }
        $from = reinjecte_joint($afrom, $from);
    }
    $GLOBALS['debug']['aucasou'] = array($table, $id, $serveur, $requeter);
    $r = sql_select($select, $from, $where, $groupby, array_filter($orderby), $limit, $having, $serveur, $requeter);
    unset($GLOBALS['debug']['aucasou']);
    return $r;
}
Esempio n. 4
0
/**
 * Calcule la liste des langues reellement utilisees dans le site public
 *
 * La recherche de langue est effectuée en recréant une boucle pour chaque
 * objet éditorial gérant des langues de sorte que les éléments non publiés
 * ne sont pas pris en compte.
 * 
 * @param string $serveur
 *    Nom du connecteur à la base de données
 * @return string
 *    Liste des langues utilisées séparées par des virgules
**/
function calculer_langues_utilisees($serveur = '')
{
    include_spip('public/interfaces');
    include_spip('public/compiler');
    include_spip('public/composer');
    $langues = array();
    $langues[$GLOBALS['meta']['langue_site']] = 1;
    include_spip('base/objets');
    $tables = lister_tables_objets_sql();
    $trouver_table = charger_fonction('trouver_table', 'base');
    foreach (array_keys($tables) as $t) {
        $desc = $trouver_table($t, $serveur);
        // c'est une table avec des langues
        if ($desc['exist'] and isset($desc['field']['lang']) and isset($desc['field']['langue_choisie'])) {
            $boucle = new Boucle();
            $boucle->show = $desc;
            $boucle->nom = 'calculer_langues_utilisees';
            $boucle->id_boucle = $desc['table_objet'];
            $boucle->id_table = $desc['table_objet'];
            $boucle->sql_serveur = $serveur;
            $boucle->select[] = "DISTINCT lang";
            $boucle->from[$desc['table_objet']] = $t;
            $boucle = pipeline('pre_boucle', $boucle);
            if (isset($desc['statut']) and $desc['statut']) {
                instituer_boucle($boucle, false);
                $res = calculer_select($boucle->select, $boucle->from, $boucle->from_type, $boucle->where, $boucle->join, $boucle->group, $boucle->order, $boucle->limit, $boucle->having, $desc['table_objet'], $desc['table_objet'], $serveur);
            } else {
                $res = sql_select(implode(',', $boucle->select), $boucle->from);
            }
            while ($row = sql_fetch($res)) {
                $langues[$row['lang']] = 1;
            }
        }
    }
    $langues = array_filter(array_keys($langues));
    sort($langues);
    $langues = join(',', $langues);
    spip_log("langues utilisees: {$langues}");
    return $langues;
}
Esempio n. 5
0
function calculer_select ($select = array(), $from = array(), 
			$from_type = array(),
      $where = array(), $join=array(),
			$groupby = array(), $orderby = array(), $limit = '',
			$having=array(), $table = '', $id = '', $serveur='', $requeter=true) {

// retirer les criteres vides:
// {X ?} avec X absent de l'URL
// {par #ENV{X}} avec X absent de l'URL
// IN sur collection vide (ce dernier devrait pouvoir etre fait a la compil)

	$menage = false;
	foreach($where as $k => $v) { 
		if (is_array($v)){
			if ((count($v)>=2) && ($v[0]=='REGEXP') && ($v[2]=="'.*'")) $op= false;
			elseif ((count($v)>=2) && ($v[0]=='LIKE') && ($v[2]=="'%'")) $op= false;
			else $op = $v[0] ? $v[0] : $v;
		} else $op = $v;
		if ((!$op) OR ($op==1) OR ($op=='0=0')) {
			unset($where[$k]);
			$menage = true;
		}
	}

	// evacuer les eventuels groupby vide issus d'un calcul dynamique
	$groupby = array_diff($groupby,array(''));

	// remplacer les sous requetes recursives au calcul
	list($where_simples,$where_sous) = trouver_sous_requetes($where);
	//var_dump($where_sous);
	foreach($where_sous as $k=>$w) {
		$menage = true;
		// on recupere la sous requete 
		$sous = match_self($w);
		if ($sous[0]=='SELF') {
			// c'est une sous requete identique a elle meme sous la forme (SELF,$select,$where)
			array_push($where_simples,$sous[2]);
			$where[$k] = remplace_sous_requete($w,"(".calculer_select(
			$sous[1],
			$from,
			$from_type,
			array($sous[2],'0=0'), // pour accepter une string et forcer a faire le menage car on a surement simplifie select et where
			$join,
			array(),array(),'',
			$having,$table,$id,$serveur,false).")");
		}
		if ($sous[0]=='SUBSELECT') {
			// c'est une sous requete explicite sous la forme identique a sql_select : (SUBSELECT,$select,$from,$where,$groupby,$orderby,$limit,$having)
			array_push($where_simples,$sous[3]); // est-ce utile dans ce cas ?
			$where[$k] = remplace_sous_requete($w,"(".calculer_select(
			$sous[1], # select
			$sous[2], #from
			array(), #from_type
			$sous[3]?(is_array($sous[3])?$sous[3]:array($sous[3])):array(), #where, qui peut etre de la forme string comme dans sql_select
			array(), #join
			$sous[4]?$sous[4]:array(), #groupby
			$sous[5]?$sous[5]:array(), #orderby
			$sous[6], #limit
			$sous[7]?$sous[7]:array(), #having
			$table,$id,$serveur,false
			).")");
		}
		array_pop($where_simples);
	}

	foreach($having as $k => $v) { 
		if ((!$v) OR ($v==1) OR ($v=='0=0')) {
			unset($having[$k]);
		}
	}

// Installer les jointures.
// Retirer celles seulement utiles aux criteres finalement absents mais
// parcourir de la plus recente a la moins recente pour pouvoir eliminer Ln
// si elle est seulement utile a Ln+1 elle meme inutile
	
	$afrom = array();
	$equiv = array();
	$k = count($join);
	foreach(array_reverse($join,true) as $cledef=>$j) {
		$cle = $cledef;
		// le format de join est :
		// array(table depart, cle depart [,cle arrivee[,condition optionnelle and ...]])
		if (count($join[$cle])==2) $join[$cle][] = $join[$cle][1];
		if (count($join[$cle])==3) $join[$cle][] = '';
		list($t,$c,$carr,$and) = $join[$cle];
		// si le nom de la jointure n'a pas ete specifiee, on prend Lx avec x sont rang dans la liste
		// pour compat avec ancienne convention
		if (is_numeric($cle))
			$cle = "L$k";
		if (!$menage
		OR isset($afrom[$cle])
		OR calculer_jointnul($cle, $select)
		OR calculer_jointnul($cle, array_diff($join,array($cle=>$join[$cle])))
		OR calculer_jointnul($cle, $having)
		OR calculer_jointnul($cle, $where_simples)) {
			// on garde une ecriture decomposee pour permettre une simplification ulterieure si besoin
			// sans recours a preg_match
			// un implode(' ',..) est fait dans reinjecte_joint un peu plus bas
			$afrom[$t][$cle] = array("\n" .
				(isset($from_type[$cle])?$from_type[$cle]:"INNER")." JOIN",
				$from[$cle],
				"AS $cle",
				"ON (",
				"$cle.$c",
				"=",
				"$t.$carr",
				($and ? "AND ". $and:"") .
				")");
			if (isset($afrom[$cle])){
				$afrom[$t] = $afrom[$t] + $afrom[$cle];
				unset($afrom[$cle]);
			}
			$equiv[]= $carr;
		} else { unset($join[$cledef]);}
		unset($from[$cle]);
		$k--;
	}

	if (count($afrom)) {
		// Regarder si la table principale ne sert finalement a rien comme dans
		//<BOUCLE3(MOTS){id_article}{id_mot}> class='on'</BOUCLE3>
		//<BOUCLE2(MOTS){id_article} />#TOTAL_BOUCLE<//B2>
		//<BOUCLE5(RUBRIQUES){id_mot}{tout} />#TOTAL_BOUCLE<//B5>
		// ou dans
		//<BOUCLE8(HIERARCHIE){id_rubrique}{tout}{type='Squelette'}{inverse}{0,1}{lang_select=non} />#TOTAL_BOUCLE<//B8>
		// qui comporte plusieurs jointures
		// ou dans
		// <BOUCLE6(ARTICLES){id_mot=2}{statut==.*} />#TOTAL_BOUCLE<//B6>
		// <BOUCLE7(ARTICLES){id_mot>0}{statut?} />#TOTAL_BOUCLE<//B7>
		// penser a regarder aussi la clause orderby pour ne pas simplifier abusivement
		// <BOUCLE9(ARTICLES){recherche truc}{par titre}>#ID_ARTICLE</BOUCLE9>
		// penser a regarder aussi la clause groubpy pour ne pas simplifier abusivement
		// <BOUCLE10(EVENEMENTS){id_rubrique} />#TOTAL_BOUCLE<//B10>
		
	  list($t,$c) = each($from);
	  reset($from);
	  $e = '/\b(' . "$t\\." . join("|" . $t . '\.', $equiv) . ')\b/';
	  if (!(strpos($t, ' ') OR // jointure des le depart cf boucle_doc
		 calculer_jointnul($t, $select, $e) OR
		 calculer_jointnul($t, $join, $e) OR
		 calculer_jointnul($t, $where, $e) OR
		 calculer_jointnul($t, $orderby, $e) OR
		 calculer_jointnul($t, $groupby, $e) OR
		 calculer_jointnul($t, $having, $e))
		 && count($afrom[$t])) {
		 	reset($afrom[$t]);
		 	list($nt,$nfrom) = each($afrom[$t]);
	    unset($from[$t]);
	    $from[$nt] = $nfrom[1];
	    unset($afrom[$t][$nt]);
	    $afrom[$nt] = $afrom[$t];
	    unset($afrom[$t]);
	    $e = '/\b'.preg_quote($nfrom[6]).'\b/';
	    $t = $nfrom[4];
	    $alias = "";
	    // verifier que les deux cles sont homonymes, sinon installer un alias dans le select
	    $oldcle = explode('.',$nfrom[6]);
	    $oldcle = end($oldcle);
	    $newcle = explode('.',$nfrom[4]);
	    $newcle = end($newcle);
	    if ($newcle!=$oldcle){
	    	$alias = ", ".$nfrom[4]." AS $oldcle";
	    }
	    $select = remplacer_jointnul($t . $alias, $select, $e);
	    $join = remplacer_jointnul($t, $join, $e);
	    $where = remplacer_jointnul($t, $where, $e);
	    $having = remplacer_jointnul($t, $having, $e);
	    $groupby = remplacer_jointnul($t, $groupby, $e);
	    $orderby = remplacer_jointnul($t, $orderby, $e);
	  }
	  $from = reinjecte_joint($afrom, $from);
	}
	$GLOBALS['debug']['aucasou'] = array ($table, $id, $serveur, $requeter);
	$r = sql_select($select, $from, $where,
		$groupby, array_filter($orderby), $limit, $having, $serveur, $requeter);
	unset($GLOBALS['debug']['aucasou']);
	return $r;
}