/**
* Build a condition to match a table name against a standard information_schema.
*
* MySQL uses databases like schemas rather than catalogs so when we build
* a condition to query the information_schema.tables, we set the default
* database as the schema unless specified otherwise, and exclude table_catalog
* from the condition criteria.
*/
protected function buildTableNameCondition($table_name, $operator = '=', $add_prefix = TRUE)
{
$info = $this->connection->getConnectionOptions();
$table_info = $this->getPrefixInfo($table_name, $add_prefix);
$condition = new DatabaseCondition('AND');
$condition->condition('table_schema', $table_info['database']);
$condition->condition('table_name', $table_info['table'], $operator);
return $condition;
}
/**
* Parses the search query into SQL conditions.
*
* Sets up the following variables:
* - $this->keys
* - $this->words
* - $this->conditions
* - $this->simple
* - $this->matches
*/
protected function parseSearchExpression()
{
// Matches words optionally prefixed by a - sign. A word in this case is
// something between two spaces, optionally quoted.
preg_match_all('/ (-?)("[^"]+"|[^" ]+)/i', ' ' . $this->searchExpression, $keywords, PREG_SET_ORDER);
if (count($keywords) == 0) {
return;
}
// Classify tokens.
$or = FALSE;
$limit_combinations = \Drupal::config('search.settings')->get('and_or_limit');
// The first search expression does not count as AND.
$and_count = -1;
$or_count = 0;
foreach ($keywords as $match) {
if ($or_count && $and_count + $or_count >= $limit_combinations) {
// Ignore all further search expressions to prevent Denial-of-Service
// attacks using a high number of AND/OR combinations.
$this->status |= SearchQuery::EXPRESSIONS_IGNORED;
break;
}
$phrase = FALSE;
// Strip off phrase quotes.
if ($match[2][0] == '"') {
$match[2] = substr($match[2], 1, -1);
$phrase = TRUE;
$this->simple = FALSE;
}
// Simplify keyword according to indexing rules and external
// preprocessors. Use same process as during search indexing, so it
// will match search index.
$words = search_simplify($match[2]);
// Re-explode in case simplification added more words, except when
// matching a phrase.
$words = $phrase ? array($words) : preg_split('/ /', $words, -1, PREG_SPLIT_NO_EMPTY);
// Negative matches.
if ($match[1] == '-') {
$this->keys['negative'] = array_merge($this->keys['negative'], $words);
} elseif ($match[2] == 'OR' && count($this->keys['positive'])) {
$last = array_pop($this->keys['positive']);
// Starting a new OR?
if (!is_array($last)) {
$last = array($last);
}
$this->keys['positive'][] = $last;
$or = TRUE;
$or_count++;
continue;
} elseif ($match[2] == 'AND' || $match[2] == 'and') {
continue;
} else {
if ($match[2] == 'or') {
// Lower-case "or" instead of "OR" is a warning condition.
$this->status |= SearchQuery::LOWER_CASE_OR;
}
if ($or) {
// Add to last element (which is an array).
$this->keys['positive'][count($this->keys['positive']) - 1] = array_merge($this->keys['positive'][count($this->keys['positive']) - 1], $words);
} else {
$this->keys['positive'] = array_merge($this->keys['positive'], $words);
$and_count++;
}
}
$or = FALSE;
}
// Convert keywords into SQL statements.
$simple_and = FALSE;
$simple_or = FALSE;
// Positive matches.
foreach ($this->keys['positive'] as $key) {
// Group of ORed terms.
if (is_array($key) && count($key)) {
$simple_or = TRUE;
$any = FALSE;
$queryor = db_or();
foreach ($key as $or) {
list($num_new_scores) = $this->parseWord($or);
$any |= $num_new_scores;
$queryor->condition('d.data', "% {$or} %", 'LIKE');
}
if (count($queryor)) {
$this->conditions->condition($queryor);
// A group of OR keywords only needs to match once.
$this->matches += $any > 0;
}
} else {
$simple_and = TRUE;
list($num_new_scores, $num_valid_words) = $this->parseWord($key);
$this->conditions->condition('d.data', "% {$key} %", 'LIKE');
if (!$num_valid_words) {
$this->simple = FALSE;
}
// Each AND keyword needs to match at least once.
$this->matches += $num_new_scores;
}
}
if ($simple_and && $simple_or) {
$this->simple = FALSE;
}
// Negative matches.
foreach ($this->keys['negative'] as $key) {
$this->conditions->condition('d.data', "% {$key} %", 'NOT LIKE');
$this->simple = FALSE;
}
}
public function execute()
{
if (!empty($this->queryOptions['sqlite_return_matched_rows'])) {
return parent::execute();
}
// Get the fields used in the update query, and remove those that are already
// in the condition.
$fields = $this->expressionFields + $this->fields;
$this->removeFieldsInCondition($fields, $this->condition);
// Add the inverse of the fields to the condition.
$condition = new DatabaseCondition('OR');
foreach ($fields as $field => $data) {
if (is_array($data)) {
// The field is an expression.
$condition->where($field . ' <> ' . $data['expression']);
$condition->isNull($field);
} elseif (!isset($data)) {
// The field will be set to NULL.
$condition->isNull($field);
} else {
$condition->condition($field, $data, '<>');
$condition->isNull($field);
}
}
if (count($condition)) {
$condition->compile($this->connection, $this);
$this->condition->where((string) $condition, $condition->arguments());
}
return parent::execute();
}
/**
* {@inheritdoc}
*/
public function preloadPathAlias($sources, $langcode)
{
// VERY IMPORTANT PIECE OF DOCUMENTATION, BECAUSE CORE DOES NOT
// DOCUMENT IT VERY WELL:
// - the query inverse all the orders 'pid' and 'language' compared
// to the original ::lookupPathAlias() method
// - smart little bitches, it seems they didn't know how to write it
// correctly in SQL (and neither do I actually) - so they rely on
// the fetchAllKeyed() method, which iterates in order on the rows
// making them squashing the previously fetched one
$query = $this->db->select('url_alias', 'u')->fields('u', ['source', 'alias']);
$condition = new \DatabaseCondition('OR');
foreach ($sources as $source) {
// See the queries above. Use LIKE for case-insensitive matching.
$condition->condition('u.source', $this->db->escapeLike($source), 'LIKE');
}
$query->condition($condition);
if (LanguageInterface::LANGCODE_NOT_SPECIFIED === $langcode) {
$langcodeList = [$langcode];
} else {
$langcodeList = [$langcode, LanguageInterface::LANGCODE_NOT_SPECIFIED];
// !!! condition here is inversed from the lookup*() methods
if (LanguageInterface::LANGCODE_NOT_SPECIFIED > $langcode) {
$query->orderBy('u.language', 'DESC');
} else {
$query->orderBy('u.language', 'ASC');
}
}
return $query->orderBy('u.pid', 'ASC')->condition('u.language', $langcodeList)->execute()->fetchAllKeyed();
}
public function condition($field, $value = null, $operator = null)
{
Internal\condition_hook($field, $value, $operator);
return parent::condition($field, $value, $operator);
}
public function havingCondition($field, $value = NULL, $operator = NULL)
{
$this->having->condition($field, $value, $operator);
return $this;
}
