lib/searchlib.php

   1 <?php
   2
   3 // This file is part of Moodle - http://moodle.org/
   4 //
   5 // Moodle is free software: you can redistribute it and/or modify
   6 // it under the terms of the GNU General Public License as published by
   7 // the Free Software Foundation, either version 3 of the License, or
   8 // (at your option) any later version.
   9 //
  10 // Moodle is distributed in the hope that it will be useful,
  11 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  12 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13 // GNU General Public License for more details.
  14 //
  15 // You should have received a copy of the GNU General Public License
  16 // along with Moodle.  If not, see <http://www.gnu.org/licenses/>.
  17
  18 /**
  19  * @package    core
  20  * @subpackage search
  21  * @copyright  1999 onwards Martin Dougiamas  {@link http://moodle.com}
  22  * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
  23  */
  24
  25 defined('MOODLE_INTERNAL') || die();
  26
  27 /** @see lexer.php */
  28 require_once($CFG->libdir.'/lexer.php');
  29
  30 /** Constants for the various types of tokens */
  31
  32 define("TOKEN_USER","0");
  33 define("TOKEN_META","1");
  34 define("TOKEN_EXACT","2");
  35 define("TOKEN_NEGATE","3");
  36 define("TOKEN_STRING","4");
  37 define("TOKEN_USERID","5");
  38 define("TOKEN_DATEFROM","6");
  39 define("TOKEN_DATETO","7");
  40 define("TOKEN_INSTANCE","8");
  41 define("TOKEN_TAGS","9");
  42
  43 /**
  44  * Class to hold token/value pairs after they're parsed.
  45  *
  46  * @package   moodlecore
  47  * @copyright 1999 onwards Martin Dougiamas  {@link http://moodle.com}
  48  * @license   http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
  49  */
  50 class search_token {
  51   private $value;
  52   private $type;
  53
  54   public function __construct($type,$value){
  55     $this->type = $type;
  56     $this->value = $this->sanitize($value);
  57
  58   }
  59
  60   /**
  61    * Old syntax of class constructor. Deprecated in PHP7.
  62    *
  63    * @deprecated since Moodle 3.1
  64    */
  65   public function search_token($type, $value) {
  66     debugging('Use of class name as constructor is deprecated', DEBUG_DEVELOPER);
  67     self::__construct($type, $value);
  68   }
  69
  70   // Try to clean up user input to avoid potential security issues.
  71   // Need to think about this some more.
  72
  73   function sanitize($userstring){
  74     return htmlspecialchars($userstring);
  75   }
  76   function getValue(){
  77     return $this->value;
  78   }
  79   function getType(){
  80     return $this->type;
  81   }
  82 }
  83
  84
  85 /**
  86  * This class does the heavy lifting of lexing the search string into tokens.
  87  * Using a full-blown lexer is probably overkill for this application, but
  88  * might be useful for other tasks.
  89  *
  90  * @package   moodlecore
  91  * @copyright 1999 onwards Martin Dougiamas  {@link http://moodle.com}
  92  * @license   http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
  93  */
  94 class search_lexer extends Lexer{
  95
  96   public function __construct(&$parser){
  97
  98     // Call parent constructor.
  99     parent::__construct($parser);
 100
 101     //Set up the state machine and pattern matches for transitions.
 102
 103     // Patterns to handle strings  of the form datefrom:foo
 104
 105     // If we see the string datefrom: while in the base accept state, start
 106     // parsing a username and go to the indatefrom state.
 107     $this->addEntryPattern("datefrom:\S+","accept","indatefrom");
 108
 109     // Snarf everything into the username until we see whitespace, then exit
 110     // back to the base accept state.
 111     $this->addExitPattern("\s","indatefrom");
 112
 113
 114     // If we see the string tags: while in the base accept state, start
 115     // parsing tags and go to the intags state.
 116     $this->addEntryPattern("tags:\S+","accept","intags");
 117
 118     // Snarf everything into the tags until we see whitespace, then exit
 119     // back to the base accept state.
 120     $this->addExitPattern("\s","intags");
 121
 122     // Patterns to handle strings  of the form dateto:foo
 123
 124     // If we see the string dateto: while in the base accept state, start
 125     // parsing a username and go to the indateto state.
 126     $this->addEntryPattern("dateto:\S+","accept","indateto");
 127
 128     // Snarf everything into the username until we see whitespace, then exit
 129     // back to the base accept state.
 130     $this->addExitPattern("\s","indateto");
 131
 132
 133     // Patterns to handle strings  of the form instance:foo
 134
 135     // If we see the string instance: while in the base accept state, start
 136     // parsing for instance number and go to the ininstance state.
 137     $this->addEntryPattern("instance:\S+","accept","ininstance");
 138
 139     // Snarf everything into the username until we see whitespace, then exit
 140     // back to the base accept state.
 141     $this->addExitPattern("\s","ininstance");
 142
 143
 144     // Patterns to handle strings  of the form userid:foo
 145
 146     // If we see the string userid: while in the base accept state, start
 147     // parsing a username and go to the inuserid state.
 148     $this->addEntryPattern("userid:\S+","accept","inuserid");
 149
 150     // Snarf everything into the username until we see whitespace, then exit
 151     // back to the base accept state.
 152     $this->addExitPattern("\s","inuserid");
 153
 154
 155     // Patterns to handle strings  of the form user:foo
 156
 157     // If we see the string user: while in the base accept state, start
 158     // parsing a username and go to the inusername state.
 159     $this->addEntryPattern("user:\S+","accept","inusername");
 160
 161     // Snarf everything into the username until we see whitespace, then exit
 162     // back to the base accept state.
 163     $this->addExitPattern("\s","inusername");
 164
 165
 166     // Patterns to handle strings  of the form meta:foo
 167
 168    // If we see the string meta: while in the base accept state, start
 169     // parsing a username and go to the inmeta state.
 170     $this->addEntryPattern("subject:\S+","accept","inmeta");
 171
 172     // Snarf everything into the meta token until we see whitespace, then exit
 173     // back to the base accept state.
 174     $this->addExitPattern("\s","inmeta");
 175
 176
 177     // Patterns to handle required exact match strings (+foo) .
 178
 179     // If we see a + sign  while in the base accept state, start
 180     // parsing an exact match string and enter the inrequired state
 181     $this->addEntryPattern("\+\S+","accept","inrequired");
 182     // When we see white space, exit back to accept state.
 183     $this->addExitPattern("\s","inrequired");
 184
 185     // Handle excluded strings (-foo)
 186
 187    // If we see a - sign  while in the base accept state, start
 188     // parsing an excluded string and enter the inexcluded state
 189     $this->addEntryPattern("\-\S+","accept","inexcluded");
 190     // When we see white space, exit back to accept state.
 191     $this->addExitPattern("\s","inexcluded");
 192
 193
 194     // Patterns to handle quoted strings.
 195
 196     // If we see a quote  while in the base accept state, start
 197     // parsing a quoted string and enter the inquotedstring state.
 198     // Grab everything until we see the closing quote.
 199
 200     $this->addEntryPattern("\"[^\"]+","accept","inquotedstring");
 201
 202     // When we see a closing quote, reenter the base accept state.
 203     $this->addExitPattern("\"","inquotedstring");
 204
 205     // Patterns to handle ordinary, nonquoted words.
 206
 207     // When we see non-whitespace, snarf everything into the nonquoted word
 208     // until we see whitespace again.
 209     $this->addEntryPattern("\S+","accept","plainstring");
 210
 211     // Once we see whitespace, reenter the base accept state.
 212     $this->addExitPattern("\s","plainstring");
 213
 214   }
 215
 216   /**
 217    * Old syntax of class constructor. Deprecated in PHP7.
 218    *
 219    * @deprecated since Moodle 3.1
 220    */
 221   public function search_lexer(&$parser) {
 222     debugging('Use of class name as constructor is deprecated', DEBUG_DEVELOPER);
 223     self::__construct($parser);
 224   }
 225
 226 }
 227
 228
 229
 230 /**
 231  * This class takes care of sticking the proper token type/value pairs into
 232  * the parsed token  array.
 233  * Most functions in this class should only be called by the lexer, the
 234  * one exception being getParseArray() which returns the result.
 235  *
 236  * @package   moodlecore
 237  * @copyright 1999 onwards Martin Dougiamas  {@link http://moodle.com}
 238  * @license   http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
 239  */
 240 class search_parser {
 241     private $tokens;
 242
 243     // This function is called by the code that's interested in the result of the parse operation.
 244     function get_parsed_array(){
 245         return $this->tokens;
 246     }
 247
 248     /*
 249      * Functions below this are part of the state machine for the parse
 250      * operation and should not be called directly.
 251      */
 252
 253     // Base state. No output emitted.
 254     function accept() {
 255         return true;
 256     }
 257
 258     // State for handling datefrom:foo constructs. Potentially emits a token.
 259     function indatefrom($content){
 260         if (strlen($content) < 10) { // State exit or missing parameter.
 261             return true;
 262         }
 263         // Strip off the datefrom: part and add the reminder to the parsed token array
 264         $param = trim(substr($content,9));
 265         $this->tokens[] = new search_token(TOKEN_DATEFROM,$param);
 266         return true;
 267     }
 268
 269     // State for handling dateto:foo constructs. Potentially emits a token.
 270     function indateto($content){
 271         if (strlen($content) < 8) { // State exit or missing parameter.
 272             return true;
 273         }
 274         // Strip off the dateto: part and add the reminder to the parsed token array
 275         $param = trim(substr($content,7));
 276         $this->tokens[] = new search_token(TOKEN_DATETO,$param);
 277         return true;
 278     }
 279
 280     // State for handling tags:tagname,tagname constructs. Potentially emits a token.
 281     function intags($content){
 282         if (strlen($content) < 5) { // State exit or missing parameter.
 283             return true;
 284         }
 285         // Strip off the tags: part and add the reminder to the parsed token array
 286         $param = trim(substr($content,5));
 287         $this->tokens[] = new search_token(TOKEN_TAGS,$param);
 288         return true;
 289     }
 290
 291     // State for handling instance:foo constructs. Potentially emits a token.
 292     function ininstance($content){
 293         if (strlen($content) < 10) { // State exit or missing parameter.
 294             return true;
 295         }
 296         // Strip off the instance: part and add the reminder to the parsed token array
 297         $param = trim(substr($content,9));
 298         $this->tokens[] = new search_token(TOKEN_INSTANCE,$param);
 299         return true;
 300     }
 301
 302
 303     // State for handling userid:foo constructs. Potentially emits a token.
 304     function inuserid($content){
 305         if (strlen($content) < 8) { // State exit or missing parameter.
 306             return true;
 307         }
 308         // Strip off the userid: part and add the reminder to the parsed token array
 309         $param = trim(substr($content,7));
 310         $this->tokens[] = new search_token(TOKEN_USERID,$param);
 311         return true;
 312     }
 313
 314
 315     // State for handling user:foo constructs. Potentially emits a token.
 316     function inusername($content){
 317         if (strlen($content) < 6) { // State exit or missing parameter.
 318             return true;
 319         }
 320         // Strip off the user: part and add the reminder to the parsed token array
 321         $param = trim(substr($content,5));
 322         $this->tokens[] = new search_token(TOKEN_USER,$param);
 323         return true;
 324     }
 325
 326
 327     // State for handling meta:foo constructs. Potentially emits a token.
 328     function inmeta($content){
 329         if (strlen($content) < 9) { // Missing parameter.
 330             return true;
 331         }
 332         // Strip off the meta: part and add the reminder to the parsed token array.
 333         $param = trim(substr($content,8));
 334         $this->tokens[] = new search_token(TOKEN_META,$param);
 335         return true;
 336     }
 337
 338
 339     // State entered when we've seen a required string (+foo). Potentially
 340     // emits a token.
 341     function inrequired($content){
 342         if (strlen($content) < 2) { // State exit or missing parameter, don't emit.
 343             return true;
 344         }
 345         // Strip off the + sign and add the reminder to the parsed token array.
 346         $this->tokens[] = new search_token(TOKEN_EXACT,substr($content,1));
 347         return true;
 348     }
 349
 350     // State entered when we've seen an excluded string (-foo). Potentially
 351     // emits a token.
 352     function inexcluded($content){
 353         if (strlen($content) < 2) { // State exit or missing parameter.
 354             return true;
 355         }
 356         // Strip off the -sign and add the reminder to the parsed token array.
 357         $this->tokens[] = new search_token(TOKEN_NEGATE,substr($content,1));
 358         return true;
 359     }
 360
 361
 362     // State entered when we've seen a quoted string. Potentially emits a token.
 363     function inquotedstring($content){
 364         if (strlen($content) < 2) { // State exit or missing parameter.
 365             return true;
 366         }
 367         // Strip off the opening quote and add the reminder to the parsed token array.
 368         $this->tokens[] = new search_token(TOKEN_STRING,substr($content,1));
 369         return true;
 370     }
 371
 372     // State entered when we've seen an ordinary, non-quoted word. Potentially
 373     // emits a token.
 374     function plainstring($content){
 375         if (trim($content) === '') { // State exit
 376             return true;
 377         }
 378         // Add the string to the parsed token array.
 379         $this->tokens[] = new search_token(TOKEN_STRING,$content);
 380         return true;
 381     }
 382 }
 383
 384 /**
 385  * Primitive function to generate a SQL string from a parse tree
 386  * using TEXT indexes. If searches aren't suitable to use TEXT
 387  * this function calls the default search_generate_SQL() one.
 388  *
 389  * @deprecated since Moodle 2.9 MDL-48939
 390  * @todo MDL-48940 This will be deleted in Moodle 3.2
 391  * @see search_generate_SQL()
 392  */
 393 function search_generate_text_SQL($parsetree, $datafield, $metafield, $mainidfield, $useridfield,
 394                              $userfirstnamefield, $userlastnamefield, $timefield, $instancefield) {
 395     debugging('search_generate_text_SQL() is deprecated, please use search_generate_SQL() instead.', DEBUG_DEVELOPER);
 396
 397     return search_generate_SQL($parsetree, $datafield, $metafield, $mainidfield, $useridfield,
 398                                $userfirstnamefield, $userlastnamefield, $timefield, $instancefield);
 399 }
 400
 401 /**
 402  * Primitive function to generate a SQL string from a parse tree.
 403  * Parameters:
 404  *
 405  * $parsetree should be a parse tree generated by a
 406  * search_lexer/search_parser combination.
 407  * Other fields are database table names to search.
 408  *
 409  * @global object
 410  * @global object
 411  */
 412 function search_generate_SQL($parsetree, $datafield, $metafield, $mainidfield, $useridfield,
 413                              $userfirstnamefield, $userlastnamefield, $timefield, $instancefield,
 414                              $tagfields = []) {
 415     global $CFG, $DB;
 416     static $p = 0;
 417
 418     if ($DB->sql_regex_supported()) {
 419         $REGEXP    = $DB->sql_regex(true);
 420         $NOTREGEXP = $DB->sql_regex(false);
 421         $regexwordbegin = $DB->sql_regex_get_word_beginning_boundary_marker();
 422         $regexwordend = $DB->sql_regex_get_word_end_boundary_marker();
 423     }
 424
 425     $params = array();
 426
 427     $ntokens = count($parsetree);
 428     if ($ntokens == 0) {
 429         return "";
 430     }
 431
 432     $SQLString = '';
 433     $nexttagfield = 0;
 434     for ($i=0; $i<$ntokens; $i++){
 435         if ($i > 0) {// We have more than one clause, need to tack on AND
 436             $SQLString .= ' AND ';
 437         }
 438
 439         $type = $parsetree[$i]->getType();
 440         $value = $parsetree[$i]->getValue();
 441
 442     /// Under Oracle and MSSQL, transform TOKEN searches into STRING searches and trim +- chars
 443         if (!$DB->sql_regex_supported()) {
 444             $value = trim($value, '+-');
 445             if ($type == TOKEN_EXACT) {
 446                 $type = TOKEN_STRING;
 447             }
 448         }
 449
 450         $name1 = 'sq'.$p++;
 451         $name2 = 'sq'.$p++;
 452
 453         switch($type){
 454             case TOKEN_STRING:
 455                 $SQLString .= "((".$DB->sql_like($datafield, ":$name1", false).") OR (".$DB->sql_like($metafield, ":$name2", false)."))";
 456                 $params[$name1] = "%$value%";
 457                 $params[$name2] = "%$value%";
 458                 break;
 459             case TOKEN_EXACT:
 460                 $SQLString .= "(($datafield $REGEXP :$name1) OR ($metafield $REGEXP :$name2))";
 461                 $params[$name1] = $regexwordbegin.$value.$regexwordend;
 462                 $params[$name2] = $regexwordbegin.$value.$regexwordend;
 463                 break;
 464             case TOKEN_META:
 465                 if ($metafield != '') {
 466                     $SQLString .= "(".$DB->sql_like($metafield, ":$name1", false).")";
 467                     $params[$name1] = "%$value%";
 468                 }
 469                 break;
 470             case TOKEN_USER:
 471                 $SQLString .= "(($mainidfield = $useridfield) AND ((".$DB->sql_like($userfirstnamefield, ":$name1", false).") OR (".$DB->sql_like($userlastnamefield, ":$name2", false).")))";
 472                 $params[$name1] = "%$value%";
 473                 $params[$name2] = "%$value%";
 474                 break;
 475             case TOKEN_USERID:
 476                 $SQLString .= "($useridfield = :$name1)";
 477                 $params[$name1] = $value;
 478                 break;
 479             case TOKEN_INSTANCE:
 480                 $SQLString .= "($instancefield = :$name1)";
 481                 $params[$name1] = $value;
 482                 break;
 483             case TOKEN_DATETO:
 484                 $SQLString .= "($timefield <= :$name1)";
 485                 $params[$name1] = $value;
 486                 break;
 487             case TOKEN_DATEFROM:
 488                 $SQLString .= "($timefield >= :$name1)";
 489                 $params[$name1] = $value;
 490                 break;
 491             case TOKEN_TAGS:
 492                 $sqlstrings = [];
 493                 foreach (explode(',', $value) as $tag) {
 494                     $paramname = $name1 . '_' . $nexttagfield;
 495                     if (isset($tagfields[$nexttagfield])) {
 496                         $sqlstrings[]       = "($tagfields[$nexttagfield] = :$paramname)";
 497                         $params[$paramname] = $tag;
 498                     } else if (!isset($tagfields[$nexttagfield]) && !isset($stoppedprocessingtags)) {
 499                         // Show a debugging message the first time we hit this.
 500                         $stoppedprocessingtags = true;
 501                         \core\notification::add(get_string('toomanytags'), \core\notification::WARNING);
 502                     }
 503                     $nexttagfield++;
 504                 }
 505                 $SQLString .= implode(' AND ', $sqlstrings);
 506                 break;
 507             case TOKEN_NEGATE:
 508                 $SQLString .= "(NOT ((".$DB->sql_like($datafield, ":$name1", false).") OR (".$DB->sql_like($metafield, ":$name2", false).")))";
 509                 $params[$name1] = "%$value%";
 510                 $params[$name2] = "%$value%";
 511                 break;
 512             default:
 513                 return '';
 514
 515         }
 516     }
 517     return array($SQLString, $params);
 518 }