/** * Retrieves an option set on this search query. * * @param string $name * The name of an option. * @param mixed $default * The value to return if the specified option is not set. * * @return mixed * The value of the option with the specified name, if set. NULL otherwise. * * @see \Drupal\search_api\Query\QueryInterface::getOption() */ public function getOption($name, $default = NULL) { if (!$this->shouldAbort()) { return $this->query->getOption($name, $default); } return $default; }
/** * Lets modules alter the Solarium select query before executing it. * * @param \Solarium\QueryType\Select\Query\Query $solarium_query * The Solarium query object, as generated from the Search API query. * @param \Drupal\search_api\Query\QueryInterface $query * The Search API query object representing the executed search query. */ function hook_search_api_solr_query_alter(\Solarium\QueryType\Select\Query\Query $solarium_query, \Drupal\search_api\Query\QueryInterface $query) { if ($query->getOption('foobar')) { // If the Search API query has a 'foobar' option, remove all sorting options // from the Solarium query. $solarium_query->clearSorts(); } }
/** * Implements SearchApiAutocompleteInterface::getAutocompleteSuggestions(). */ public function getAutocompleteSuggestions(QueryInterface $query, SearchApiAutocompleteSearch $search, $incomplete_key, $user_input) { $settings = isset($this->configuration['autocomplete']) ? $this->configuration['autocomplete'] : array(); $settings += array( 'suggest_suffix' => TRUE, 'suggest_words' => TRUE, ); // If none of these options is checked, the user apparently chose a very // roundabout way of telling us he doesn't want autocompletion. if (!array_filter($settings)) { return array(); } $index = $query->getIndex(); $db_info = $this->getIndexDbInfo($index); if (empty($db_info['field_tables'])) { throw new SearchApiException(new FormattableMarkup('Unknown index @id.', array('@id' => $index->id()))); } $fields = $this->getFieldInfo($index); $suggestions = array(); $passes = array(); $incomplete_like = NULL; // Make the input lowercase as the indexed data is (usually) also all // lowercase. $incomplete_key = Unicode::strtolower($incomplete_key); $user_input = Unicode::strtolower($user_input); // Decide which methods we want to use. if ($incomplete_key && $settings['suggest_suffix']) { $passes[] = 1; $incomplete_like = $this->database->escapeLike($incomplete_key) . '%'; } if ($settings['suggest_words'] && (!$incomplete_key || strlen($incomplete_key) >= $this->configuration['min_chars'])) { $passes[] = 2; } if (!$passes) { return array(); } // We want about half of the suggestions from each enabled method. $limit = $query->getOption('limit', 10); $limit /= count($passes); $limit = ceil($limit); // Also collect all keywords already contained in the query so we don't // suggest them. $keys = preg_split('/[^\p{L}\p{N}]+/u', $user_input, -1, PREG_SPLIT_NO_EMPTY); $keys = array_combine($keys, $keys); if ($incomplete_key) { $keys[$incomplete_key] = $incomplete_key; } foreach ($passes as $pass) { if ($pass == 2 && $incomplete_key) { $query->keys($user_input); } // To avoid suggesting incomplete words, we have to temporarily disable // the "partial_matches" option. (There should be no way we'll save the // server during the createDbQuery() call, so this should be safe.) $options = $this->options; $this->options['partial_matches'] = FALSE; $db_query = $this->createDbQuery($query, $fields); $this->options = $options; // We need a list of all current results to match the suggestions against. // However, since MySQL doesn't allow using a temporary table multiple // times in one query, we regrettably have to do it this way. $fulltext_fields = $this->getQueryFulltextFields($query); if (count($fulltext_fields) > 1) { $all_results = $db_query->execute()->fetchCol(); // Compute the total number of results so we can later sort out matches // that occur too often. $total = count($all_results); } else { $table = $this->getTemporaryResultsTable($db_query); if (!$table) { return array(); } $all_results = $this->database->select($table, 't') ->fields('t', array('item_id')); $total = $this->database->query("SELECT COUNT(item_id) FROM {{$table}}")->fetchField(); } $max_occurrences = $this->getConfigFactory()->get('search_api_db.settings')->get('autocomplete_max_occurrences'); $max_occurrences = max(1, floor($total * $max_occurrences)); if (!$total) { if ($pass == 1) { return NULL; } continue; } /** @var \Drupal\Core\Database\Query\SelectInterface|null $word_query */ $word_query = NULL; foreach ($fulltext_fields as $field) { if (!isset($fields[$field]) || !Utility::isTextType($fields[$field]['type'])) { continue; } $field_query = $this->database->select($fields[$field]['table'], 't'); $field_query->fields('t', array('word', 'item_id')) ->condition('item_id', $all_results, 'IN'); if ($pass == 1) { $field_query->condition('word', $incomplete_like, 'LIKE') ->condition('word', $keys, 'NOT IN'); } if (!isset($word_query)) { $word_query = $field_query; } else { $word_query->union($field_query); } } if (!$word_query) { return array(); } $db_query = $this->database->select($word_query, 't'); $db_query->addExpression('COUNT(DISTINCT item_id)', 'results'); $db_query->fields('t', array('word')) ->groupBy('word') ->having('results <= :max', array(':max' => $max_occurrences)) ->orderBy('results', 'DESC') ->range(0, $limit); $incomp_len = strlen($incomplete_key); foreach ($db_query->execute() as $row) { $suffix = ($pass == 1) ? substr($row->word, $incomp_len) : ' ' . $row->word; $suggestions[] = array( 'suggestion_suffix' => $suffix, 'results' => $row->results, ); } } return $suggestions; }
/** * {@inheritdoc} */ public function preprocessSearchQuery(QueryInterface $query) { if (!$query->getOption('search_api_bypass_access')) { $account = $query->getOption('search_api_access_account', \Drupal::currentUser()); if (is_numeric($account)) { $account = User::load($account); } if (is_object($account)) { try { $this->addNodeAccess($query, $account); } catch (SearchApiException $e) { watchdog_exception('search_api', $e); } } else { $account = $query->getOption('search_api_access_account', \Drupal::currentUser()); if ($account instanceof AccountInterface) { $account = $account->id(); } if (!is_scalar($account)) { $account = var_export($account, TRUE); } $this->getLogger()->warning('An illegal user UID was given for node access: @uid.', array('@uid' => $account)); } } }
public function getAutocompleteSuggestions(QueryInterface $query, SearchApiAutocompleteSearch $search, $incomplete_key, $user_input) { $suggestions = array(); // Reset request handler $this->request_handler = NULL; // Turn inputs to lower case, otherwise we get case sensivity problems. $incomp = Unicode::strtolower($incomplete_key); $index = $query->getIndex(); $field_names = $this->getFieldNames($index); $complete = $query->getOriginalKeys(); // Extract keys $keys = $query->getKeys(); if (is_array($keys)) { $keys_array = array(); while ($keys) { reset($keys); if (!element_child(key($keys))) { array_shift($keys); continue; } $key = array_shift($keys); if (is_array($key)) { $keys = array_merge($keys, $key); } else { $keys_array[$key] = $key; } } $keys = $this->getSolrHelper()->flattenKeys($query->getKeys()); } else { $keys_array = preg_split('/[-\\s():{}\\[\\]\\\\"]+/', $keys, -1, PREG_SPLIT_NO_EMPTY); $keys_array = array_combine($keys_array, $keys_array); } if (!$keys) { $keys = NULL; } // Set searched fields $options = $query->getOptions(); $search_fields = $query->getFulltextFields(); $qf = array(); foreach ($search_fields as $f) { $qf[] = $field_names[$f]; } // Extract filters $fq = $this->createFilterQueries($query->getFilter(), $field_names, $index->getOption('fields', array())); $index_id = $this->getIndexId($index->id()); $fq[] = 'index_id:' . $this->getQueryHelper()->escapePhrase($index_id); if ($this->configuration['site_hash']) { $site_hash = $this->getQueryHelper()->escapePhrase(SearchApiSolrUtility::getSiteHash()); $fq[] = 'hash:' . $site_hash; } // Autocomplete magic $facet_fields = array(); foreach ($search_fields as $f) { $facet_fields[] = $field_names[$f]; } $limit = $query->getOption('limit', 10); $params = array('qf' => $qf, 'fq' => $fq, 'rows' => 0, 'facet' => 'true', 'facet.field' => $facet_fields, 'facet.prefix' => $incomp, 'facet.limit' => $limit * 5, 'facet.mincount' => 1, 'spellcheck' => !isset($this->configuration['autocorrect_spell']) || $this->configuration['autocorrect_spell'] ? 'true' : 'false', 'spellcheck.count' => 1); // Retrieve http method from server options. $http_method = !empty($this->configuration['http_method']) ? $this->configuration['http_method'] : 'AUTO'; $call_args = array('query' => &$keys, 'params' => &$params, 'http_method' => &$http_method); if ($this->request_handler) { $this->setRequestHandler($this->request_handler, $call_args); } $second_pass = !isset($this->configuration['autocorrect_suggest_words']) || $this->configuration['autocorrect_suggest_words']; for ($i = 0; $i < ($second_pass ? 2 : 1); ++$i) { try { // Send search request $this->connect(); $this->moduleHandler->alter('search_api_solr_query', $call_args, $query); $this->preQuery($call_args, $query); $response = $this->solr->search($keys, $params, $http_method); if (!empty($response->spellcheck->suggestions)) { $replace = array(); foreach ($response->spellcheck->suggestions as $word => $data) { $replace[$word] = $data->suggestion[0]; } $corrected = str_ireplace(array_keys($replace), array_values($replace), $user_input); if ($corrected != $user_input) { array_unshift($suggestions, array('prefix' => $this->t('Did you mean') . ':', 'user_input' => $corrected)); } } $matches = array(); if (isset($response->facet_counts->facet_fields)) { foreach ($response->facet_counts->facet_fields as $terms) { foreach ($terms as $term => $count) { if (isset($matches[$term])) { // If we just add the result counts, we can easily get over the // total number of results if terms appear in multiple fields. // Therefore, we just take the highest value from any field. $matches[$term] = max($matches[$term], $count); } else { $matches[$term] = $count; } } } if ($matches) { // Eliminate suggestions that are too short or already in the query. foreach ($matches as $term => $count) { if (strlen($term) < 3 || isset($keys_array[$term])) { unset($matches[$term]); } } // Don't suggest terms that are too frequent (by default in more // than 90% of results). $result_count = $response->response->numFound; $max_occurrences = $result_count * $this->searchApiSolrSettings->get('autocomplete_max_occurrences'); if (($max_occurrences >= 1 || $i > 0) && $max_occurrences < $result_count) { foreach ($matches as $match => $count) { if ($count > $max_occurrences) { unset($matches[$match]); } } } // The $count in this array is actually a score. We want the // highest ones first. arsort($matches); // Shorten the array to the right ones. $additional_matches = array_slice($matches, $limit - count($suggestions), NULL, TRUE); $matches = array_slice($matches, 0, $limit, TRUE); // Build suggestions using returned facets $incomp_length = strlen($incomp); foreach ($matches as $term => $count) { if (Unicode::strtolower(substr($term, 0, $incomp_length)) == $incomp) { $suggestions[] = array('suggestion_suffix' => substr($term, $incomp_length), 'term' => $term, 'results' => $count); } else { $suggestions[] = array('suggestion_suffix' => ' ' . $term, 'term' => $term, 'results' => $count); } } } } } catch (SearchApiException $e) { watchdog_exception('search_api_solr', $e, "%type during autocomplete Solr query: !message in %function (line %line of %file).", array(), WATCHDOG_WARNING); } if (count($suggestions) >= $limit) { break; } // Change parameters for second query. unset($params['facet.prefix']); $keys = trim($keys . ' ' . $incomplete_key); } return $suggestions; }