4 /***************************************************************************\
5 * SPIP, Systeme de publication pour l'internet *
7 * Copyright (c) 2001-2012 *
8 * Arnaud Martin, Antoine Pitrou, Philippe Riviere, Emmanuel Saint-James *
10 * Ce programme est un logiciel libre distribue sous licence GNU/GPL. *
11 * Pour plus de details voir le fichier COPYING.txt ou l'aide en ligne. *
12 \***************************************************************************/
14 if (!defined('_ECRIRE_INC_VERSION')) return;
17 * Fabrique d'iterateur
18 * permet de charger n'importe quel iterateur IterateurXXX
19 * fourni dans le fichier iterateurs/xxx.php
23 public static function create($iterateur, $command, $info=null){
25 // cas des SI {si expression} analises tres tot
26 // pour eviter le chargement de tout iterateur
27 if (isset($command['si'])) {
28 foreach ($command['si'] as $si) {
30 // $command pour boucle SQL peut generer des erreurs de compilation
31 // s'il est transmis alors qu'on est dans un iterateur vide
32 return new IterDecorator(new EmptyIterator(), array(), $info);
37 // chercher un iterateur PHP existant (par exemple dans SPL)
38 // (il faudrait passer l'argument ->sql_serveur
39 // pour etre certain qu'on est sur un "php:")
40 if (class_exists($iterateur)) {
41 $a = isset($command['args']) ?
$command['args'] : array() ;
43 // permettre de passer un Iterateur directement {args #ITERATEUR} :
44 // si on recoit deja un iterateur en argument, on l'utilise
45 if (count($a)==1 and is_object($a[0]) and is_subclass_of($a[0], 'Iterator')) {
48 // sinon, on cree un iterateur du type donne
50 // arguments de creation de l'iterateur...
54 case 0: $iter = new $iterateur(); break;
55 case 1: $iter = new $iterateur($a[0]); break;
56 case 2: $iter = new $iterateur($a[0], $a[1]); break;
57 case 3: $iter = new $iterateur($a[0], $a[1], $a[2]); break;
58 case 4: $iter = new $iterateur($a[0], $a[1], $a[2], $a[3]); break;
60 } catch (Exception
$e) {
61 spip_log("Erreur de chargement de l'iterateur $iterateur");
62 spip_log($e->getMessage());
63 $iter = new EmptyIterator();
67 // chercher la classe d'iterateur
69 // definie dans le fichier iterateurs/xxx.php
70 $class = "Iterateur".$iterateur;
71 if (!class_exists($class)){
72 if (!include_spip("iterateur/" . strtolower($iterateur))
73 OR !class_exists($class)) {
74 die("Iterateur $iterateur non trouvé");
75 // si l'iterateur n'existe pas, on se rabat sur le generique
76 # $iter = new EmptyIterator();
79 $iter = new $class($command, $info);
81 return new IterDecorator($iter, $command, $info);
88 class IterDecorator
extends FilterIterator
{
92 * Conditions de filtrage
93 * ie criteres de selection
96 protected $filtre = array();
99 * Fonction de filtrage compilee a partir des criteres de filtre
102 protected $func_filtre = null;
105 * Critere {offset, limit}
109 protected $offset = null;
110 protected $limit = null;
113 * nombre d'elements recuperes depuis la position 0,
114 * en tenant compte des filtres
117 protected $fetched=0;
120 * Y a t'il une erreur ?
124 protected $err = false;
127 * Drapeau a activer en cas d'echec
128 * (select SQL errone, non chargement des DATA, etc)
130 public function err() {
131 if (method_exists($this->iter
, 'err'))
132 return $this->iter
->err();
133 if (property_exists($this->iter
, 'err'))
134 return $this->iter
->err
;
138 public function __construct(Iterator
$iter, $command, $info){
139 parent
::__construct($iter);
140 parent
::rewind(); // remettre a la premiere position (bug? connu de FilterIterator)
142 // recuperer l'iterateur transmis
143 $this->iter
= $this->getInnerIterator();
144 $this->command
= $command;
149 // chercher la liste des champs a retourner par
150 // fetch si l'objet ne les calcule pas tout seul
151 if (!method_exists($this->iter
, 'fetch')) {
152 $this->calculer_select();
153 $this->calculer_filtres();
156 // emptyIterator critere {si} faux n'a pas d'erreur !
157 if (isset($this->iter
->err
)) {
158 $this->err
= $this->iter
->err
;
161 // pas d'init a priori, le calcul ne sera fait qu'en cas de besoin (provoque une double requete souvent inutile en sqlite)
162 //$this->total = $this->count();
166 // calcule les elements a retournes par fetch()
167 // enleve les elements inutiles du select()
169 private function calculer_select() {
170 if ($select = &$this->command
['select']) {
171 foreach($select as $s) {
176 $this->select
[] = $s;
181 // recuperer la valeur d'une balise #X
182 // en fonction des methodes
183 // et proprietes disponibles
184 public function get_select($nom) {
185 if (is_object($this->iter
)
186 AND method_exists($this->iter
, $nom)) {
188 return $this->iter
->$nom();
189 } catch(Exception
$e) {
190 // #GETCHILDREN sur un fichier de DirectoryIterator ...
191 spip_log("Methode $nom en echec sur " . get_class($this->iter
));
192 spip_log("Cela peut être normal : retour d'une ligne de resultat ne pouvant pas calculer cette methode");
197 if (property_exists($this->iter, $nom)) {
198 return $this->iter->$nom;
200 // cle et valeur par defaut
201 // ICI PLANTAGE SI ON NE CONTROLE PAS $nom
202 if (in_array($nom, array('cle', 'valeur'))
203 AND method_exists($this, $nom)) {
204 return $this->$nom();
207 // Par defaut chercher en xpath dans la valeur()
208 return table_valeur($this->valeur(), $nom, null);
212 private function calculer_filtres() {
214 // Issu de calculer_select() de public/composer L.519
215 // TODO: externaliser...
217 // retirer les criteres vides:
218 // {X ?} avec X absent de l'URL
219 // {par #ENV{X}} avec X absent de l'URL
220 // IN sur collection vide (ce dernier devrait pouvoir etre fait a la compil)
221 if ($where = &$this->command
['where']) {
223 foreach($where as $k => $v) {
225 if ((count($v)>=2) && ($v[0]=='REGEXP') && ($v[2]=="'.*'")) $op= false;
226 elseif ((count($v)>=2) && ($v[0]=='LIKE') && ($v[2]=="'%'")) $op= false;
227 else $op = $v[0] ?
$v[0] : $v;
229 if ((!$op) OR ($op==1) OR ($op=='0=0')) {
233 // traiter {cle IN a,b} ou {valeur !IN a,b}
234 // prendre en compte le cas particulier de sous-requetes
235 // produites par sql_in quand plus de 255 valeurs passees a IN
236 if (preg_match_all(',\s+IN\s+(\(.*\)),', $op, $s_req)) {
238 foreach($s_req[1] as $key => $val) {
239 $req .= trim($val, '(,)') . ',';
241 $req = '(' . rtrim($req, ',') . ')';
243 if (preg_match(',^\(\(([\w/]+)(\s+NOT)?\s+IN\s+(\(.*\))\)(?:\s+(AND|OR)\s+\(([\w/]+)(\s+NOT)?\s+IN\s+(\(.*\))\))*\)$,', $op, $regs)) {
244 $this->ajouter_filtre($regs[1], 'IN', strlen($req) ?
$req : $regs[3], $regs[2]);
248 foreach($where as $k => $v) {
249 // 3 possibilites : count($v) =
250 // * 1 : {x y} ; on recoit $v[0] = y
251 // * 2 : {x !op y} ; on recoit $v[0] = 'NOT', $v[1] = array() // array du type {x op y}
252 // * 3 : {x op y} ; on recoit $v[0] = 'op', $v[1] = x, $v[2] = y
254 // 1 : forcement traite par un critere, on passe
255 if (count($v) == 1) {
258 if (count($v) == 2 and is_array($v[1])) {
259 $this->ajouter_filtre($v[1][1], $v[1][0], $v[1][2], 'NOT');
261 if (count($v) == 3) {
262 $this->ajouter_filtre($v[1], $v[0], $v[2]);
268 if (isset($this->command
['limit']) AND $this->command
['limit']) {
269 $limit = explode(',',$this->command
['limit']);
270 $this->offset
= $limit[0];
271 $this->limit
= $limit[1];
274 // Creer la fonction de filtrage sur $this
276 $this->func_filtre
= create_function('$me', $b = 'return ('.join(') AND (', $this->filtre
).');');
282 protected function ajouter_filtre($cle, $op, $valeur, $not=false) {
283 if (method_exists($this->iter
, 'exception_des_criteres')) {
284 if (in_array($cle, $this->iter
->exception_des_criteres())) {
288 // TODO: analyser le filtre pour refuser ce qu'on ne sait pas traiter ?
289 # mais c'est normalement deja opere par calculer_critere_infixe()
290 # qui regarde la description 'desc' (en casse reelle d'ailleurs : {isDir=1}
291 # ne sera pas vu si l'on a defini desc['field']['isdir'] pour que #ISDIR soit present.
292 # il faudrait peut etre definir les 2 champs isDir et isdir... a reflechir...
294 # if (!in_array($cle, array('cle', 'valeur')))
297 $a = '$me->get_select(\''.$cle.'\')';
301 if ($op == 'REGEXP') {
302 $filtre = 'match('.$a.', '.str_replace('\"', '"', $valeur).')';
304 } else if ($op == 'LIKE') {
305 $valeur = str_replace(array('\"', '_', '%'), array('"', '.', '.*'), preg_quote($valeur));
306 $filtre = 'match('.$a.', '.$valeur.')';
308 } else if ($op == '=') {
310 } else if ($op == 'IN') {
311 $filtre = 'in_array('.$a.', array'.$valeur.')';
313 } else if (!in_array($op, array('<','<=', '>', '>='))) {
314 spip_log('operateur non reconnu ' . $op); // [todo] mettre une erreur de squelette
319 $filtre = $a.$op.str_replace('\"', '"', $valeur);
322 $filtre = "!($filtre)";
325 $this->filtre
[] = $filtre;
330 public function next(){
339 public function rewind() {
346 # Extension SPIP des iterateurs PHP
348 * type de l'iterateur
354 * parametres de l'iterateur
360 * infos de compilateur
366 * position courante de l'iterateur
372 * nombre total resultats dans l'iterateur
375 protected $total=null;
378 * nombre maximal de recherche pour $total
379 * si l'iterateur n'implemente pas de fonction specifique
381 protected $max=100000;
385 * Liste des champs a inserer dans les $row
386 * retournes par ->fetch()
388 protected $select=array();
392 * aller a la position absolue n,
393 * comptee depuis le debut
397 * @param string $continue
400 * success or fail if not implemented
402 public function seek($n=0, $continue=null) {
403 if ($this->func_filtre
OR !method_exists($this->iter
, 'seek') OR !$this->iter
->seek($n)) {
404 $this->seek_loop($n);
412 * aller a la position $n en parcourant
413 * un par un tous les elements
415 private function seek_loop($n) {
419 while ($this->pos
< $n AND $this->valid()) {
427 * Avancer de $saut pas
432 public function skip($saut, $max=null){
433 // pas de saut en arriere autorise pour cette fonction
434 if (($saut=intval($saut))<=0) return $this->pos
;
435 $seek = $this->pos +
$saut;
436 // si le saut fait depasser le maxi, on libere la resource
439 $max = $this->count();
441 if ($seek>=$max OR $seek>=$this->count()) {
442 // sortie plus rapide que de faire next() jusqu'a la fin !
452 * Renvoyer un tableau des donnees correspondantes
453 * a la position courante de l'iterateur
454 * en controlant si on respecte le filtre
455 * Appliquer aussi le critere {offset,limit}
459 public function fetch() {
460 if (method_exists($this->iter
, 'fetch')) {
461 return $this->iter
->fetch();
464 while ($this->valid()
467 OR (isset($this->offset
) AND $this->fetched++
< $this->offset
)
474 if (isset($this->limit
)
475 AND $this->fetched
> $this->offset +
$this->limit
)
479 foreach ($this->select
as $nom) {
480 $r[$nom] = $this->get_select($nom);
487 // retourner la cle pour #CLE
488 public function cle() {
492 // retourner la valeur pour #VALEUR
493 public function valeur() {
494 # attention PHP est mechant avec les objets, parfois il ne les
495 # clone pas proprement (directoryiterator sous php 5.2.2)
496 # on se rabat sur la version __toString()
497 if (is_object($v = $this->current())) {
498 if (method_exists($v, '__toString'))
499 $v = $v->__toString();
507 * Accepte-t-on l'entree courante lue ?
508 * On execute les filtres pour le savoir.
510 public function accept() {
511 if ($f = $this->func_filtre
) {
518 * liberer la ressource
521 public function free() {
522 if (method_exists($this->iter
, 'free')) {
525 $this->pos
= $this->total
= 0;
530 * Compter le nombre total de resultats
534 public function count() {
535 if (is_null($this->total
)) {
536 if (method_exists($this->iter
, 'count')
537 AND !$this->func_filtre
) {
538 return $this->total
= $this->iter
->count();
540 // compter les lignes et rembobiner
542 $pos = $this->pos
; // sauver la position
544 while ($this->fetch() and $total < $this->max
) {
548 $this->total
= $total;