source: spip-zone/_plugins_/iterateurs/public/iterateur.php @ 47955

Last change on this file since 47955 was 47955, checked in by denisb@…, 10 years ago

iterateurs : prendre en compte le cas particulier de sous-requetes produites par sql_in quand plus de 255 valeurs sont passees dans un critere IN d'une boucle DATA.

File size: 13.5 KB
Line 
1<?php
2
3
4/***************************************************************************\
5 *  SPIP, Systeme de publication pour l'internet                           *
6 *                                                                         *
7 *  Copyright (c) 2001-2011                                                *
8 *  Arnaud Martin, Antoine Pitrou, Philippe Riviere, Emmanuel Saint-James  *
9 *                                                                         *
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\***************************************************************************/
13
14if (!defined('_ECRIRE_INC_VERSION')) return;
15
16/**
17 * Fabrique d'iterateur
18 * permet de charger n'importe quel iterateur IterateurXXX
19 * fourni dans le fichier iterateurs/xxx.php
20 *
21 */
22class IterFactory{
23        public static function create($iterateur, $command, $info=null){
24
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) {
29                                if (!$si) {
30                                        return new IterDecorator(new EmptyIterator(), $command, $info);
31                                }
32                        }
33                }
34
35                // chercher un iterateur PHP existant (par exemple dans SPL)
36                // (il faudrait passer l'argument ->serveur
37                // pour etre certain qu'on est sur un "php:")
38                if (class_exists($iterateur)) {
39                        $a = isset($command['args']) ? $command['args'] : array() ;
40
41                        // permettre de passer un Iterateur directement {args #ITERATEUR} :
42                        // si on recoit deja un iterateur en argument, on l'utilise
43                        if (count($a)==1 and is_object($a[0]) and is_subclass_of($a[0], 'Iterator')) {
44                                $iter = $a[0];
45
46                        // sinon, on cree un iterateur du type donne
47                        } else {                                                       
48                                // arguments de creation de l'iterateur...
49                                // (pas glop)
50                                try {
51                                        switch (count($a)) {
52                                                case 0:    $iter = new $iterateur();  break;
53                                                case 1:    $iter = new $iterateur($a[0]);  break;
54                                                case 2:    $iter = new $iterateur($a[0], $a[1]);  break;
55                                                case 3:    $iter = new $iterateur($a[0], $a[1], $a[2]);  break;
56                                                case 4:    $iter = new $iterateur($a[0], $a[1], $a[2], $a[3]);  break;
57                                        }
58                                } catch (Exception $e) {
59                                        spip_log("Erreur de chargement de l'iterateur $iterateur");
60                                        spip_log($e->getMessage());
61                                        $iter = new EmptyIterator();
62                                }
63                        }
64                } else {
65                        // chercher la classe d'iterateur
66                        // IterateurXXX
67                        // definie dans le fichier iterateurs/xxx.php
68                        $class = "Iterateur".$iterateur;
69                        if (!include_spip("iterateur/" . strtolower($iterateur))
70                          OR !class_exists($class)) {
71                                die("Iterateur $iterateur non trouv&#233;");
72                                // si l'iterateur n'existe pas, on se rabat sur le generique
73                                $iter = new EmptyIterator();
74                        } else {
75                                $iter = new $class($command, $info);
76                        }
77                }
78                return new IterDecorator($iter, $command, $info);
79        }
80}
81
82
83
84
85class IterDecorator extends FilterIterator {
86        private $iter;
87
88        /**
89         * Conditions de filtrage
90         * ie criteres de selection
91         * @var array
92         */
93        protected $filtre = array();
94
95        /**
96         * Fonction de filtrage compilee a partir des criteres de filtre
97         * @var string
98         */
99        protected $func_filtre = null;
100
101        /**
102         * Critere {offset, limit}
103         * @var int
104         * @var int
105         */
106        protected $offset = null;
107        protected $limit = null;
108
109        /**
110         * nombre d'elements recuperes depuis la position 0,
111         * en tenant compte des filtres
112         * @var int
113         */
114        protected $fetched=0;
115
116        /**
117         * Drapeau a activer en cas d'echec
118         * (select SQL errone, non chargement des DATA, etc)
119         */
120        public function err() {
121                if (method_exists($this->iter, 'err'))
122                        return $this->iter->err();
123                if (property_exists($this->iter, 'err'))
124                        return $this->iter->err;
125                return false;
126        }
127
128        public function __construct(Iterator $iter, $command, $info){
129                parent::__construct($iter);
130                parent::rewind(); // remettre a la premiere position (bug? connu de FilterIterator)
131               
132                // recuperer l'iterateur transmis
133                $this->iter = $this->getInnerIterator();
134                $this->command = $command;
135                $this->info = $info;
136                $this->pos = 0;
137                $this->fetched = 0;
138
139                // chercher la liste des champs a retourner par
140                // fetch si l'objet ne les calcule pas tout seul
141                if (!method_exists($this->iter, 'fetch')) {
142                        $this->calculer_select();
143                        $this->calculer_filtres();
144                }
145
146                $this->err = $this->iter->err;
147
148                $this->total = $this->count();
149        }
150
151
152        // calcule les elements a retournes par fetch()
153        // enleve les elements inutiles du select()
154        //
155        private function calculer_select() {
156                if ($select = &$this->command['select']) {
157                        foreach($select as $s) {
158                                // /!\ $s = '.nom'
159                                if ($s[0] == '.') {
160                                        $s = substr($s, 1);
161                                }
162                                $this->select[] = $s;
163                        }
164                }
165        }
166
167        // recuperer la valeur d'une balise #X
168        // en fonction des methodes
169        // et proprietes disponibles
170        public function get_select($nom) {
171                if (is_object($this->iter)
172                AND method_exists($this->iter, $nom)) {
173                        try {
174                                return $this->iter->$nom();
175                        } catch(Exception $e) {
176                                // #GETCHILDREN sur un fichier de DirectoryIterator ...
177                                spip_log("Methode $nom en echec sur " . get_class($this->iter));
178                                spip_log("Cela peut être normal : retour d'une ligne de resultat ne pouvant pas calculer cette methode");
179                                return '';
180                        }
181                }
182                /*
183                if (property_exists($this->iter, $nom)) {
184                        return $this->iter->$nom;
185                }*/
186                // cle et valeur par defaut
187                // ICI PLANTAGE SI ON NE CONTROLE PAS $nom
188                if (in_array($nom, array('cle', 'valeur'))
189                AND method_exists($this, $nom)) {
190                        return $this->$nom();
191                }
192
193                // Par defaut chercher en xpath dans la valeur()
194                return Iterateurs_table_valeur($this->valeur(), $nom);
195        }
196
197       
198        private function calculer_filtres() {
199               
200                // Issu de calculer_select() de public/composer L.519
201                // [todo] externaliser...
202                //
203                // retirer les criteres vides:
204                // {X ?} avec X absent de l'URL
205                // {par #ENV{X}} avec X absent de l'URL
206                // IN sur collection vide (ce dernier devrait pouvoir etre fait a la compil)
207                if ($where = &$this->command['where']) {
208                        $menage = false;
209                        foreach($where as $k => $v) { 
210                                if (is_array($v)){
211                                        if ((count($v)>=2) && ($v[0]=='REGEXP') && ($v[2]=="'.*'")) $op= false;
212                                        elseif ((count($v)>=2) && ($v[0]=='LIKE') && ($v[2]=="'%'")) $op= false;
213                                        else $op = $v[0] ? $v[0] : $v;
214                                } else $op = $v;
215                                if ((!$op) OR ($op==1) OR ($op=='0=0')) {
216                                        unset($where[$k]);
217                                        $menage = true;
218                                }
219                                // traiter {cle IN a,b} ou {valeur !IN a,b}                             
220                                // prendre en compte le cas particulier de sous-requetes
221                                // produites par sql_in quand plus de 255 valeurs passees a IN
222                                if (preg_match_all(',\s+IN\s+(\(.*\)),', $op, $s_req)) {
223                                        $req = '';
224                                        foreach($s_req[1] as $key => $val) {
225                                                $req .= trim($val, '(,)').',';
226                                        }
227                                        $req = '(' . rtrim($req, ',') . ')';
228                                }
229                                if (preg_match(',^\(\(([\w/]+)(\s+NOT)?\s+IN\s+(\(.*\))\)(?:\s+(AND|OR)\s+\(([\w/]+)(\s+NOT)?\s+IN\s+(\(.*\))\))*\)$,', $op, $regs)) {
230                                        $this->ajouter_filtre($regs[1], 'IN', strlen($req) ? $req : $regs[3], $regs[2]);
231                                        unset($op);
232                                }
233                        }
234                        foreach($where as $k => $v) {
235                                // 3 possibilites : count($v) =
236                                // * 1 : {x y} ; on recoit $v[0] = y
237                                // * 2 : {x !op y} ; on recoit $v[0] = 'NOT', $v[1] = array() // array du type {x op y}
238                                // * 3 : {x op y} ; on recoit $v[0] = 'op', $v[1] = x, $v[2] = y
239
240                                // 1 : forcement traite par un critere, on passe
241                                if (count($v) == 1) {
242                                        continue;
243                                }
244                                if (count($v) == 2) {
245                                        $this->ajouter_filtre($v[1][1], $v[1][0], $v[1][2], 'NOT');
246                                }
247                                if (count($v) == 3) {
248                                        $this->ajouter_filtre($v[1], $v[0], $v[2]);
249                                }
250                        }
251                }
252
253                // critere {2,7}
254                if ($this->command['limit']) {
255                        $limit = explode(',',$this->command['limit']);
256                        $this->offset = $limit[0];
257                        $this->limit = $limit[1];
258                }
259
260                // Creer la fonction de filtrage sur $this
261                if ($this->filtre) {
262                        $this->func_filtre = create_function('$me', $b = 'return ('.join(') AND (', $this->filtre).');');
263                }
264        }
265
266
267
268        protected function ajouter_filtre($cle, $op, $valeur, $not=false) {
269                if (method_exists($this->iter, 'exception_des_criteres')) {
270                        if (in_array($cle, $this->iter->exception_des_criteres())) {
271                                return;
272                        }
273                }
274                # [todo ?] analyser le filtre pour refuser ce qu'on ne sait pas traiter ?
275                # mais c'est normalement deja opere par calculer_critere_infixe()
276                # qui regarde la description 'desc' (en casse reelle d'ailleurs : {isDir=1}
277                # ne sera pas vu si l'on a defini desc['field']['isdir'] pour que #ISDIR soit present.
278                # il faudrait peut etre definir les 2 champs isDir et isdir... a reflechir...
279               
280                # if (!in_array($cle, array('cle', 'valeur')))
281                #       return;
282
283                $a = '$me->get_select(\''.$cle.'\')';
284
285                $filtre = '';
286               
287                if ($op == 'REGEXP') {
288                        $filtre = 'match('.$a.', '.str_replace('\"', '"', $valeur).')';
289                        $op = '';
290                } else if ($op == 'LIKE') {
291                        $valeur = str_replace(array('\"', '_', '%'), array('"', '.', '.*'), preg_quote($valeur));
292                        $filtre = 'match('.$a.', '.$valeur.')';
293                        $op = '';
294                } else if ($op == '=') {
295                        $op = '==';
296                } else if ($op == 'IN') {
297                        $filtre = 'in_array('.$a.', array'.$valeur.')';
298                        $op = '';
299                } else if (!in_array($op, array('<','<=', '>', '>='))) {
300                        spip_log('operateur non reconnu ' . $op); // [todo] mettre une erreur de squelette
301                        $op = '';
302                }
303       
304                if ($op)
305                        $filtre = $a.$op.str_replace('\"', '"', $valeur);
306
307                if ($not)
308                        $filtre = "!($filtre)";
309                       
310                if ($filtre) {
311                        $this->filtre[] = $filtre;
312                }
313        }
314
315       
316        public function next(){
317                $this->pos++;
318                parent::next();
319        }
320
321        /**
322         * revient au depart
323         * @return void
324         */
325        public function rewind() {
326                $this->pos = 0;
327                $this->fetched = 0;
328                parent::rewind();
329        }
330
331
332        # Extension SPIP des iterateurs PHP
333        /**
334         * type de l'iterateur
335         * @var string
336         */
337        protected $type;
338
339        /**
340         * parametres de l'iterateur
341         * @var array
342         */
343        protected $command;
344
345        /**
346         * infos de compilateur
347         * @var array
348         */
349        protected $info;
350
351        /**
352         * position courante de l'iterateur
353         * @var int
354         */
355        protected $pos=null;
356
357        /**
358         * nombre total resultats dans l'iterateur
359         * @var int
360         */
361        protected $total=null;
362
363        /**
364         * nombre maximal de recherche pour $total
365         * si l'iterateur n'implemente pas de fonction specifique
366         */
367         protected $max=100000;
368
369
370        /**
371         * Liste des champs a inserer dans les $row
372         * retournes par ->fetch()
373         */
374         protected $select=array();
375
376         
377        /**
378         * aller a la position absolue n,
379         * comptee depuis le debut
380         *
381         * @param int $n
382         *   absolute pos
383         * @param string $continue
384         *   param for sql_ api
385         * @return bool
386         *   success or fail if not implemented
387         */
388        public function seek($n=0, $continue=null) {
389                if ($this->func_filtre OR !method_exists($this->iter, 'seek') OR !$this->iter->seek($n)) {
390                        $this->seek_loop($n);
391                }
392                $this->pos = $n;
393                $this->fetched = $n;
394                return true;
395        }
396
397        /*
398         * aller a la position $n en parcourant
399         * un par un tous les elements
400         */
401        private function seek_loop($n) {
402                if ($this->pos > $n)
403                        $this->rewind();
404
405                while ($this->pos < $n AND $this->valid()) {
406                        $this->next();
407                }
408               
409                return true;
410        }
411
412        /**
413         * Avancer de $saut pas
414         * @param  $saut
415         * @param  $max
416         * @return int
417         */
418        public function skip($saut, $max=null){
419                // pas de saut en arriere autorise pour cette fonction
420                if (($saut=intval($saut))<=0) return $this->pos;
421                $seek = $this->pos + $saut;
422                // si le saut fait depasser le maxi, on libere la resource
423                // et on sort
424                if (is_null($max))
425                        $max = $this->count();
426
427                if ($seek>=$max OR $seek>=$this->count()) {
428                        // sortie plus rapide que de faire next() jusqu'a la fin !
429                        $this->free();
430                  return $max;
431                }
432
433          $this->seek($seek);
434          return $this->pos;
435        }
436
437        /**
438         * Renvoyer un tableau des donnees correspondantes
439         * a la position courante de l'iterateur
440         * en controlant si on respecte le filtre
441         * Appliquer aussi le critere {offset,limit}
442         *
443         * @return array|bool
444         */
445        public function fetch() {
446                if (method_exists($this->iter, 'fetch')) {
447                        return $this->iter->fetch();
448                } else {
449
450                        while ($this->valid()
451                        AND (
452                                !$this->accept()
453                                OR (isset($this->offset) AND $this->fetched++ < $this->offset)
454                        ))
455                                $this->next();
456
457                        if (!$this->valid())
458                                return false;
459
460                        if (isset($this->limit)
461                        AND $this->fetched > $this->offset + $this->limit)
462                                return false;
463
464                        $r = array();
465                        foreach ($this->select as $nom) {
466                                $r[$nom] = $this->get_select($nom);
467                        }
468                        $this->next();
469                        return $r;
470                }
471        }
472
473        // retourner la cle pour #CLE
474        public function cle() {
475                return $this->key();
476        }
477       
478        // retourner la valeur pour #VALEUR
479        public function valeur() {
480                # attention PHP est mechant avec les objets, parfois il ne les
481                # clone pas proprement (directoryiterator sous php 5.2.2)
482                # on se rabat sur la version __toString()
483                if (is_object($v = $this->current())) {
484                        if (method_exists($v, '__toString'))
485                                $v = $v->__toString();
486                        else
487                                $v = (array) $v;
488                }
489                return $v;
490        }
491
492        /**
493         * Accepte-t-on l'entree courante lue ?
494         * On execute les filtres pour le savoir.
495        **/
496        public function accept() {
497                if ($f = $this->func_filtre) {
498                        return $f($this);
499                }
500                return true;
501        }
502
503        /**
504         * liberer la ressource
505         * @return bool
506         */
507        public function free() {
508                if (method_exists($this->iter, 'free')) {
509                        $this->iter->free();
510                }
511                $this->pos = $this->total = 0;
512                return true;
513        }
514
515        /**
516         * Compter le nombre total de resultats
517         * pour #TOTAL_BOUCLE
518         * @return int
519         */
520        public function count() {
521                if (is_null($this->total)) {
522                        if (method_exists($this->iter, 'count')
523                        AND !$this->func_filtre) {
524                                return $this->total = $this->iter->count();
525                        } else {
526                                // compter les lignes et rembobiner
527                                $total = 0;
528                                $pos = $this->pos; // sauver la position
529                                $this->rewind();
530                                while ($this->fetch() and $total < $this->max) {
531                                        $total++;
532                                }
533                                $this->seek($pos);
534                                $this->total = $total;
535                        }
536                }
537
538                return $this->total;
539        }
540       
541}
542
543
544?>
Note: See TracBrowser for help on using the repository browser.