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