vendor/ruflin/elastica/src/Search.php line 326

Open in your IDE?
  1. <?php
  3. namespace Elastica;
  5. use Elastica\Exception\InvalidException;
  6. use Elastica\Exception\ResponseException;
  7. use Elastica\Query\AbstractQuery;
  8. use Elastica\ResultSet\BuilderInterface;
  9. use Elastica\ResultSet\DefaultBuilder;
  10. use Elastica\Suggest\AbstractSuggest;
  12. /**
  13.  * Elastica search object.
  14.  *
  15.  * @author   Nicolas Ruflin <spam@ruflin.com>
  16.  */
  17. class Search
  18. {
  19.     /*
  20.      * Options
  21.      */
  22.     public const OPTION_SEARCH_TYPE = 'search_type';
  23.     public const OPTION_ROUTING = 'routing';
  24.     public const OPTION_PREFERENCE = 'preference';
  25.     public const OPTION_VERSION = 'version';
  26.     public const OPTION_TIMEOUT = 'timeout';
  27.     public const OPTION_FROM = 'from';
  28.     public const OPTION_SIZE = 'size';
  29.     public const OPTION_SCROLL = 'scroll';
  30.     public const OPTION_SCROLL_ID = 'scroll_id';
  31.     public const OPTION_QUERY_CACHE = 'query_cache';
  32.     public const OPTION_TERMINATE_AFTER = 'terminate_after';
  33.     public const OPTION_SHARD_REQUEST_CACHE = 'request_cache';
  34.     public const OPTION_FILTER_PATH = 'filter_path';
  35.     public const OPTION_TYPED_KEYS = 'typed_keys';
  37.     /*
  38.      * Search types
  39.      */
  40.     public const OPTION_SEARCH_TYPE_DFS_QUERY_THEN_FETCH = 'dfs_query_then_fetch';
  41.     public const OPTION_SEARCH_TYPE_QUERY_THEN_FETCH = 'query_then_fetch';
  42.     public const OPTION_SEARCH_TYPE_SUGGEST = 'suggest';
  43.     public const OPTION_SEARCH_IGNORE_UNAVAILABLE = 'ignore_unavailable';
  45.     /**
  46.      * Array of indices names.
  47.      *
  48.      * @var string[]
  49.      */
  50.     protected $_indices = [];
  52.     /**
  53.      * @var Query
  54.      */
  55.     protected $_query;
  57.     /**
  58.      * @var array
  59.      */
  60.     protected $_options = [];
  62.     /**
  63.      * Client object.
  64.      *
  65.      * @var Client
  66.      */
  67.     protected $_client;
  69.     /**
  70.      * @var BuilderInterface|null
  71.      */
  72.     private $builder;
  74.     public function __construct(Client $client, ?BuilderInterface $builder = null)
  75.     {
  76.         $this->_client = $client;
  77.         $this->builder = $builder ?: new DefaultBuilder();
  78.     }
  80.     /**
  81.      * Adds a index to the list.
  82.      *
  83.      * @param Index $index Index object or string
  84.      *
  85.      * @throws InvalidException
  86.      */
  87.     public function addIndex($index): self
  88.     {
  89.         if ($index instanceof Index) {
  90.             $index = $index->getName();
  91.         } else {
  92.             \trigger_deprecation(
  93.                 'ruflin/elastica',
  94.                 '7.2.0',
  95.                 'Passing a string as 1st argument to "%s()" is deprecated, pass an Index instance or use "addIndexByName" instead. It will throw a %s in 8.0.',
  96.                 __METHOD__,
  97.                 \TypeError::class
  98.             );
  99.         }
  101.         if (!\is_scalar($index)) {
  102.             throw new InvalidException('Invalid param type');
  103.         }
  105.         return $this->addIndexByName((string) $index);
  106.     }
  108.     /**
  109.      * Adds an index to the list.
  110.      */
  111.     public function addIndexByName(string $index): self
  112.     {
  113.         $this->_indices[] = $index;
  115.         return $this;
  116.     }
  118.     /**
  119.      * Add array of indices at once.
  120.      *
  121.      * @param Index[] $indices
  122.      */
  123.     public function addIndices(array $indices = []): self
  124.     {
  125.         foreach ($indices as $index) {
  126.             if (\is_string($index)) {
  127.                 \trigger_deprecation(
  128.                     'ruflin/elastica',
  129.                     '7.2.0',
  130.                     'Passing a array of strings as 1st argument to "%s()" is deprecated, pass an array of Indexes or use "addIndicesByName" instead. It will throw a %s in 8.0.',
  131.                     __METHOD__,
  132.                     \TypeError::class
  133.                 );
  134.                 $this->addIndexByName($index);
  136.                 continue;
  137.             }
  139.             if (!$index instanceof Index) {
  140.                 throw new InvalidException('Invalid param type for addIndices(), expected Index[]');
  141.             }
  143.             $this->addIndex($index);
  144.         }
  146.         return $this;
  147.     }
  149.     /**
  150.      * @param string[] $indices
  151.      */
  152.     public function addIndicesByName(array $indices = []): self
  153.     {
  154.         foreach ($indices as $index) {
  155.             if (!\is_string($index)) {
  156.                 throw new InvalidException('Invalid param type for addIndicesByName(), expected string[]');
  157.             }
  158.             $this->addIndexByName($index);
  159.         }
  161.         return $this;
  162.     }
  164.     /**
  165.      * @param AbstractQuery|AbstractSuggest|array|Collapse|Query|string|Suggest $query
  166.      */
  167.     public function setQuery($query): self
  168.     {
  169.         $this->_query = Query::create($query);
  171.         return $this;
  172.     }
  174.     /**
  175.      * @param mixed $value
  176.      */
  177.     public function setOption(string $key, $value): self
  178.     {
  179.         $this->validateOption($key);
  181.         $this->_options[$key] = $value;
  183.         return $this;
  184.     }
  186.     public function setOptions(array $options): self
  187.     {
  188.         $this->clearOptions();
  190.         foreach ($options as $key => $value) {
  191.             $this->setOption($key, $value);
  192.         }
  194.         return $this;
  195.     }
  197.     public function clearOptions(): self
  198.     {
  199.         $this->_options = [];
  201.         return $this;
  202.     }
  204.     /**
  205.      * @param mixed $value
  206.      */
  207.     public function addOption(string $key, $value): self
  208.     {
  209.         $this->validateOption($key);
  211.         $this->_options[$key][] = $value;
  213.         return $this;
  214.     }
  216.     public function hasOption(string $key): bool
  217.     {
  218.         return isset($this->_options[$key]);
  219.     }
  221.     /**
  222.      * @throws InvalidException if the given key does not exists as an option
  223.      *
  224.      * @return mixed
  225.      */
  226.     public function getOption(string $key)
  227.     {
  228.         if (!$this->hasOption($key)) {
  229.             throw new InvalidException('Option '.$key.' does not exist');
  230.         }
  232.         return $this->_options[$key];
  233.     }
  235.     public function getOptions(): array
  236.     {
  237.         return $this->_options;
  238.     }
  240.     /**
  241.      * Return client object.
  242.      */
  243.     public function getClient(): Client
  244.     {
  245.         return $this->_client;
  246.     }
  248.     /**
  249.      * Return array of indices names.
  250.      *
  251.      * @return string[]
  252.      */
  253.     public function getIndices(): array
  254.     {
  255.         return $this->_indices;
  256.     }
  258.     public function hasIndices(): bool
  259.     {
  260.         return \count($this->_indices) > 0;
  261.     }
  263.     /**
  264.      * @param Index $index
  265.      */
  266.     public function hasIndex($index): bool
  267.     {
  268.         if ($index instanceof Index) {
  269.             $index = $index->getName();
  270.         } else {
  271.             \trigger_deprecation(
  272.                 'ruflin/elastica',
  273.                 '7.2.0',
  274.                 'Passing a string as 1st argument to "%s()" is deprecated, pass an Index instance or use "hasIndexByName" instead. It will throw a %s in 8.0.',
  275.                 __METHOD__,
  276.                 \TypeError::class
  277.             );
  278.         }
  280.         return $this->hasIndexByName($index);
  281.     }
  283.     public function hasIndexByName(string $index): bool
  284.     {
  285.         return \in_array($index, $this->_indices, true);
  286.     }
  288.     public function getQuery(): Query
  289.     {
  290.         if (null === $this->_query) {
  291.             $this->_query = Query::create('');
  292.         }
  294.         return $this->_query;
  295.     }
  297.     /**
  298.      * Creates new search object.
  299.      */
  300.     public static function create(SearchableInterface $searchObject): Search
  301.     {
  302.         return $searchObject->createSearch();
  303.     }
  305.     /**
  306.      * Combines indices to the search request path.
  307.      */
  308.     public function getPath(): string
  309.     {
  310.         if (isset($this->_options[self::OPTION_SCROLL_ID])) {
  311.             return '_search/scroll';
  312.         }
  314.         return \implode(',', $this->getIndices()).'/_search';
  315.     }
  317.     /**
  318.      * Search in the set indices.
  319.      *
  320.      * @param AbstractQuery|AbstractSuggest|array|Collapse|Query|string|Suggest $query
  321.      * @param array|int                                                         $options Limit or associative array of options (option=>value)
  322.      *
  323.      * @throws InvalidException
  324.      * @throws ResponseException
  325.      */
  326.     public function search($query = '', $options = null, string $method = Request::POST): ResultSet
  327.     {
  328.         $this->setOptionsAndQuery($options, $query);
  330.         $query = $this->getQuery();
  331.         $path = $this->getPath();
  333.         $params = $this->getOptions();
  335.         // Send scroll_id via raw HTTP body to handle cases of very large (> 4kb) ids.
  336.         if ('_search/scroll' === $path) {
  337.             $data = [self::OPTION_SCROLL_ID => $params[self::OPTION_SCROLL_ID]];
  338.             unset($params[self::OPTION_SCROLL_ID]);
  339.         } else {
  340.             $data = $query->toArray();
  341.         }
  343.         $response = $this->getClient()->request($path, $method, $data, $params);
  345.         return $this->builder->buildResultSet($response, $query);
  346.     }
  348.     /**
  349.      * @param array|Query|Query\AbstractQuery|string $query
  350.      * @param bool                                   $fullResult By default only the total hit count is returned. If set to true, the full ResultSet including aggregations is returned
  351.      *
  352.      * @return int|ResultSet
  353.      */
  354.     public function count($query = '', bool $fullResult = false, string $method = Request::POST)
  355.     {
  356.         $this->setOptionsAndQuery(null, $query);
  358.         // Clone the object as we do not want to modify the original query.
  359.         $query = clone $this->getQuery();
  360.         $query->setSize(0);
  361.         $query->setTrackTotalHits(true);
  363.         $path = $this->getPath();
  365.         $response = $this->getClient()->request(
  366.             $path,
  367.             $method,
  368.             $query->toArray(),
  369.             [self::OPTION_SEARCH_TYPE => self::OPTION_SEARCH_TYPE_QUERY_THEN_FETCH]
  370.         );
  371.         $resultSet = $this->builder->buildResultSet($response, $query);
  373.         return $fullResult ? $resultSet : $resultSet->getTotalHits();
  374.     }
  376.     /**
  377.      * @param array|int                                                         $options
  378.      * @param AbstractQuery|AbstractSuggest|array|Collapse|Query|string|Suggest $query
  379.      */
  380.     public function setOptionsAndQuery($options = null, $query = ''): self
  381.     {
  382.         if ('' !== $query) {
  383.             $this->setQuery($query);
  384.         }
  386.         if (\is_int($options)) {
  387.             \trigger_deprecation('ruflin/elastica', '7.1.3', 'Passing an int as 1st argument to "%s()" is deprecated, pass an array with the key "size" instead. It will be removed in 8.0.', __METHOD__);
  388.             $this->getQuery()->setSize($options);
  389.         } elseif (\is_array($options)) {
  390.             if (isset($options['limit'])) {
  391.                 $this->getQuery()->setSize($options['limit']);
  392.                 unset($options['limit']);
  393.             }
  394.             if (isset($options['explain'])) {
  395.                 $this->getQuery()->setExplain($options['explain']);
  396.                 unset($options['explain']);
  397.             }
  398.             $this->setOptions($options);
  399.         }
  401.         return $this;
  402.     }
  404.     public function setSuggest(Suggest $suggest): self
  405.     {
  406.         return $this->setOptionsAndQuery([self::OPTION_SEARCH_TYPE_SUGGEST => 'suggest'], $suggest);
  407.     }
  409.     /**
  410.      * Returns the Scroll Iterator.
  411.      *
  412.      * @see Scroll
  413.      */
  414.     public function scroll(string $expiryTime = '1m'): Scroll
  415.     {
  416.         return new Scroll($this, $expiryTime);
  417.     }
  419.     public function getResultSetBuilder(): BuilderInterface
  420.     {
  421.         return $this->builder;
  422.     }
  424.     /**
  425.      * @throws InvalidException If the given key is not a valid option
  426.      */
  427.     protected function validateOption(string $key): void
  428.     {
  429.         switch ($key) {
  430.             case self::OPTION_SEARCH_TYPE:
  431.             case self::OPTION_ROUTING:
  432.             case self::OPTION_PREFERENCE:
  433.             case self::OPTION_VERSION:
  434.             case self::OPTION_TIMEOUT:
  435.             case self::OPTION_FROM:
  436.             case self::OPTION_SIZE:
  437.             case self::OPTION_SCROLL:
  438.             case self::OPTION_SCROLL_ID:
  439.             case self::OPTION_SEARCH_TYPE_SUGGEST:
  440.             case self::OPTION_SEARCH_IGNORE_UNAVAILABLE:
  441.             case self::OPTION_QUERY_CACHE:
  442.             case self::OPTION_TERMINATE_AFTER:
  443.             case self::OPTION_SHARD_REQUEST_CACHE:
  444.             case self::OPTION_FILTER_PATH:
  445.             case self::OPTION_TYPED_KEYS:
  446.                 return;
  447.         }
  449.         throw new InvalidException('Invalid option '.$key);
  450.     }
  451. }