1431 lines
42 KiB
PHP
1431 lines
42 KiB
PHP
<?php namespace ProcessWire;
|
||
|
||
/**
|
||
* ProcessWire DatabaseQuerySelectFulltext
|
||
*
|
||
* A wrapper for SELECT SQL queries using FULLTEXT indexes
|
||
*
|
||
* Decorates a DatabaseQuerySelect object by providing the WHERE and
|
||
* ORDER parts for a fulltext query based on the table, field, operator
|
||
* and value you are searching.
|
||
*
|
||
* Assumes that you are providing at least the SELECT and FROM portions
|
||
* of the query.
|
||
*
|
||
* The intention behind these classes is to have a query that can safely
|
||
* be passed between methods and objects that add to it without knowledge
|
||
* of what other methods/objects have done to it. It also means being able
|
||
* to build a complex query without worrying about correct syntax placement.
|
||
*
|
||
* This file is licensed under the MIT license
|
||
* https://processwire.com/about/license/mit/
|
||
*
|
||
* ProcessWire 3.x, Copyright 2022 by Ryan Cramer
|
||
* https://processwire.com
|
||
*
|
||
* @property-read $tableField
|
||
*
|
||
*
|
||
*
|
||
*/
|
||
class DatabaseQuerySelectFulltext extends Wire {
|
||
|
||
/**
|
||
* Max length that we allow for a query
|
||
*
|
||
*/
|
||
const maxQueryValueLength = 500;
|
||
|
||
/**
|
||
* @var DatabaseQuerySelect|PageFinderDatabaseQuerySelect
|
||
*
|
||
*/
|
||
protected $query;
|
||
|
||
/**
|
||
* @var string
|
||
*
|
||
*/
|
||
protected $tableName = '';
|
||
|
||
/**
|
||
* Current field/column name
|
||
*
|
||
* @var $fieldName
|
||
*
|
||
*/
|
||
protected $fieldName = '';
|
||
|
||
/**
|
||
* All field/column names (if more than one)
|
||
*
|
||
* @var array
|
||
*
|
||
*/
|
||
protected $fieldNames = array();
|
||
|
||
/**
|
||
* @var string
|
||
*
|
||
*/
|
||
protected $operator = '';
|
||
|
||
/**
|
||
* @var string
|
||
*
|
||
*/
|
||
protected $method = '';
|
||
|
||
/**
|
||
* Is it a NOT operator?
|
||
*
|
||
* This is not used by PageFinder originating queries, which handles NOT internally.
|
||
*
|
||
* @var bool
|
||
*
|
||
*/
|
||
protected $not = false;
|
||
|
||
/**
|
||
* Cached minimum word length
|
||
*
|
||
* @var int|null
|
||
*
|
||
*/
|
||
protected $minWordLength = null;
|
||
|
||
/**
|
||
* Allow adding 'ORDER BY' to query?
|
||
*
|
||
* @var bool|null
|
||
*
|
||
*/
|
||
protected $allowOrder = null;
|
||
|
||
/**
|
||
* Allow fulltext searches to fallback to LIKE searches to match stopwords?
|
||
*
|
||
* @var bool
|
||
*
|
||
*/
|
||
protected $allowStopwords = true;
|
||
|
||
/**
|
||
* @var array
|
||
*
|
||
*/
|
||
static protected $scoreCnts = array();
|
||
|
||
/**
|
||
* Method names to operators they handle
|
||
*
|
||
* @var array
|
||
*
|
||
*/
|
||
protected $methodOperators = array(
|
||
'matchEquals' => array('=', '!=', '>', '<', '>=', '<='),
|
||
'matchPhrase' => array('*='),
|
||
'matchPhraseExpand' => array('*+='),
|
||
'matchRegular' => array('**=', '**+='),
|
||
'matchStartEnd' => array('^=', '$='),
|
||
'matchWords' => array('~=', '~+=', '~*=', '~~=', '~|=', '~|*=', '~|+='),
|
||
'matchLikeWords' => array('~%=', '~|%='),
|
||
'matchLikePhrase' => array('%='),
|
||
'matchLikeStartEnd' => array('%^=', '%$='),
|
||
'matchCommands' => array('#='),
|
||
);
|
||
|
||
/**
|
||
* Alternate operators to substitute when LIKE match is forced due to no FULLTEXT index
|
||
*
|
||
* @var array of operator to replacement operator
|
||
*
|
||
*/
|
||
protected $likeAlternateOperators = array(
|
||
'*=' => '%=',
|
||
'^=' => '%^=',
|
||
'$=' => '%$=',
|
||
'~=' => '~%=',
|
||
'~|=' => '~|%=',
|
||
);
|
||
|
||
/**
|
||
* Force use of LIKE?
|
||
*
|
||
* @var bool
|
||
*
|
||
*/
|
||
protected $forceLike = false;
|
||
|
||
/**
|
||
* Construct
|
||
*
|
||
* @param DatabaseQuerySelect|PageFinderDatabaseQuerySelect $query
|
||
*
|
||
*/
|
||
public function __construct(DatabaseQuerySelect $query) {
|
||
parent::__construct();
|
||
$query->wire($this);
|
||
$this->query = $query;
|
||
}
|
||
|
||
/**
|
||
* @param string $name
|
||
* @return mixed|string
|
||
*
|
||
*/
|
||
public function __get($name) {
|
||
if($name === 'tableField') return $this->tableField();
|
||
return parent::__get($name);
|
||
}
|
||
|
||
/**
|
||
* Get the query that was provided to the constructor
|
||
*
|
||
* @return DatabaseQuerySelect
|
||
*
|
||
*/
|
||
public function getQuery() {
|
||
return $this->query;
|
||
}
|
||
|
||
/**
|
||
* Get 'tableName.fieldName' string
|
||
*
|
||
* @return string
|
||
*
|
||
*/
|
||
protected function tableField() {
|
||
$fieldName = $this->fieldName;
|
||
if(!$fieldName) $fieldName = 'data';
|
||
return "$this->tableName.$fieldName";
|
||
}
|
||
|
||
/**
|
||
* Get or set whether or not 'ORDER BY' statements are allowed to be added
|
||
*
|
||
* @param null|bool $allow Specify bool to set or omit to get
|
||
* @return bool|null Returns bool when known or null when not yet known
|
||
* @since 3.0.162
|
||
*
|
||
*/
|
||
public function allowOrder($allow = null) {
|
||
if($allow !== null) $this->allowOrder = $allow ? true : false;
|
||
return $this->allowOrder;
|
||
}
|
||
|
||
/**
|
||
* Get or set whether fulltext searches can fallback to LIKE searches to match stopwords
|
||
*
|
||
* @param null|bool $allow Specify bool to set or omit to get
|
||
* @return bool
|
||
* @since 3.0.162
|
||
*
|
||
*/
|
||
public function allowStopwords($allow = null) {
|
||
if($allow !== null) $this->allowStopwords = $allow ? true : false;
|
||
return $this->allowStopwords;
|
||
}
|
||
|
||
/**
|
||
* @return string
|
||
*
|
||
*/
|
||
protected function matchType() {
|
||
return "\n " . ($this->not ? 'NOT MATCH' : 'MATCH');
|
||
}
|
||
|
||
/**
|
||
* Escape string for use in a MySQL LIKE
|
||
*
|
||
* When applicable, $database->escapeStr() should be applied before this.
|
||
*
|
||
* @param string $str
|
||
* @return string
|
||
*
|
||
*/
|
||
protected function escapeLike($str) {
|
||
return str_replace(array('%', '_'), array('\\%', '\\_'), $str);
|
||
}
|
||
|
||
/**
|
||
* Additional escape for use in a MySQL AGAINST
|
||
*
|
||
* When applicable, $database->escapeStr() must also be applied (before or after).
|
||
*
|
||
* @param string $str
|
||
* @return string
|
||
*
|
||
*/
|
||
protected function escapeAgainst($str) {
|
||
$str = str_replace(array('@', '+', '-', '*', '~', '<', '>', '(', ')', ':', '"', '&', '|', '=', '.'), ' ', $str);
|
||
while(strpos($str, ' ')) $str = str_replace(' ', ' ', $str);
|
||
return $str;
|
||
}
|
||
|
||
/**
|
||
* @param string $value
|
||
* @return string
|
||
*
|
||
*/
|
||
protected function value($value) {
|
||
$maxLength = self::maxQueryValueLength;
|
||
$value = trim($value);
|
||
if(strlen($value) < $maxLength && strpos($value, "\n") === false && strpos($value, "\r") === false) return $value;
|
||
$value = $this->sanitizer->trunc($value, $maxLength);
|
||
return $value;
|
||
}
|
||
|
||
/**
|
||
* Update the query (provided to the constructor) to match the given arguments
|
||
*
|
||
* @param string $tableName
|
||
* @param string $fieldName
|
||
* @param string $operator
|
||
* @param string|int|array $value Value to match. Array value support added 3.0.141 (not used by PageFinder)
|
||
* @return $this
|
||
* @throws WireException If given $operator argument is not implemented here
|
||
*
|
||
*/
|
||
public function match($tableName, $fieldName, $operator, $value) {
|
||
|
||
$this->tableName = $this->database->escapeTable($tableName);
|
||
$allowOrder = true;
|
||
|
||
if(strpos($operator, '!') === 0 && $operator !== '!=') {
|
||
$this->not = true;
|
||
$operator = ltrim($operator, '!');
|
||
} else {
|
||
// disable orderby statements when calling object will be negating whatever we do
|
||
$selector = $this->query->selector;
|
||
if($selector instanceof Selector && $selector->not) $allowOrder = false;
|
||
}
|
||
|
||
// if allowOrder has not been specifically set, then set value now
|
||
if($this->allowOrder === null) $this->allowOrder = $allowOrder;
|
||
|
||
if($this->forceLike && isset($this->likeAlternateOperators[$operator])) {
|
||
$operator = $this->likeAlternateOperators[$operator];
|
||
}
|
||
|
||
$this->operator = $operator;
|
||
|
||
foreach($this->methodOperators as $name => $operators) {
|
||
if(in_array($operator, $operators)) $this->method = $name;
|
||
if($this->method) break;
|
||
}
|
||
|
||
if(!$this->method) {
|
||
throw new WireException("Unimplemented operator in $this::match()");
|
||
}
|
||
|
||
if(is_array($fieldName) && count($fieldName) < 2) {
|
||
$fieldName = reset($fieldName);
|
||
}
|
||
|
||
if(is_array($fieldName)) {
|
||
$this->matchArrayFieldName($fieldName, $value);
|
||
} else {
|
||
$this->matchFieldName($fieldName, $value);
|
||
}
|
||
|
||
return $this;
|
||
}
|
||
|
||
protected function matchFieldName($fieldName, $value) {
|
||
$this->fieldName = $this->database->escapeCol($fieldName);
|
||
if(is_array($value)) {
|
||
$this->matchArrayValue($value);
|
||
} else {
|
||
$value = $this->value($value);
|
||
$method = $this->method;
|
||
if(strlen($value)) {
|
||
$this->$method($value);
|
||
} else {
|
||
// empty value
|
||
if($this->not || $this->operator === '!=') {
|
||
$this->matchIsNotEmpty();
|
||
} else {
|
||
$this->matchIsEmpty();
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
/**
|
||
* Match when given $fieldName is an array
|
||
*
|
||
* @param array $fieldNames
|
||
* @param mixed $value
|
||
* @since 3.0.169
|
||
*
|
||
*/
|
||
protected function matchArrayFieldName(array $fieldNames, $value) {
|
||
$query = $this->query;
|
||
$query->bindOption('global', true);
|
||
|
||
$this->query = new DatabaseQuerySelect();
|
||
$this->wire($this->query);
|
||
$this->query->bindOption(true, $query->bindOption(true));
|
||
|
||
foreach($fieldNames as $fieldName) {
|
||
$this->matchFieldName($fieldName, $value);
|
||
}
|
||
|
||
$query->where('((' . implode(') OR (', $this->query->where) . '))');
|
||
$this->query->copyBindValuesTo($query);
|
||
$this->query = $query;
|
||
}
|
||
|
||
/**
|
||
* Match when given $value is an array
|
||
*
|
||
* Note: PageFinder uses its own array-to-value conversion, so this case applies only to other usages outside PageFinder,
|
||
* such as FieldtypeMulti::getLoadQueryWhere()
|
||
*
|
||
* @param array $value
|
||
* @since 3.0.141
|
||
* @throws WireException
|
||
*
|
||
*/
|
||
protected function matchArrayValue(array $value) {
|
||
|
||
/*
|
||
if(strpos($this->operator, '~') !== false) {
|
||
throw new WireException("Operator $this->operator is not supported for $this->fieldName with OR value condition");
|
||
}
|
||
*/
|
||
|
||
// convert *= operator to %= to make the query possible (avoiding matchContains method)
|
||
// if($this->operator === '*=') $this->operator = '%=';
|
||
|
||
$query = $this->query;
|
||
$query->bindOption('global', true);
|
||
$this->query = new DatabaseQuerySelect();
|
||
$this->wire($this->query);
|
||
$this->query->bindOption(true, $query->bindOption(true));
|
||
$method = $this->method;
|
||
|
||
foreach($value as $v) {
|
||
$v = $this->value("$v");
|
||
if(strlen($v)) $this->$method($v);
|
||
}
|
||
|
||
// @todo need to get anything else from substitute query?
|
||
$query->where('((' . implode(') OR (', $this->query->where) . '))');
|
||
$this->query->copyBindValuesTo($query);
|
||
$this->query = $query;
|
||
}
|
||
|
||
/**
|
||
* Match equals, not equals, less, greater, etc.
|
||
*
|
||
* @param string $value
|
||
*
|
||
*/
|
||
protected function matchEquals($value) {
|
||
$op = $this->wire()->database->escapeOperator($this->operator, WireDatabasePDO::operatorTypeComparison);
|
||
$this->query->where("$this->tableField$op?", $value);
|
||
}
|
||
|
||
/**
|
||
* Match is an empty empty string, null or not present
|
||
*
|
||
*/
|
||
protected function matchIsEmpty() {
|
||
$this->query->where("($this->tableField='' OR $this->tableField IS NULL)");
|
||
}
|
||
|
||
/**
|
||
* Match is present, not null and not an empty string
|
||
*
|
||
*/
|
||
protected function matchIsNotEmpty() {
|
||
$this->query->where("($this->tableField IS NOT NULL AND $this->tableField!='')");
|
||
}
|
||
|
||
/**
|
||
* Match LIKE phrase
|
||
*
|
||
* @param string $value
|
||
*
|
||
*/
|
||
protected function matchLikePhrase($value) {
|
||
$likeType = $this->not ? 'NOT LIKE' : 'LIKE';
|
||
$this->query->where("$this->tableField $likeType ?", '%' . $this->escapeLike($value) . '%');
|
||
}
|
||
|
||
/**
|
||
* Match starts-with or ends-with using only LIKE (no match/against index)
|
||
*
|
||
* Does not ignore whitespace, closing tags or punctutation at start/end the way that the
|
||
* matchStartEnd() method does, so this can be used to perform more literal start/end matches.
|
||
*
|
||
* @param string $value
|
||
*
|
||
*/
|
||
protected function matchLikeStartEnd($value) {
|
||
$likeType = $this->not ? 'NOT LIKE' : 'LIKE';
|
||
if(strpos($this->operator, '^') !== false) {
|
||
$this->query->where("$this->tableField $likeType ?", $this->escapeLike($value) . '%');
|
||
} else {
|
||
$this->query->where("$this->tableField $likeType ?", '%' . $this->escapeLike($value));
|
||
}
|
||
}
|
||
|
||
/**
|
||
* Match words (plural) LIKE, given words can appear in full or in any part of a word
|
||
*
|
||
* @param string $value
|
||
* @since 3.0.160
|
||
*
|
||
*/
|
||
protected function matchLikeWords($value) {
|
||
|
||
// ~%= Match all words LIKE
|
||
// ~|%= Match any words LIKE
|
||
|
||
$likeType = $this->not ? 'NOT LIKE' : 'LIKE';
|
||
$any = strpos($this->operator, '|') !== false;
|
||
$words = $this->words($value);
|
||
$binds = array(); // used only in $any mode
|
||
$wheres = array(); // used only in $any mode
|
||
|
||
foreach($words as $word) {
|
||
$word = $this->escapeLike($word);
|
||
if(!strlen($word)) continue;
|
||
if($any) {
|
||
$bindKey = $this->query->getUniqueBindKey();
|
||
$wheres[] = "($this->tableField $likeType $bindKey)";
|
||
$binds[$bindKey] = "%$word%";
|
||
} else {
|
||
$this->query->where("($this->tableField $likeType ?)", "%$word%");
|
||
}
|
||
}
|
||
|
||
if($any && count($words)) {
|
||
$this->query->where('(' . implode(' OR ', $wheres) . ')');
|
||
$this->query->bindValues($binds);
|
||
}
|
||
}
|
||
|
||
/**
|
||
* Match contains words (full, any or partial)
|
||
*
|
||
* @param string $value
|
||
* @since 3.0.160
|
||
*
|
||
*/
|
||
protected function matchWords($value) {
|
||
|
||
// ~= Contains all full words
|
||
// !~= Does not contain all full words
|
||
// ~+= Contains all full words + expand
|
||
// ~*= Contains all partial words
|
||
// ~~= Contains all words live (all full words + partial last word)
|
||
// ~|= Contains any full words
|
||
// ~|*= Contains any partial words
|
||
// ~|+= Contains any words + expand
|
||
|
||
$tableField = $this->tableField();
|
||
$operator = $this->operator;
|
||
$required = strpos($operator, '|') === false;
|
||
$partial = strpos($operator, '*') !== false;
|
||
$partialLast = $operator === '~~=';
|
||
$expand = strpos($operator, '+') !== false;
|
||
$matchType = $this->matchType();
|
||
$scoreField = $this->getScoreFieldName();
|
||
$matchAgainst = '';
|
||
$wheres = array();
|
||
|
||
$data = $this->getBooleanModeWords($value, array(
|
||
'required' => $required,
|
||
'partial' => $partial,
|
||
'partialLast' => $partialLast,
|
||
'partialLess' => ($partial || $expand),
|
||
'alternates' => $expand,
|
||
));
|
||
|
||
if(empty($data['value'])) {
|
||
// query contains no indexable words: force non-match
|
||
//$this->query->where('1>2');
|
||
//return;
|
||
// TEST OUT: title|summary~|+=beer
|
||
}
|
||
|
||
if($expand) {
|
||
if(!empty($data['booleanValue']) && $this->allowOrder) {
|
||
// ensure full matches are above expanded matches
|
||
$preScoreField = $this->getScoreFieldName();
|
||
$bindKey = $this->query->bindValueGetKey($data['booleanValue']);
|
||
$this->query->select("$matchType($tableField) AGAINST($bindKey IN BOOLEAN MODE) + 111.1 AS $preScoreField");
|
||
$this->query->orderby("$preScoreField DESC");
|
||
}
|
||
if(!empty($data['matchValue'])) {
|
||
$bindValue = trim($data['matchValue']);
|
||
$bindKey = $this->query->bindValueGetKey($this->escapeAgainst($bindValue));
|
||
$matchAgainst = "$matchType($tableField) AGAINST($bindKey WITH QUERY EXPANSION)";
|
||
}
|
||
|
||
} else if(!empty($data['booleanValue'])) {
|
||
$bindKey = $this->query->bindValueGetKey($data['booleanValue']);
|
||
$matchAgainst = "$matchType($tableField) AGAINST($bindKey IN BOOLEAN MODE)";
|
||
}
|
||
|
||
if($matchAgainst) {
|
||
$wheres[] = $matchAgainst;
|
||
// $this->query->where($matchAgainst);
|
||
if($this->allowOrder) {
|
||
$this->query->select("$matchAgainst AS $scoreField");
|
||
$this->query->orderby("$scoreField DESC");
|
||
}
|
||
} else if(!$this->allowStopwords) {
|
||
// no match possible
|
||
// $this->query->where('1>2');
|
||
$wheres[] = '1>2';
|
||
}
|
||
|
||
if(!empty($data['likeWords'])) {
|
||
// stopwords or words that were too short to use fulltext index
|
||
$likeType = $this->not ? 'NOT RLIKE' : 'RLIKE';
|
||
$orLikes = array();
|
||
$andLikes = array();
|
||
foreach($data['likeWords'] as $word) {
|
||
$isStopword = isset($data['stopWords'][$word]);
|
||
if($isStopword && !$this->allowStopwords) continue;
|
||
if(!strlen($word)) continue;
|
||
if($partial || ($partialLast && $word === $data['lastWord'])) {
|
||
// just match partial word from beginning
|
||
$likeValue = $this->rlikeValue($word);
|
||
} else {
|
||
// match to word-end
|
||
$likeValue = $this->rlikeValue($word, array('partial' => false));
|
||
}
|
||
$bindKey = $this->query->bindValueGetKey($likeValue);
|
||
$likeWhere = "($tableField $likeType $bindKey)";
|
||
if(!$required || ($isStopword && $expand)) {
|
||
$orLikes[] = $likeWhere;
|
||
} else {
|
||
$andLikes[] = $likeWhere;
|
||
}
|
||
}
|
||
$whereLike = '';
|
||
if(count($orLikes)) {
|
||
$whereLike .= '(' . implode(' OR ', $orLikes) . ')';
|
||
if(count($andLikes)) $whereLike .= $required ? ' AND ' : ' OR ';
|
||
}
|
||
if(count($andLikes)) {
|
||
$whereLike .= implode(' AND ', $andLikes);
|
||
}
|
||
if($whereLike) $wheres[] = $whereLike;
|
||
}
|
||
|
||
if(count($wheres)) {
|
||
$and = $required ? ' AND ' : ' OR ';
|
||
$this->query->where('(' . implode($and, $wheres) . ')');
|
||
}
|
||
}
|
||
|
||
/**
|
||
* Match contains entire phrase/string (*=)
|
||
*
|
||
* @param string $value
|
||
*
|
||
*/
|
||
protected function matchPhrase($value) {
|
||
|
||
$tableField = $this->tableField();
|
||
$likeValue = '';
|
||
$useLike = false;
|
||
$words = $this->words($value);
|
||
$lastWord = count($words) > 1 ? array_pop($words) : '';
|
||
$badWords = array();
|
||
$goodWords = array();
|
||
|
||
foreach($words as $word) {
|
||
if($this->isIndexableWord($word)) {
|
||
$goodWords[$word] = $word;
|
||
} else {
|
||
$badWords[$word] = $word;
|
||
}
|
||
}
|
||
|
||
if(count($badWords)) $useLike = true;
|
||
|
||
if(!count($goodWords)) {
|
||
// 0 good words to search: do not use match/against
|
||
$againstValue = '';
|
||
} else if(count($goodWords) === 1) {
|
||
// 1 word left: non-quoted word only, partial match if no last word
|
||
$word = reset($goodWords);
|
||
$againstValue = '+' . $this->escapeAgainst($word);
|
||
if($lastWord === '') $againstValue .= '*';
|
||
} else if(!count($badWords)) {
|
||
// no bad words, okay to match all in phrase format
|
||
$againstValue = '+"' . $this->escapeAgainst(implode(' ', $words)) . '"';
|
||
} else {
|
||
// combination of good and bad words, match the good words in any order
|
||
// and let the LIKE match them as a phrase
|
||
$againstValue = $this->escapeAgainst(implode(' ', $goodWords));
|
||
$useLike = true;
|
||
}
|
||
|
||
if($useLike || $lastWord !== '' || !strlen($againstValue)) {
|
||
// match entire phrase with LIKE as secondary qualifier that includes last word
|
||
// so that we can perform a partial match on the last word only. This is necessary
|
||
// because we can’t use partial match qualifiers in or out of quoted phrases.
|
||
$lastWord = strlen($lastWord) ? $this->escapeAgainst($lastWord) : '';
|
||
if(strlen($lastWord) && !$this->isStopword($lastWord)) {
|
||
// if word is indexable let it contribute to final score
|
||
// expand the againstValue to include the last word as a required partial match
|
||
$againstValue = trim("$againstValue +$lastWord*");
|
||
}
|
||
$likeValue = $this->rlikeValue($value);
|
||
}
|
||
|
||
if(strlen($againstValue)) {
|
||
// use MATCH/AGAINST
|
||
$bindKey = $this->query->bindValueGetKey($againstValue);
|
||
$matchType = $this->matchType();
|
||
$matchAgainst = "$matchType($tableField) AGAINST($bindKey IN BOOLEAN MODE)";
|
||
$this->query->where($matchAgainst);
|
||
|
||
if($this->allowOrder) {
|
||
$scoreField = $this->getScoreFieldName();
|
||
$this->query->select("$matchAgainst AS $scoreField");
|
||
$this->query->orderby("$scoreField DESC");
|
||
}
|
||
}
|
||
|
||
if(strlen($likeValue)) {
|
||
// LIKE is used as a secondary qualifier to MATCH/AGAINST so that it is
|
||
// performed only on rows already identified from FULLTEXT index, unless
|
||
// no MATCH/AGAINST could be created due to stopwords or too-short words
|
||
$likeType = $this->not ? 'NOT RLIKE' : 'RLIKE';
|
||
$this->query->where("($tableField $likeType ?)", $likeValue);
|
||
}
|
||
}
|
||
|
||
/**
|
||
* Match phrase with query expansion (*+=)
|
||
*
|
||
* @param string $value
|
||
*
|
||
*/
|
||
protected function matchPhraseExpand($value) {
|
||
|
||
$tableField = $this->tableField();
|
||
$matchType = $this->matchType();
|
||
$words = $this->words($value, array('indexable' => true));
|
||
$wordsAlternates = array();
|
||
|
||
$phraseWords = $this->words($value); // including non-indexable
|
||
$lastPhraseWord = array_pop($phraseWords);
|
||
$scoreField = $this->getScoreFieldName();
|
||
$againstValues = array();
|
||
|
||
// BOOLEAN PHRASE: full phrase matches come before expanded matches
|
||
if(count($phraseWords)) {
|
||
$phrases = array();
|
||
$phrase = array();
|
||
foreach($phraseWords as $word) {
|
||
if($this->isIndexableWord($word)) {
|
||
$phrase[] = $word;
|
||
} else {
|
||
if(count($phrase)) {
|
||
$phrases[] = $phrase;
|
||
$phrase = array();
|
||
}
|
||
$againstValues[] = $this->escapeAgainst($word) . '*';
|
||
}
|
||
}
|
||
if(count($phrase)) $phrases[] = $phrase;
|
||
if(count($phrases)) {
|
||
foreach($phrases as $phrase) {
|
||
$phraseStr = $this->escapeAgainst(implode(' ', $phrase));
|
||
if(count($phrase) > 1) $phraseStr = '"' . $phraseStr . '"';
|
||
$againstValues[] = "+$phraseStr";
|
||
}
|
||
}
|
||
}
|
||
|
||
$againstValues[] = ($this->isIndexableWord($lastPhraseWord) ? '+' : '') . $this->escapeAgainst($lastPhraseWord) . '*';
|
||
$bindKey = $this->query->bindValueGetKey(implode(' ', $againstValues));
|
||
$matchAgainst = "$matchType($tableField) AGAINST($bindKey IN BOOLEAN MODE)";
|
||
|
||
if($this->allowOrder) {
|
||
$this->query->select("$matchAgainst + 333.3 AS $scoreField");
|
||
$this->query->orderby("$scoreField DESC");
|
||
}
|
||
|
||
if(!count($words)) {
|
||
// no words to work with for query expansion (not likely, unless stopwords or too-short)
|
||
$this->query->where($matchAgainst);
|
||
return;
|
||
}
|
||
|
||
// BOOLEAN WEIGHTED WORDS: word matches above query expansion matches
|
||
$againstValue = '';
|
||
$scoreField = $this->getScoreFieldName();
|
||
foreach($words as $word) {
|
||
$wordAlternates = array();
|
||
foreach($this->getWordAlternates($word) as $w) {
|
||
if($w === $word || !$this->isIndexableWord($w)) continue;
|
||
$wordAlternates[$w] = $w; // alternates for just this word
|
||
$wordsAlternates[$w] = $w; // alternates for all words
|
||
}
|
||
$word = $this->escapeAgainst($word);
|
||
// full word match carries more weight than partial or alternate word match,
|
||
// but at least one must be there in order to have a good score
|
||
$againstValue .= "+(";
|
||
$againstValue .= ">$word $word*";
|
||
if(count($wordAlternates)) {
|
||
$againstValue .= ' ' . $this->escapeAgainst(implode(' ', $wordAlternates));
|
||
}
|
||
$wordRoot = $this->getWordRoot($word);
|
||
if($wordRoot && $wordRoot !== $word) {
|
||
$againstValue .= ' ' . $this->escapeAgainst($wordRoot) . '*';
|
||
}
|
||
$againstValue .= ") ";
|
||
}
|
||
|
||
if($this->allowOrder && strlen($againstValue)) {
|
||
$bindKey = $this->query->bindValueGetKey(trim($againstValue));
|
||
$this->query->select("$matchType($tableField) AGAINST($bindKey IN BOOLEAN MODE) + 222.2 AS $scoreField");
|
||
$this->query->orderby("$scoreField DESC");
|
||
}
|
||
|
||
// QUERY EXPANSION: regular match/against words with query expansion
|
||
$words = array_unique(array_merge($words, $wordsAlternates));
|
||
$againstValue = $this->escapeAgainst(implode(' ', $words));
|
||
$bindKey = $this->query->bindValueGetKey($againstValue);
|
||
$matchAgainst = "$matchType($tableField) AGAINST($bindKey WITH QUERY EXPANSION)";
|
||
$this->query->where($matchAgainst);
|
||
|
||
$scoreField = $this->getScoreFieldName();
|
||
$this->query->select("$matchAgainst AS $scoreField");
|
||
|
||
if($this->allowOrder) {
|
||
$this->query->orderby("$scoreField DESC");
|
||
}
|
||
}
|
||
|
||
/**
|
||
* Perform a regular scored MATCH/AGAINST query (non-boolean)
|
||
*
|
||
* @param string $value
|
||
*
|
||
*/
|
||
protected function matchRegular($value) {
|
||
|
||
// **= Contains match
|
||
// **+= Contains match + expand
|
||
|
||
$tableField = $this->tableField();
|
||
$expand = strpos($this->operator, '+') !== false;
|
||
$matchType = $this->matchType();
|
||
|
||
if($expand && $this->allowOrder) {
|
||
// boolean mode query for sorting purposes
|
||
$scoreField = $this->getScoreFieldName();
|
||
$data = $this->getBooleanModeWords($value, array(
|
||
'partialLess' => true,
|
||
'required' => false,
|
||
'alternates' => true,
|
||
));
|
||
if(!empty($data['booleanValue'])) {
|
||
$againstValue = $data['booleanValue'];
|
||
$bindKey = $this->query->bindValueGetKey($againstValue);
|
||
$matchAgainst = "$matchType($tableField) AGAINST($bindKey IN BOOLEAN MODE)";
|
||
$this->query->select("$matchAgainst + 111.1 AS $scoreField");
|
||
$this->query->orderby("$scoreField DESC");
|
||
}
|
||
}
|
||
|
||
// standard MATCH/AGAINST with optional query expansion
|
||
$scoreField = $this->getScoreFieldName();
|
||
$words = $this->words($value, array('indexable' => true, 'alternates' => $expand));
|
||
$againstValue = $this->escapeAgainst(implode(' ', $words));
|
||
|
||
if(!count($words) || !strlen(trim($againstValue))) {
|
||
// query contains no indexable words: force non-match
|
||
if(strlen($value)) $this->query->where('1>2');
|
||
return;
|
||
}
|
||
|
||
$bindKey = $this->query->bindValueGetKey($againstValue);
|
||
$againstType = $expand ? 'WITH QUERY EXPANSION' : '';
|
||
$where = "$matchType($tableField) AGAINST($bindKey $againstType)";
|
||
$this->query->where($where);
|
||
if($this->allowOrder) {
|
||
$this->query->select("$where AS $scoreField");
|
||
$this->query->orderby("$scoreField DESC");
|
||
}
|
||
}
|
||
|
||
/**
|
||
* Match phrase at start or end of field value (also uses fulltext index when possible)
|
||
*
|
||
* Ignores whitespace, punctuation and opening/closing tags, enabling it to match
|
||
* start/end words or phrases surrounded by non-word characters.
|
||
*
|
||
* @param $value
|
||
*
|
||
*/
|
||
protected function matchStartEnd($value) {
|
||
|
||
// ^= Starts with
|
||
// $= Ends with
|
||
|
||
$tableField = $this->tableField();
|
||
$matchStart = strpos($this->operator, '^') !== false;
|
||
$againstValue = '';
|
||
|
||
|
||
$words = $this->words($value, array('indexable' => true));
|
||
if(count($words)) {
|
||
if($matchStart) {
|
||
$lastWord = $this->escapeAgainst(array_pop($words));
|
||
$againstValue = count($words) ? '+' . $this->escapeAgainst(implode(' +', $words)) : '';
|
||
$againstValue = trim("$againstValue +$lastWord*"); // 'partial*' match last word
|
||
} else {
|
||
array_shift($words); // skip first word since '*partial' match not possible with fulltext
|
||
$againstValue = count($words) ? '+' . $this->escapeAgainst(implode(' +', $words)) : '';
|
||
}
|
||
}
|
||
|
||
if(strlen($againstValue)) {
|
||
// use MATCH/AGAINST to pre-filter before RLIKE when possible
|
||
$bindKey = $this->query->bindValueGetKey($againstValue);
|
||
$matchType = $this->matchType();
|
||
$matchAgainst = "$matchType($tableField) AGAINST($bindKey IN BOOLEAN MODE)";
|
||
$scoreField = $this->getScoreFieldName();
|
||
$this->query->where($matchAgainst);
|
||
if($this->allowOrder) {
|
||
$this->query->select("$matchAgainst AS $scoreField");
|
||
$this->query->orderby("$scoreField DESC");
|
||
}
|
||
}
|
||
|
||
$likeType = $this->not ? 'NOT RLIKE' : 'RLIKE';
|
||
|
||
if($matchStart) {
|
||
// starts with phrase, [optional non-visible html or whitespace] plus query text
|
||
$likeValue = $this->rlikeValue($value, array('start' => true));
|
||
} else {
|
||
// ends with phrase, [optional punctuation and non-visible HTML/whitespace]
|
||
$likeValue = $this->rlikeValue($value, array('end' => true));
|
||
}
|
||
|
||
$this->query->where("($tableField $likeType ?)", $likeValue);
|
||
}
|
||
|
||
/**
|
||
* Match text using boolean mode commands (Advanced search)
|
||
*
|
||
* @param string $text
|
||
* @since 3.0.160
|
||
*
|
||
*/
|
||
protected function matchCommands($text) {
|
||
$tableField = $this->tableField();
|
||
$scoreField = $this->getScoreFieldName();
|
||
$against = $this->getBooleanModeCommands($text);
|
||
$bindKey = $this->query->bindValueGetKey($against);
|
||
$matchType = $this->matchType();
|
||
$matchAgainst = "$matchType($tableField) AGAINST($bindKey IN BOOLEAN MODE) ";
|
||
$this->query->where($matchAgainst);
|
||
if($this->allowOrder) {
|
||
$select = "$matchAgainst AS $scoreField ";
|
||
$this->query->select($select);
|
||
$this->query->orderby("$scoreField DESC");
|
||
}
|
||
}
|
||
|
||
/**
|
||
* Get verbose data array of words identified and prepared for boolean mode
|
||
*
|
||
* @param string $value
|
||
* @param array $options
|
||
* - `required` (bool): Are given words required in the query? (default=true)
|
||
* - `partial` (bool): Is it okay to match a partial value? i.e. can "will" match "willy" (default=false)
|
||
* - `partialLast` (bool): Use partial only for last word? (default=null, auto-detect)
|
||
* - `partialLess` (bool): Weight partial match words less than full word match? (default=false)
|
||
* - `phrase` (bool): Is entire $value a full phrase to match? (default=auto-detect)
|
||
* - `useStopwords` (bool): Allow inclusion of stopwords? (default=null, auto-detect)
|
||
* - `alternates` (bool): Get word alternates? (default=null, auto-detect)
|
||
* @return array Value provided to the function with boolean operators added, or verbose array.
|
||
*
|
||
*/
|
||
protected function getBooleanModeWords($value, array $options = array()) {
|
||
|
||
$expand = strpos($this->operator, '+') !== false;
|
||
|
||
$defaults = array(
|
||
'required' => true,
|
||
'partial' => false,
|
||
'partialLast' => ($this->operator === '~~=' || $this->operator === '^='),
|
||
'partialLess' => false,
|
||
'useStopwords' => null,
|
||
'useShortwords' => null,
|
||
'alternates' => $expand,
|
||
);
|
||
|
||
$options = array_merge($defaults, $options);
|
||
$minWordLength = (int) $this->database->getVariable('ft_min_word_len');
|
||
$originalValue = $value;
|
||
$value = $this->escapeAgainst($value);
|
||
$booleanValues = array();
|
||
$partial = $options['partial'] ? '*' : '';
|
||
$required = $options['required'] ? '+' : '';
|
||
$useStopwords = is_bool($options['useStopwords']) ? $options['useStopwords'] : $partial === '*';
|
||
$useShortwords = is_bool($options['useShortwords']) ? $options['useShortwords'] : $partial === '*';
|
||
$lastWord = null;
|
||
$goodWords = array();
|
||
$stopWords = array();
|
||
$shortWords = array();
|
||
$likeWords = array();
|
||
$altWords = array();
|
||
$joinWords = array();
|
||
$joiners = array('->', '-', '.', ':');
|
||
|
||
// get all words
|
||
$allWords = $this->words($value);
|
||
|
||
foreach(explode(' ', $originalValue) as $word) {
|
||
foreach($joiners as $joiner) {
|
||
if(strpos($word, $joiner)) {
|
||
$joinWords[$word] = $word;
|
||
$likeWords[$word] = $word;
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
|
||
if($options['partialLast']) {
|
||
// treat last word separately (partial last word for live or starts-with searches)
|
||
// only last word is partial
|
||
$lastWord = end($allWords);
|
||
$partial = '';
|
||
}
|
||
|
||
// iterate through all words to build boolean query values
|
||
foreach($allWords as $word) {
|
||
|
||
$length = strlen($word);
|
||
if(!$length || isset($booleanValues[$word])) continue;
|
||
|
||
if($this->isStopword($word)) {
|
||
// handle stop-word
|
||
$stopWords[$word] = $word;
|
||
if($useStopwords && $partial) $booleanValues[$word] = "<$word*";
|
||
if($required) $likeWords[$word] = $word;
|
||
continue; // do nothing further with stopwords
|
||
|
||
} else if($length < $minWordLength) {
|
||
// handle too-short word
|
||
$shortWords[$word] = $word;
|
||
if($useShortwords && $partial) $booleanValues[$word] = "$word*";
|
||
if($required) $likeWords[$word] = $word;
|
||
continue; // do nothing further with short words
|
||
|
||
} else if($options['partialLess']) {
|
||
// handle regular word and match full word (more weight), or partial word (less weight)
|
||
$booleanValues[$word] = $required ? "+(>$word $word*)" : "$word*";
|
||
$goodWords[$word] = $word;
|
||
|
||
} else {
|
||
// handle regular word
|
||
$booleanValues[$word] = $required . $word . $partial;
|
||
$goodWords[$word] = $word;
|
||
}
|
||
|
||
if($options['alternates']) {
|
||
$booleanValue = $booleanValues[$word];
|
||
$alternates = $this->getBooleanModeAlternateWords($word, $booleanValue, $minWordLength, $options);
|
||
if($booleanValue !== $booleanValues[$word]) {
|
||
$booleanValues[$word] = $booleanValue;
|
||
$altWords = array_merge($altWords, $alternates);
|
||
$allWords = array_merge($allWords, $altWords);
|
||
}
|
||
}
|
||
}
|
||
|
||
if(strlen("$lastWord")) {
|
||
// only last word allowed to be a partial match word
|
||
$lastRequired = isset($stopWords[$lastWord]) || isset($shortWords[$lastWord]) ? '' : $required;
|
||
$booleanValues[$lastWord] = $lastRequired . $lastWord . '*';
|
||
}
|
||
|
||
if($useStopwords && !$required && count($stopWords) && count($goodWords)) {
|
||
// increase weight of non-stopwords
|
||
foreach($goodWords as $word) {
|
||
$booleanWord = $booleanValues[$word];
|
||
if(!in_array($booleanWord[0], array('(', '+', '<', '>', '-', '~', '"'))) {
|
||
$booleanValues[$word] = ">$booleanWord";
|
||
}
|
||
}
|
||
}
|
||
|
||
$badWords = array_merge($stopWords, $shortWords);
|
||
|
||
if(count($stopWords)) {
|
||
$numOkayWords = count($goodWords) + count($shortWords);
|
||
foreach($stopWords as $word) {
|
||
$likeWords[$word] = $word;
|
||
if($numOkayWords && isset($booleanValues[$word])) {
|
||
// make word non-required in boolean query
|
||
$booleanValues[$word] = ltrim($booleanValues[$word], '+');
|
||
} else {
|
||
// boolean query requires at least one good word to work,
|
||
// so if there aren't any, remove this word from boolean query
|
||
unset($booleanValues[$word]);
|
||
}
|
||
}
|
||
}
|
||
|
||
return array(
|
||
'value' => trim(implode(' ', $allWords)),
|
||
'originalValue' => $originalValue,
|
||
'matchValue' => trim(implode(' ', $goodWords) . ' ' . implode(' ', $altWords)), // indexable words only
|
||
'booleanValue' => trim(implode(' ', $booleanValues)),
|
||
'booleanWords' => $booleanValues,
|
||
'likeWords' => $likeWords,
|
||
'allWords' => $allWords,
|
||
'goodWords' => $goodWords,
|
||
'badWords' => $badWords,
|
||
'stopWords' => $stopWords,
|
||
'shortWords' => $shortWords,
|
||
'altWords' => $altWords,
|
||
'joinWords' => $joinWords,
|
||
'lastWord' => $lastWord,
|
||
'minWordLength' => $minWordLength,
|
||
);
|
||
}
|
||
|
||
/**
|
||
* Helper for getBooleanModeWords to handle population of alternate words in boolean value
|
||
*
|
||
* @param string $word Word to find alternates for
|
||
* @param string &$booleanValue Existing boolean value which will be updated
|
||
* @param int $minWordLength
|
||
* @param array $options
|
||
* @return array
|
||
* @since 3.0.162
|
||
*
|
||
*/
|
||
protected function getBooleanModeAlternateWords($word, &$booleanValue, $minWordLength, array $options) {
|
||
|
||
$required = strpos($booleanValue, '+') === 0 ? '+' : '';
|
||
$alternateWords = $this->getWordAlternates($word);
|
||
$rootWord = $this->getWordRoot($word);
|
||
|
||
if($rootWord) {
|
||
if(!in_array($rootWord, $alternateWords)) {
|
||
$alternateWords[] = $rootWord;
|
||
} else {
|
||
$rootWord = '';
|
||
}
|
||
}
|
||
|
||
$alternateWords = array_unique($alternateWords);
|
||
$booleanWords = $alternateWords;
|
||
|
||
// prepare alternate words for inclusion in boolean value and remove any that aren’t indexable
|
||
foreach($alternateWords as $key => $alternateWord) {
|
||
$alternateWord = $this->escapeAgainst($alternateWord);
|
||
$length = $this->strlen($alternateWord);
|
||
|
||
if($alternateWord === $rootWord && $length > 1) {
|
||
// root word is always partial match. weight less if there are other alternates to match
|
||
$less = count($booleanWords) > 1 && !empty($options['partialLess']) ? '<' : '';
|
||
$booleanWords[$key] = $less . $alternateWord . '*';
|
||
if($length >= $minWordLength && $length >= 3) $booleanWords[] = $less . $alternateWord;
|
||
unset($alternateWords[$key]);
|
||
|
||
} else if($length < $minWordLength || $this->isStopword($alternateWord)) {
|
||
// alternate word not indexable, remove it
|
||
unset($alternateWords[$key]);
|
||
unset($booleanWords[$key]);
|
||
|
||
} else {
|
||
// replace with escaped version
|
||
$alternateWords[$key] = $alternateWord;
|
||
$booleanWords[$key] = $alternateWord;
|
||
}
|
||
}
|
||
|
||
if(!count($booleanWords)) return array();
|
||
|
||
// rebuild boolean value to include alternates: "+(word word)" or "+word" or ""
|
||
if($required) $booleanValue = ltrim($booleanValue, '+');
|
||
|
||
// remove parens from boolean value, if present
|
||
$booleanValue = trim($booleanValue, '()');
|
||
|
||
// assign higher weight to existing first word, if not already
|
||
if($booleanValue && strpos($booleanValue, '>') !== 0) $booleanValue = ">$booleanValue";
|
||
|
||
// append alternate words
|
||
$booleanValue = trim($booleanValue . ' ' . implode(' ', $booleanWords));
|
||
|
||
// package boolean value into parens and optional "+" prefix (indicating required)
|
||
$booleanValue = "$required($booleanValue)";
|
||
|
||
return $alternateWords;
|
||
}
|
||
|
||
/**
|
||
* Get boolean query value where "+" and "-" and "*" and '"' are allowed in query to affect results
|
||
*
|
||
* @param string $value
|
||
* @return string
|
||
*
|
||
*/
|
||
protected function getBooleanModeCommands($value) {
|
||
$booleanValues = array();
|
||
$value = str_replace(array('“', '”'), '"', $value);
|
||
/** @var SelectorContainsAdvanced $selector */
|
||
$selector = Selectors::getSelectorByOperator('#=');
|
||
$commands = $selector->valueToCommands($value);
|
||
foreach($commands as $command) {
|
||
$booleanValue = $this->escapeAgainst($command['value']);
|
||
if($command['phrase']) $booleanValue = '"' . $booleanValue . '"';
|
||
if($command['type']) $booleanValue = $command['type'] . $booleanValue;
|
||
if($command['partial']) $booleanValue .= '*';
|
||
$booleanValues[] = $booleanValue;
|
||
}
|
||
return implode(' ', $booleanValues);
|
||
}
|
||
|
||
/**
|
||
* Get array of words from given value
|
||
*
|
||
* @param string $value
|
||
* @param array $options
|
||
* @return array
|
||
*
|
||
*/
|
||
protected function words($value, array $options = array()) {
|
||
|
||
$defaults = array(
|
||
'keepNumberFormat' => false,
|
||
'keepApostrophe' => false,
|
||
'minWordLength' => 1, // minimum allowed length or true for ft_min_word_len
|
||
'stopwords' => true, // allow stopwords
|
||
'indexable' => false, // include only indexable words?
|
||
'alternates' => false, // include alternate versions of words?
|
||
);
|
||
|
||
$options = count($options) ? array_merge($defaults, $options) : $defaults;
|
||
if($options['minWordLength'] === true) $options['minWordLength'] = (int) $this->database->getVariable('ft_min_word_len');
|
||
$words = $this->wire()->sanitizer->wordsArray($value, $options);
|
||
|
||
if($options['alternates']) {
|
||
foreach($words as $word) {
|
||
$alts = $this->getWordAlternates($word);
|
||
foreach($alts as $alt) {
|
||
if(!in_array($alt, $words)) $words[] = $alt;
|
||
}
|
||
}
|
||
}
|
||
|
||
if($options['indexable']) {
|
||
foreach($words as $key => $word) {
|
||
if(!$this->isIndexableWord($word)) unset($words[$key]);
|
||
}
|
||
} else if(!$options['stopwords']) {
|
||
foreach($words as $key => $word) {
|
||
if($this->isStopword($word)) unset($words[$key]);
|
||
}
|
||
}
|
||
|
||
return $words;
|
||
}
|
||
|
||
/**
|
||
* Prepare a word or phrase for use in an RLIKE statement
|
||
*
|
||
* @param string $value
|
||
* @param array $options
|
||
* @return string
|
||
*
|
||
*/
|
||
protected function rlikeValue($value, array $options = array()) {
|
||
|
||
$defaults = array(
|
||
'start' => false,
|
||
'end' => false,
|
||
'partial' => true, // partial match at end of
|
||
);
|
||
|
||
$options = array_merge($defaults, $options);
|
||
|
||
// consider hyphen and space the same for matching purposes (must be before preg_quote)
|
||
$value = str_replace('-', ' ', $value);
|
||
|
||
// escape characters used in regular expressions
|
||
$likeValue = preg_quote($value);
|
||
|
||
if(strpos($likeValue, "'") !== false || strpos($likeValue, "’") !== false) {
|
||
// match either straight or curly apostrophe
|
||
$likeValue = preg_replace('/[\'’]+/', '(\'|’)', $likeValue);
|
||
// if word ends with apostrophe then apostrophe is optional
|
||
$likeValue = rtrim(str_replace("('|’) ", "('|’)? ", "$likeValue "));
|
||
}
|
||
|
||
if(strpos($likeValue, ' ') !== false) {
|
||
// collapse multiple spaces to just one
|
||
while(strpos($likeValue, ' ') !== false) $likeValue = str_replace(' ', ' ', $likeValue);
|
||
// hyphen/space can match space or hyphen in any quantity
|
||
$likeValue = str_replace(' ', '[- ]+', $likeValue);
|
||
}
|
||
|
||
if($options['start']) {
|
||
// given value must match at beginning
|
||
$likeValue = '^[[:space:]]*(<[^>]+>)*[[:space:]]*' . $likeValue;
|
||
|
||
} else if($options['end']) {
|
||
// given value must match at end
|
||
$likeValue .= '[[:space:]]*[[:punct:]]*[[:space:]]*(<[^>]+>)*[[:space:]]*$';
|
||
|
||
} else {
|
||
// given value can match at beginning of any word boundary in value
|
||
if($this->wire()->database->getRegexEngine() === 'ICU') {
|
||
list($a, $b) = array("\\b", "\\b");
|
||
} else {
|
||
list($a, $b) = array('[[:<:]]', '[[:>:]]');
|
||
}
|
||
|
||
$likeValue = "($a|[[:blank:]]|[[:punct:]]|[[:space:]]|^|[-]|>|‘|“|„|«|‹|¿|¡)" . $likeValue;
|
||
|
||
// if not doing partial matching then must also end at word boundary
|
||
if(!$options['partial']) $likeValue .= "($b|[[:blank:]]|[[:punct:]]|[[:space:]]|$|[-]|<|’|”|»|›)";
|
||
}
|
||
|
||
return $likeValue;
|
||
}
|
||
|
||
/**
|
||
* @param string $value
|
||
* @return int
|
||
*
|
||
*/
|
||
protected function strlen($value) {
|
||
if(function_exists('mb_strlen')) {
|
||
return mb_strlen($value);
|
||
} else {
|
||
return strlen($value);
|
||
}
|
||
}
|
||
|
||
/**
|
||
* Is given word a stopword?
|
||
*
|
||
* @param string $word
|
||
* @return bool
|
||
*
|
||
*/
|
||
protected function isStopword($word) {
|
||
if($this->strlen($word) < 2) return true;
|
||
return $this->wire()->database->isStopword($word);
|
||
}
|
||
|
||
/**
|
||
* Is word too short for fulltext index?
|
||
*
|
||
* @param string $word
|
||
* @return bool
|
||
*
|
||
*/
|
||
protected function isShortword($word) {
|
||
$minWordLength = $this->getMinWordLength();
|
||
if($minWordLength && $this->strlen($word) < $minWordLength) return true;
|
||
return false;
|
||
}
|
||
|
||
/**
|
||
* Is given word not a stopword and long enough to be indexed?
|
||
*
|
||
* @param string $word
|
||
* @return bool
|
||
*
|
||
*/
|
||
protected function isIndexableWord($word) {
|
||
if($this->isShortword($word)) return false;
|
||
if($this->isStopword($word)) return false;
|
||
return true;
|
||
}
|
||
|
||
/**
|
||
* Get unique score field name
|
||
*
|
||
* @return string
|
||
* @since 3.0.160
|
||
*
|
||
*/
|
||
protected function getScoreFieldName() {
|
||
$key = $this->tableName . '_' . $this->fieldName;
|
||
self::$scoreCnts[$key] = isset(self::$scoreCnts[$key]) ? self::$scoreCnts[$key] + 1 : 0;
|
||
return '_score_' . $key . self::$scoreCnts[$key];
|
||
}
|
||
|
||
/**
|
||
* Get minimum allowed indexable word length
|
||
*
|
||
* @return int
|
||
*
|
||
*/
|
||
protected function getMinWordLength() {
|
||
// note: ft_min_word_len is automatically changed to InnoDB’s equivalent when applicable
|
||
if($this->minWordLength !== null) return $this->minWordLength;
|
||
$this->minWordLength = (int) $this->database->getVariable('ft_min_word_len');
|
||
return $this->minWordLength;
|
||
}
|
||
|
||
/**
|
||
* Get other variations of given word to search (such as plural, singular, lemmas, etc.)
|
||
*
|
||
* @param string $word
|
||
* @param int|null $minLength Minimum length for returned words
|
||
* @return array
|
||
*
|
||
*/
|
||
protected function getWordAlternates($word, $minLength = null) {
|
||
if($minLength === null) $minLength = $this->getMinWordLength();
|
||
return $this->wire()->sanitizer->getTextTools()->getWordAlternates($word, array(
|
||
'operator' => $this->operator,
|
||
'lowercase' => true,
|
||
'minLength' => $minLength,
|
||
));
|
||
}
|
||
|
||
/**
|
||
* Get root of word (currently not implemented)
|
||
*
|
||
* @param string $word
|
||
* @return string
|
||
*
|
||
*/
|
||
protected function getWordRoot($word) {
|
||
if($word) {}
|
||
return '';
|
||
}
|
||
|
||
/**
|
||
* Call forceLike(true) to force use of LIKE, or omit argument to get current setting
|
||
*
|
||
* This forces LIKE only for matching operators that have a LIKE equivalent.
|
||
* This includes these operators: `*=`, `^=`, `$=`, `~=`, `~|=`.
|
||
*
|
||
* @param bool|null $forceLike
|
||
* @return bool
|
||
* @since 3.0.182
|
||
*
|
||
*/
|
||
public function forceLike($forceLike = null) {
|
||
if(is_bool($forceLike)) $this->forceLike = $forceLike;
|
||
return $this->forceLike;
|
||
|
||
}
|
||
}
|