www/ecrire/inc/rechercher.php

   1 <?php
   2
   3 /***************************************************************************\
   4  *  SPIP, Systeme de publication pour l'internet                           *
   5  *                                                                         *
   6  *  Copyright (c) 2001-2017                                                *
   7  *  Arnaud Martin, Antoine Pitrou, Philippe Riviere, Emmanuel Saint-James  *
   8  *                                                                         *
   9  *  Ce programme est un logiciel libre distribue sous licence GNU/GPL.     *
  10  *  Pour plus de details voir le fichier COPYING.txt ou l'aide en ligne.   *
  11 \***************************************************************************/
  12
  13 /**
  14  * Gestion des recherches
  15  *
  16  * @package SPIP\Core\Recherche
  17  **/
  18
  19 if (!defined('_ECRIRE_INC_VERSION')) {
  20         return;
  21 }
  22
  23
  24 /**
  25  * Donne la liste des champs/tables où l'on sait chercher / remplacer
  26  * avec un poids pour le score
  27  *
  28  * Utilise l'information `rechercher_champs` sur la déclaration
  29  * des objets éditoriaux.
  30  *
  31  * @pipeline_appel rechercher_liste_des_champs
  32  * @uses lister_tables_objets_sql()
  33  *
  34  * @return array Couples (type d'objet => Couples (champ => score))
  35  */
  36 function liste_des_champs() {
  37         static $liste = null;
  38         if (is_null($liste)) {
  39                 $liste = array();
  40                 // recuperer les tables_objets_sql declarees
  41                 include_spip('base/objets');
  42                 $tables_objets = lister_tables_objets_sql();
  43                 foreach ($tables_objets as $t => $infos) {
  44                         if ($infos['rechercher_champs']) {
  45                                 $liste[$infos['type']] = $infos['rechercher_champs'];
  46                         }
  47                 }
  48                 // puis passer dans le pipeline
  49                 $liste = pipeline('rechercher_liste_des_champs', $liste);
  50         }
  51
  52         return $liste;
  53 }
  54
  55
  56 // Recherche des auteurs et mots-cles associes
  57 // en ne regardant que le titre ou le nom
  58 // http://code.spip.net/@liste_des_jointures
  59 function liste_des_jointures() {
  60         static $liste = null;
  61         if (is_null($liste)) {
  62                 $liste = array();
  63                 // recuperer les tables_objets_sql declarees
  64                 include_spip('base/objets');
  65                 $tables_objets = lister_tables_objets_sql();
  66                 foreach ($tables_objets as $t => $infos) {
  67                         if ($infos['rechercher_jointures']) {
  68                                 $liste[$infos['type']] = $infos['rechercher_jointures'];
  69                         }
  70                 }
  71                 // puis passer dans le pipeline
  72                 $liste = pipeline('rechercher_liste_des_jointures', $liste);
  73         }
  74
  75         return $liste;
  76 }
  77
  78 function expression_recherche($recherche, $options) {
  79         // ne calculer qu'une seule fois l'expression par hit
  80         // (meme si utilisee dans plusieurs boucles)
  81         static $expression = array();
  82         $key = serialize(array($recherche, $options['preg_flags']));
  83         if (isset($expression[$key])) {
  84                 return $expression[$key];
  85         }
  86
  87         $u = $GLOBALS['meta']['pcre_u'];
  88         if ($u and strpos($options['preg_flags'], $u) === false) {
  89                 $options['preg_flags'] .= $u;
  90         }
  91         include_spip('inc/charsets');
  92         $recherche = trim($recherche);
  93
  94         $is_preg = false;
  95         if (substr($recherche, 0, 1) == '/' and substr($recherche, -1, 1) == '/' and strlen($recherche) > 2) {
  96                 // c'est une preg
  97                 $recherche_trans = translitteration($recherche);
  98                 $preg = $recherche_trans . $options['preg_flags'];
  99                 $is_preg = true;
 100         } else {
 101                 // s'il y a plusieurs mots il faut les chercher tous : oblige REGEXP,
 102                 // sauf ceux de moins de 4 lettres (on supprime ainsi 'le', 'les', 'un',
 103                 // 'une', 'des' ...)
 104
 105                 // attention : plusieurs mots entre guillemets sont a rechercher tels quels
 106                 $recherche_trans = $recherche_mod = $recherche;
 107
 108                 // les expressions entre " " sont un mot a chercher tel quel
 109                 // -> on remplace les espaces par un \x1 et on enleve les guillemets
 110                 if (preg_match(',["][^"]+["],Uims', $recherche_mod, $matches)) {
 111                         foreach ($matches as $match) {
 112                                 $word = preg_replace(",\s+,Uims", "\x1", $match);
 113                                 $word = trim($word, '"');
 114                                 $recherche_mod = str_replace($match, $word, $recherche_mod);
 115                         }
 116                 }
 117
 118                 if (preg_match(",\s+," . $u, $recherche_mod)) {
 119                         $is_preg = true;
 120
 121                         $recherche_inter = '|';
 122                         $recherche_mots = explode(' ', $recherche_mod);
 123                         $min_long = defined('_RECHERCHE_MIN_CAR') ? _RECHERCHE_MIN_CAR : 4;
 124                         foreach ($recherche_mots as $mot) {
 125                                 if (strlen($mot) >= $min_long) {
 126                                         // echapper les caracteres de regexp qui sont eventuellement dans la recherche
 127                                         $recherche_inter .= preg_quote($mot) . ' ';
 128                                 }
 129                         }
 130                         $recherche_inter = str_replace("\x1", '\s', $recherche_inter);
 131
 132                         // mais on cherche quand même l'expression complète, même si elle
 133                         // comporte des mots de moins de quatre lettres
 134                         $recherche = rtrim(preg_quote($recherche) . preg_replace(',\s+,' . $u, '|', $recherche_inter), '|');
 135                         $recherche_trans = translitteration($recherche);
 136                 }
 137
 138                 $preg = '/' . str_replace('/', '\\/', $recherche_trans) . '/' . $options['preg_flags'];
 139         }
 140
 141         // Si la chaine est inactive, on va utiliser LIKE pour aller plus vite
 142         // ou si l'expression reguliere est invalide
 143         if (!$is_preg
 144                 or (@preg_match($preg, '') === false)
 145         ) {
 146                 $methode = 'LIKE';
 147                 $u = $GLOBALS['meta']['pcre_u'];
 148
 149                 // echapper les % et _
 150                 $q = str_replace(array('%', '_'), array('\%', '\_'), trim($recherche));
 151
 152                 // eviter les parentheses et autres caractères qui interferent avec pcre par la suite (dans le preg_match_all) s'il y a des reponses
 153                 $recherche = preg_quote($recherche, '/');
 154                 $recherche_trans = translitteration($recherche);
 155                 $recherche_mod = $recherche_trans;
 156
 157                 // les expressions entre " " sont un mot a chercher tel quel
 158                 // -> on remplace les espaces par un _ et on enleve les guillemets
 159                 // corriger le like dans le $q
 160                 if (preg_match(',["][^"]+["],Uims', $q, $matches)) {
 161                         foreach ($matches as $match) {
 162                                 $word = preg_replace(",\s+,Uims", "_", $match);
 163                                 $word = trim($word, '"');
 164                                 $q = str_replace($match, $word, $q);
 165                         }
 166                 }
 167                 // corriger la regexp
 168                 if (preg_match(',["][^"]+["],Uims', $recherche_mod, $matches)) {
 169                         foreach ($matches as $match) {
 170                                 $word = preg_replace(",\s+,Uims", "[\s]", $match);
 171                                 $word = trim($word, '"');
 172                                 $recherche_mod = str_replace($match, $word, $recherche_mod);
 173                         }
 174                 }
 175                 $q = sql_quote(
 176                         "%"
 177                         . preg_replace(",\s+," . $u, "%", $q)
 178                         . "%"
 179                 );
 180
 181                 $preg = '/' . preg_replace(",\s+," . $u, ".+", trim($recherche_mod)) . '/' . $options['preg_flags'];
 182         } else {
 183                 $methode = 'REGEXP';
 184                 $q = sql_quote(trim($recherche, '/'));
 185         }
 186
 187         // tous les caracteres transliterables de $q sont remplaces par un joker
 188         // permet de matcher en SQL meme si on est sensible aux accents (SQLite)
 189         $q_t = $q;
 190         for ($i = 0; $i < spip_strlen($q); $i++) {
 191                 $char = spip_substr($q, $i, 1);
 192                 if (!is_ascii($char)
 193                         and $char_t = translitteration($char)
 194                         and $char_t !== $char
 195                 ) {
 196                         $q_t = str_replace($char, $is_preg ? "." : "_", $q_t);
 197                 }
 198         }
 199
 200         $q = $q_t;
 201
 202         // fix : SQLite 3 est sensible aux accents, on jokerise les caracteres
 203         // les plus frequents qui peuvent etre accentues
 204         // (oui c'est tres dicustable...)
 205         if (isset($GLOBALS['connexions'][$options['serveur'] ? $options['serveur'] : 0]['type'])
 206                 and strncmp($GLOBALS['connexions'][$options['serveur'] ? $options['serveur'] : 0]['type'], 'sqlite', 6) == 0
 207         ) {
 208                 $q_t = strtr($q, "aeuioc", $is_preg ? "......" : "______");
 209                 // si il reste au moins un char significatif...
 210                 if (preg_match(",[^'%_.],", $q_t)) {
 211                         $q = $q_t;
 212                 }
 213         }
 214
 215         return $expression[$key] = array($methode, $q, $preg);
 216 }
 217
 218
 219
 220 /**
 221  * Effectue une recherche sur toutes les tables de la base de données
 222  *
 223  * @uses liste_des_champs()
 224  * @uses inc_recherche_to_array_dist()
 225  *
 226  * @param string $recherche
 227  *     Le terme de recherche
 228  * @param null|array|string $tables
 229  *     - null : toutes les tables acceptant des recherches
 230  *     - array : liste des tables souhaitées
 231  *     - string : une chaîne listant les tables souhaitées, séparées par des virgules (préférer array cependant)
 232  * @param array $options {
 233  *     @var $toutvoir pour éviter autoriser(voir)
 234  *     @var $flags pour éviter les flags regexp par défaut (UimsS)
 235  *     @var $champs pour retourner les champs concernés
 236  *     @var $score pour retourner un score
 237  * }
 238  * @param string $serveur
 239  * @return array
 240  */
 241 function recherche_en_base($recherche = '', $tables = null, $options = array(), $serveur = '') {
 242         include_spip('base/abstract_sql');
 243
 244         if (!is_array($tables)) {
 245                 $liste = liste_des_champs();
 246
 247                 if (is_string($tables)
 248                         and $tables != ''
 249                 ) {
 250                         $toutes = array();
 251                         foreach (explode(',', $tables) as $t) {
 252                                 $t = trim($t);
 253                                 if (isset($liste[$t])) {
 254                                         $toutes[$t] = $liste[$t];
 255                                 }
 256                         }
 257                         $tables = $toutes;
 258                         unset($toutes);
 259                 } else {
 260                         $tables = $liste;
 261                 }
 262         }
 263
 264         if (!strlen($recherche) or !count($tables)) {
 265                 return array();
 266         }
 267
 268         include_spip('inc/autoriser');
 269
 270         // options par defaut
 271         $options = array_merge(array(
 272                 'preg_flags' => 'UimsS',
 273                 'toutvoir' => false,
 274                 'champs' => false,
 275                 'score' => false,
 276                 'matches' => false,
 277                 'jointures' => false,
 278                 'serveur' => $serveur
 279         ),
 280                 $options
 281         );
 282
 283         $results = array();
 284
 285         // Utiliser l'iterateur (DATA:recherche)
 286         // pour recuperer les couples (id_objet, score)
 287         // Le resultat est au format {
 288         //      id1 = { 'score' => x, attrs => { } },
 289         //      id2 = { 'score' => x, attrs => { } },
 290         // }
 291
 292         foreach ($tables as $table => $champs) {
 293                 # lock via memoization, si dispo
 294                 if (function_exists('cache_lock')) {
 295                         cache_lock($lock = 'recherche ' . $table . ' ' . $recherche);
 296                 }
 297
 298                 spip_timer('rech');
 299
 300                 // TODO: ici plutot charger un iterateur via l'API iterateurs
 301                 include_spip('inc/recherche_to_array');
 302                 $to_array = charger_fonction('recherche_to_array', 'inc');
 303                 $results[$table] = $to_array($recherche,
 304                         array_merge($options, array('table' => $table, 'champs' => $champs))
 305                 );
 306                 ##var_dump($results[$table]);
 307
 308
 309                 spip_log("recherche $table ($recherche) : " . count($results[$table]) . " resultats " . spip_timer('rech'),
 310                         'recherche');
 311
 312                 if (isset($lock)) {
 313                         cache_unlock($lock);
 314                 }
 315         }
 316
 317         return $results;
 318 }
 319
 320
 321 // Effectue une recherche sur toutes les tables de la base de donnees
 322 // http://code.spip.net/@remplace_en_base
 323 function remplace_en_base($recherche = '', $remplace = null, $tables = null, $options = array()) {
 324         include_spip('inc/modifier');
 325
 326         // options par defaut
 327         $options = array_merge(array(
 328                 'preg_flags' => 'UimsS',
 329                 'toutmodifier' => false
 330         ),
 331                 $options
 332         );
 333         $options['champs'] = true;
 334
 335
 336         if (!is_array($tables)) {
 337                 $tables = liste_des_champs();
 338         }
 339
 340         $results = recherche_en_base($recherche, $tables, $options);
 341
 342         $preg = '/' . str_replace('/', '\\/', $recherche) . '/' . $options['preg_flags'];
 343
 344         foreach ($results as $table => $r) {
 345                 $_id_table = id_table_objet($table);
 346                 foreach ($r as $id => $x) {
 347                         if ($options['toutmodifier']
 348                                 or autoriser('modifier', $table, $id)
 349                         ) {
 350                                 $modifs = array();
 351                                 foreach ($x['champs'] as $key => $val) {
 352                                         if ($key == $_id_table) {
 353                                                 next;
 354                                         }
 355                                         $repl = preg_replace($preg, $remplace, $val);
 356                                         if ($repl <> $val) {
 357                                                 $modifs[$key] = $repl;
 358                                         }
 359                                 }
 360                                 if ($modifs) {
 361                                         objet_modifier_champs($table, $id,
 362                                                 array(
 363                                                         'champs' => array_keys($modifs),
 364                                                 ),
 365                                                 $modifs);
 366                                 }
 367                         }
 368                 }
 369         }
 370 }