www/ecrire/public/iterateur.php

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