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

Open in your IDE?
  1. <?php
  3. namespace Elastica;
  5. use Elastica\Exception\ClientException;
  6. use Elastica\Exception\ConnectionException;
  7. use Elastica\Exception\InvalidException;
  8. use Elastica\Exception\ResponseException;
  9. use Elastica\Query\AbstractQuery;
  10. use Elastica\Query\MatchAll;
  11. use Elastica\ResultSet\BuilderInterface;
  12. use Elastica\ResultSet\DefaultBuilder;
  13. use Elastica\Suggest\AbstractSuggest;
  15. /**
  16. * Elastica search object.
  17. *
  18. * @author Nicolas Ruflin <spam@ruflin.com>
  19. * @phpstan-import-type TCreateQueryArgs from Query
  20. */
  21. class Search
  22. {
  23. /*
  24. * Options
  25. */
  26. public const OPTION_SEARCH_TYPE = 'search_type';
  27. public const OPTION_ROUTING = 'routing';
  28. public const OPTION_PREFERENCE = 'preference';
  29. public const OPTION_VERSION = 'version';
  30. public const OPTION_TIMEOUT = 'timeout';
  31. public const OPTION_FROM = 'from';
  32. public const OPTION_SIZE = 'size';
  33. public const OPTION_SCROLL = 'scroll';
  34. public const OPTION_SCROLL_ID = 'scroll_id';
  35. public const OPTION_QUERY_CACHE = 'query_cache';
  36. public const OPTION_TERMINATE_AFTER = 'terminate_after';
  37. public const OPTION_SHARD_REQUEST_CACHE = 'request_cache';
  38. public const OPTION_FILTER_PATH = 'filter_path';
  39. public const OPTION_TYPED_KEYS = 'typed_keys';
  41. /*
  42. * Search types
  43. */
  44. public const OPTION_SEARCH_TYPE_DFS_QUERY_THEN_FETCH = 'dfs_query_then_fetch';
  45. public const OPTION_SEARCH_TYPE_QUERY_THEN_FETCH = 'query_then_fetch';
  46. public const OPTION_SEARCH_TYPE_SUGGEST = 'suggest';
  47. public const OPTION_SEARCH_IGNORE_UNAVAILABLE = 'ignore_unavailable';
  49. /**
  50. * Array of indices names.
  51. *
  52. * @var string[]
  53. */
  54. protected $_indices = [];
  56. /**
  57. * @var Query
  58. */
  59. protected $_query;
  61. /**
  62. * @var array
  63. */
  64. protected $_options = [];
  66. /**
  67. * Client object.
  68. *
  69. * @var Client
  70. */
  71. protected $_client;
  73. /**
  74. * @var BuilderInterface|null
  75. */
  76. private $builder;
  78. public function __construct(Client $client, ?BuilderInterface $builder = null)
  79. {
  80. $this->_client = $client;
  81. $this->builder = $builder ?: new DefaultBuilder();
  82. }
  84. /**
  85. * Adds a index to the list.
  86. *
  87. * @param Index $index Index object or string
  88. *
  89. * @throws InvalidException
  90. */
  91. public function addIndex($index): self
  92. {
  93. if ($index instanceof Index) {
  94. $index = $index->getName();
  95. } else {
  96. \trigger_deprecation(
  97. 'ruflin/elastica',
  98. '7.2.0',
  99. '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.',
  100. __METHOD__,
  101. \TypeError::class
  102. );
  103. }
  105. if (!\is_scalar($index)) {
  106. throw new InvalidException('Invalid param type');
  107. }
  109. return $this->addIndexByName((string) $index);
  110. }
  112. /**
  113. * Adds an index to the list.
  114. */
  115. public function addIndexByName(string $index): self
  116. {
  117. $this->_indices[] = $index;
  119. return $this;
  120. }
  122. /**
  123. * Add array of indices at once.
  124. *
  125. * @param Index[] $indices
  126. */
  127. public function addIndices(array $indices = []): self
  128. {
  129. foreach ($indices as $index) {
  130. if (\is_string($index)) {
  131. \trigger_deprecation(
  132. 'ruflin/elastica',
  133. '7.2.0',
  134. '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.',
  135. __METHOD__,
  136. \TypeError::class
  137. );
  138. $this->addIndexByName($index);
  140. continue;
  141. }
  143. if (!$index instanceof Index) {
  144. throw new InvalidException('Invalid param type for addIndices(), expected Index[]');
  145. }
  147. $this->addIndex($index);
  148. }
  150. return $this;
  151. }
  153. /**
  154. * @param string[] $indices
  155. */
  156. public function addIndicesByName(array $indices = []): self
  157. {
  158. foreach ($indices as $index) {
  159. if (!\is_string($index)) {
  160. throw new InvalidException('Invalid param type for addIndicesByName(), expected string[]');
  161. }
  162. $this->addIndexByName($index);
  163. }
  165. return $this;
  166. }
  168. /**
  169. * @param AbstractQuery|AbstractSuggest|array|Collapse|Query|string|Suggest|null $query
  170. * @phpstan-param TCreateQueryArgs $query
  171. */
  172. public function setQuery($query): self
  173. {
  174. $this->_query = Query::create($query);
  176. return $this;
  177. }
  179. /**
  180. * @param mixed $value
  181. */
  182. public function setOption(string $key, $value): self
  183. {
  184. $this->validateOption($key);
  186. $this->_options[$key] = $value;
  188. return $this;
  189. }
  191. public function setOptions(array $options): self
  192. {
  193. $this->clearOptions();
  195. foreach ($options as $key => $value) {
  196. $this->setOption($key, $value);
  197. }
  199. return $this;
  200. }
  202. public function clearOptions(): self
  203. {
  204. $this->_options = [];
  206. return $this;
  207. }
  209. /**
  210. * @param mixed $value
  211. */
  212. public function addOption(string $key, $value): self
  213. {
  214. $this->validateOption($key);
  216. $this->_options[$key][] = $value;
  218. return $this;
  219. }
  221. public function hasOption(string $key): bool
  222. {
  223. return isset($this->_options[$key]);
  224. }
  226. /**
  227. * @throws InvalidException if the given key does not exists as an option
  228. *
  229. * @return mixed
  230. */
  231. public function getOption(string $key)
  232. {
  233. if (!$this->hasOption($key)) {
  234. throw new InvalidException('Option '.$key.' does not exist');
  235. }
  237. return $this->_options[$key];
  238. }
  240. public function getOptions(): array
  241. {
  242. return $this->_options;
  243. }
  245. /**
  246. * Return client object.
  247. */
  248. public function getClient(): Client
  249. {
  250. return $this->_client;
  251. }
  253. /**
  254. * Return array of indices names.
  255. *
  256. * @return string[]
  257. */
  258. public function getIndices(): array
  259. {
  260. return $this->_indices;
  261. }
  263. public function hasIndices(): bool
  264. {
  265. return \count($this->_indices) > 0;
  266. }
  268. /**
  269. * @param Index $index
  270. */
  271. public function hasIndex($index): bool
  272. {
  273. if ($index instanceof Index) {
  274. $index = $index->getName();
  275. } else {
  276. \trigger_deprecation(
  277. 'ruflin/elastica',
  278. '7.2.0',
  279. '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.',
  280. __METHOD__,
  281. \TypeError::class
  282. );
  283. }
  285. return $this->hasIndexByName($index);
  286. }
  288. public function hasIndexByName(string $index): bool
  289. {
  290. return \in_array($index, $this->_indices, true);
  291. }
  293. public function getQuery(): Query
  294. {
  295. if (null === $this->_query) {
  296. $this->_query = new Query(new MatchAll());
  297. }
  299. return $this->_query;
  300. }
  302. /**
  303. * Creates new search object.
  304. */
  305. public static function create(SearchableInterface $searchObject): Search
  306. {
  307. return $searchObject->createSearch();
  308. }
  310. /**
  311. * Combines indices to the search request path.
  312. */
  313. public function getPath(): string
  314. {
  315. if (isset($this->_options[self::OPTION_SCROLL_ID])) {
  316. return '_search/scroll';
  317. }
  319. return \implode(',', $this->getIndices()).'/_search';
  320. }
  322. /**
  323. * Search in the set indices.
  324. *
  325. * @param AbstractQuery|AbstractSuggest|array|Collapse|Query|string|Suggest|null $query
  326. * @phpstan-param TCreateQueryArgs $query
  327. *
  328. * @param array|int $options Limit or associative array of options (option=>value)
  329. *
  330. * @throws InvalidException
  331. * @throws ClientException
  332. * @throws ConnectionException
  333. * @throws ResponseException
  334. */
  335. public function search($query = '', $options = null, string $method = Request::POST): ResultSet
  336. {
  337. $this->setOptionsAndQuery($options, $query);
  339. $query = $this->getQuery();
  340. $path = $this->getPath();
  342. $params = $this->getOptions();
  344. // Send scroll_id via raw HTTP body to handle cases of very large (> 4kb) ids.
  345. if ('_search/scroll' === $path) {
  346. $data = [self::OPTION_SCROLL_ID => $params[self::OPTION_SCROLL_ID]];
  347. unset($params[self::OPTION_SCROLL_ID]);
  348. } else {
  349. $data = $query->toArray();
  350. }
  352. $response = $this->getClient()->request($path, $method, $data, $params);
  354. return $this->builder->buildResultSet($response, $query);
  355. }
  357. /**
  358. * @param array|Query|Query\AbstractQuery|string $query
  359. * @param bool $fullResult By default only the total hit count is returned. If set to true, the full ResultSet including aggregations is returned
  360. *
  361. * @throws ClientException
  362. * @throws ConnectionException
  363. * @throws ResponseException
  364. *
  365. * @return int|ResultSet
  366. */
  367. public function count($query = '', bool $fullResult = false, string $method = Request::POST)
  368. {
  369. $this->setOptionsAndQuery(null, $query);
  371. // Clone the object as we do not want to modify the original query.
  372. $query = clone $this->getQuery();
  373. $query->setSize(0);
  374. $query->setTrackTotalHits(true);
  376. $path = $this->getPath();
  378. $response = $this->getClient()->request(
  379. $path,
  380. $method,
  381. $query->toArray(),
  382. [self::OPTION_SEARCH_TYPE => self::OPTION_SEARCH_TYPE_QUERY_THEN_FETCH]
  383. );
  384. $resultSet = $this->builder->buildResultSet($response, $query);
  386. return $fullResult ? $resultSet : $resultSet->getTotalHits();
  387. }
  389. /**
  390. * @param array|int $options
  391. * @param AbstractQuery|AbstractSuggest|array|Collapse|Query|string|Suggest|null $query
  392. * @phpstan-param TCreateQueryArgs $query
  393. */
  394. public function setOptionsAndQuery($options = null, $query = ''): self
  395. {
  396. if ('' !== $query) {
  397. $this->setQuery($query);
  398. }
  400. if (\is_int($options)) {
  401. \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__);
  402. $this->getQuery()->setSize($options);
  403. } elseif (\is_array($options)) {
  404. if (isset($options['limit'])) {
  405. $this->getQuery()->setSize($options['limit']);
  406. unset($options['limit']);
  407. }
  408. if (isset($options['explain'])) {
  409. $this->getQuery()->setExplain($options['explain']);
  410. unset($options['explain']);
  411. }
  412. $this->setOptions($options);
  413. }
  415. return $this;
  416. }
  418. public function setSuggest(Suggest $suggest): self
  419. {
  420. return $this->setOptionsAndQuery([self::OPTION_SEARCH_TYPE_SUGGEST => 'suggest'], $suggest);
  421. }
  423. /**
  424. * Returns the Scroll Iterator.
  425. *
  426. * @see Scroll
  427. */
  428. public function scroll(string $expiryTime = '1m'): Scroll
  429. {
  430. return new Scroll($this, $expiryTime);
  431. }
  433. public function getResultSetBuilder(): BuilderInterface
  434. {
  435. return $this->builder;
  436. }
  438. /**
  439. * @throws InvalidException If the given key is not a valid option
  440. */
  441. protected function validateOption(string $key): void
  442. {
  443. switch ($key) {
  444. case self::OPTION_SEARCH_TYPE:
  445. case self::OPTION_ROUTING:
  446. case self::OPTION_PREFERENCE:
  447. case self::OPTION_VERSION:
  448. case self::OPTION_TIMEOUT:
  449. case self::OPTION_FROM:
  450. case self::OPTION_SIZE:
  451. case self::OPTION_SCROLL:
  452. case self::OPTION_SCROLL_ID:
  453. case self::OPTION_SEARCH_TYPE_SUGGEST:
  454. case self::OPTION_SEARCH_IGNORE_UNAVAILABLE:
  455. case self::OPTION_QUERY_CACHE:
  456. case self::OPTION_TERMINATE_AFTER:
  457. case self::OPTION_SHARD_REQUEST_CACHE:
  458. case self::OPTION_FILTER_PATH:
  459. case self::OPTION_TYPED_KEYS:
  460. return;
  461. }
  463. throw new InvalidException('Invalid option '.$key);
  464. }
  465. }