PHP Search::addIndex方法代码示例

 /**
  * Run a search.
  *
  * @param Query $q
  * @return ResultSet
  */
 protected function doSearch(Query $q)
 {
     $search = new Search($this->client);
     $search->addIndex('bash')->addType('bash');
     $search->setQuery($q);
     return $search->search();
 }

 /**
  * @group functional
  */
 public function testShouldReturnTheRightNumberOfResult()
 {
     $filter = new Nested();
     $this->assertEquals(array('nested' => array()), $filter->toArray());
     $query = new Terms();
     $query->setTerms('hobby', array('guitar'));
     $filter->setPath('hobbies');
     $filter->setFilter($query);
     $client = $this->_getClient();
     $search = new Search($client);
     $index = $this->_getIndexForTest();
     $search->addIndex($index);
     $resultSet = $search->search($filter);
     $this->assertEquals(1, $resultSet->getTotalHits());
     $filter = new Nested();
     $this->assertEquals(array('nested' => array()), $filter->toArray());
     $query = new Terms();
     $query->setTerms('hobby', array('opensource'));
     $filter->setPath('hobbies');
     $filter->setFilter($query);
     $client = $this->_getClient();
     $search = new Search($client);
     $index = $this->_getIndexForTest();
     $search->addIndex($index);
     $resultSet = $search->search($filter);
     $this->assertEquals(2, $resultSet->getTotalHits());
 }

 /**
  * Reindex documents from an old index to a new index.
  *
  * @link https://www.elastic.co/guide/en/elasticsearch/guide/master/reindex.html
  *
  * @param \Elastica\Index $oldIndex
  * @param \Elastica\Index $newIndex
  * @param array           $options  keys: CrossIndex::OPTION_* constants
  *
  * @return \Elastica\Index The new index object
  */
 public static function reindex(Index $oldIndex, Index $newIndex, array $options = array())
 {
     // prepare search
     $search = new Search($oldIndex->getClient());
     $options = array_merge(array(self::OPTION_TYPE => null, self::OPTION_QUERY => new MatchAll(), self::OPTION_EXPIRY_TIME => '1m', self::OPTION_SIZE_PER_SHARD => 1000), $options);
     $search->addIndex($oldIndex);
     if (isset($options[self::OPTION_TYPE])) {
         $type = $options[self::OPTION_TYPE];
         $search->addTypes(is_array($type) ? $type : array($type));
     }
     $search->setQuery($options[self::OPTION_QUERY]);
     // search on old index and bulk insert in new index
     $scanAndScroll = new ScanAndScroll($search, $options[self::OPTION_EXPIRY_TIME], $options[self::OPTION_SIZE_PER_SHARD]);
     foreach ($scanAndScroll as $resultSet) {
         $bulk = new Bulk($newIndex->getClient());
         $bulk->setIndex($newIndex);
         foreach ($resultSet as $result) {
             $action = new Bulk\Action();
             $action->setType($result->getType());
             $action->setId($result->getId());
             $action->setSource($result->getData());
             $bulk->addAction($action);
         }
         $bulk->send();
     }
     $newIndex->refresh();
     return $newIndex;
 }

 /**
  * @return \Elastica\ResultSet
  */
 public function getSearchResult()
 {
     $index = $this->search->getIndex($this->getIndexName() . '_' . $this->language);
     $search = new Search($this->search->getClient());
     $search->addIndex($index);
     $search->addType($index->getType($this->indexType));
     $result = $search->search($this->query);
     return $result;
 }

 protected function searchDocuments()
 {
     dump(__METHOD__);
     $client = $this->getClient();
     $index = $client->getIndex($this->getIndexName());
     $type = $index->getType($this->getTypeName());
     if (true) {
         $query = json_decode('{"query":{"bool":{"must":[{"term":{"uid":19246}},{"term":{"name":"XXXXXXXXXX"}},{"term":{"op":30}}],"filter":[{"range":{"level":{"from":10,"to":300}}},{"range":{"addtime":{"gte":"20150706T145200+0800","lte":"20150707T145203+0800"}}}]}}}', true);
         dump($query);
         $path = $index->getName() . '/' . $type->getName() . '/_search';
         $response = $client->request($path, Request::GET, $query);
         $this->assertTrue($response->isOk());
         //            dump($response->getEngineTime());
         //            dump($response->getQueryTime());
         //            dump($response->getShardsStatistics());
         //            dump($response->getStatus()); // http status code
         //            dump($response->getTransferInfo());
         dump($response->getData()['hits']['hits']);
     }
     if (false) {
         $search = new Search($client);
         $search->addIndex($index)->addType($type);
         $query = new Query\BoolQuery();
         //        $query->setFrom(0);
         //        $query->setSize(10);
         //        $query->setSort(['uid' => 'asc']);
         //        $query->setFields(['snsid', 'uid']);
         //        $query->setHighlight(['fields' => 'uid']);
         //        $query->setExplain(true);
         //        $term = new Query\Term(['name' => 'XXXXXXXXXX']);
         //        $query->setQuery($term);
         $query->addMust(new Term(['uid' => 19246]));
         $query->addMust(new Term(['name' => 'XXXXXXXXXX']));
         $query->addMust(new Term(['op' => 30]));
         //        $query->addMustNot(new Term(['country' => 'CN']));
         $range = new Query\Range('level', ['from' => 10, 'to' => 300]);
         $query->addFilter($range);
         $range = new Query\Range();
         $range->addField('addtime', ['gte' => '20150706T145200+0800', 'lte' => '20150707T145203+0800']);
         $query->addFilter($range);
         $search->setQuery($query);
         $resultSet = $search->search();
         dump('Hit: ' . $resultSet->count());
         $queryArray = $resultSet->getQuery()->toArray();
         dump(json_encode($queryArray));
         dump($resultSet->getResponse()->getData()['hits']['hits']);
         dump('query time: ' . \PHP_Timer::secondsToTimeString($resultSet->getResponse()->getQueryTime()));
     }
 }

 /**
  * index: 12 docs, 2 shards.
  *
  * @return Search
  */
 private function _prepareSearch()
 {
     $index = $this->_createIndex('', true, 2);
     $index->refresh();
     $docs = array();
     for ($x = 1; $x <= 12; $x++) {
         $docs[] = new Document($x, array('id' => $x, 'key' => 'value'));
     }
     $type = $index->getType('scanAndScrollTest');
     $type->addDocuments($docs);
     $index->refresh();
     $search = new Search($this->_getClient());
     $search->addIndex($index)->addType($type);
     return $search;
 }

 /**
  * Perform the show action for a block
  *
  * @param ReadBlockInterface $block
  *
  * @return Response
  */
 public function show(ReadBlockInterface $block)
 {
     $request = $this->requestStack->getCurrentRequest();
     $data = $request->get('elastica_search');
     $searchData = array();
     if (is_array($data) && array_key_exists('search', $data) && null !== $data['search']) {
         $searchParameter = $data['search'];
         $index = $this->client->getIndex($this->indexName);
         $qb = new QueryBuilder();
         $search = new Search($this->client);
         $search->addIndex($index);
         $search->setQuery($qb->query()->filtered($qb->query()->query_string($searchParameter), $qb->filter()->bool()->addMust($qb->filter()->term(array('language' => $request->getLocale())))));
         $searchData = $search->search(null, array('limit' => $block->getAttribute('searchLimit')));
     }
     return $this->render('OpenOrchestraElasticaFrontBundle:Block/List:show.html.twig', array('searchData' => $searchData));
 }

 /**
  * Get Query Count
  *
  * @param string $index        	
  * @param string $type        	
  *
  * @return number
  */
 public function getElasticaCount($index = false, $type = false)
 {
     $elastica_query = new Query();
     $elastica_client = $this->getElasticaClient();
     // If you want to restrict your search to a particular index then get
     // that
     $elastica_index = $index ? $elastica_client->getIndex($index) : false;
     // If you want to restrict your search to a particular type then get
     // that
     $elastica_type = $elastica_index && $type ? $elastica_index->getType($type) : false;
     $elastica_search = new Search($elastica_client);
     if ($elastica_index) {
         $elastica_search->addIndex($elastica_index);
     }
     if ($elastica_type) {
         $elastica_search->addType($elastica_type);
     }
     return $elastica_search->count($elastica_query);
 }

 public function searchAction()
 {
     //WIP, todo: export to repository and use it in Search Playlists
     $elasticaClient = new Client();
     $playListIndex = $elasticaClient->getIndex('playlist');
     $trackType = $playListIndex->getType('track');
     $search = new Search($elasticaClient);
     $search->addIndex($playListIndex)->addType($trackType);
     $query = new Query();
     $query->setSize(5)->setSort(['name' => 'asc'])->setFields(['name', 'ids', 'id', 'composer'])->setExplain(true)->setVersion(true)->setHighlight(['fields' => 'composer']);
     $query->setQuery(new MatchAll());
     //        $query->addAggregation(new \Elastica\Aggregation\Range('name'));
     //        $term = new \Elastica\Suggest\Term('name', 'field');
     //        $term->setText('aaaaa');
     //        $query->setSuggest(new \Elastica\Suggest($term));
     //        $query->setFacets([new \Elastica\Facet\Range('name')]);
     $search->setQuery($query);
     $resultSet = $search->search();
     $numberOfEntries = $search->count();
     $results = $resultSet->getResults();
     $totalResults = $resultSet->getTotalHits();
     return $this->render('PlayWithElasticSearchBundle:Elastica:search.html.twig', ['query' => $query, 'numberOfEntries' => $numberOfEntries, 'resultSet' => $resultSet, 'results' => $results, 'totalResults' => $totalResults]);
 }

 public function readData($source_definition, $rest_parameters = [])
 {
     Pager::setDefaultLimit(500);
     list($limit, $offset) = Pager::calculateLimitAndOffset();
     $client = new Client(['host' => $source_definition['host'], 'port' => $source_definition['port'], 'username' => $source_definition['username'], 'password' => $source_definition['password']]);
     $index = $client->getIndex($source_definition['es_index']);
     $type = $index->getType($source_definition['es_type']);
     $search = new Search($client);
     $search->addIndex($index);
     $search->addType($type);
     $query_param = \Input::get('query');
     if (empty($query_param)) {
         $query = new MatchAll();
         $search->setQuery($query);
     } else {
         $query = new SimpleQueryString($query_param);
         $search->setQuery($query);
     }
     $search->getQuery()->setFrom($offset);
     $search->getQuery()->setSize($limit);
     $resultSet = $search->search();
     $data = new Data();
     $data_results = [];
     foreach ($resultSet->getResults() as $result) {
         $data_result = $result->getData();
         unset($data_result['__tdt_etl_timestamp__']);
         $data_results[] = $data_result;
     }
     $data->data = $data_results;
     if ($resultSet->getTotalHits() > 0) {
         $paging = Pager::calculatePagingHeaders($limit, $offset, $resultSet->getTotalHits());
         $data->paging = $paging;
     }
     $data->preferred_formats = $this->getPreferredFormats();
     return $data;
 }

 /**
  * @group functional
  */
 public function testGlobalSearchTypeSearchWithKeys()
 {
     $type = $this->_createType();
     $index = $type->getIndex();
     $client = $index->getClient();
     $multiSearch = new MultiSearch($client);
     $search1 = new Search($client);
     $search1->addIndex($index)->addType($type);
     $query1 = new Query();
     $termQuery1 = new Term();
     $termQuery1->setTerm('username', 'farrelley');
     $query1->setQuery($termQuery1);
     $query1->setSize(2);
     $search1->setQuery($query1);
     $multiSearch->addSearch($search1);
     $this->assertCount(1, $multiSearch->getSearches());
     $search2 = new Search($client);
     $search2->addIndex($index)->addType($type);
     $query2 = new Query();
     $termQuery2 = new Term();
     $termQuery2->setTerm('username', 'bunny');
     $query2->setQuery($termQuery2);
     $query2->setSize(3);
     $search2->setQuery($query2);
     $multiSearch->addSearch($search2);
     $multiSearch->setSearchType(Search::OPTION_SEARCH_TYPE_COUNT);
     $multiResultSet = $multiSearch->search();
     $this->assertInstanceOf('Elastica\\Multi\\ResultSet', $multiResultSet);
     $this->assertCount(2, $multiResultSet);
     $this->assertInstanceOf('Elastica\\Response', $multiResultSet->getResponse());
     $resultSets = $multiResultSet->getResultSets();
     $this->assertInternalType('array', $resultSets);
     $this->assertArrayHasKey(0, $resultSets);
     $this->assertInstanceOf('Elastica\\ResultSet', $resultSets[0]);
     $this->assertCount(0, $resultSets[0]);
     $this->assertSame($query1, $resultSets[0]->getQuery());
     $this->assertEquals(3, $resultSets[0]->getTotalHits());
     $this->assertArrayHasKey(1, $resultSets);
     $this->assertInstanceOf('Elastica\\ResultSet', $resultSets[1]);
     $this->assertCount(0, $resultSets[1]);
     $this->assertSame($query2, $resultSets[1]->getQuery());
     $this->assertEquals(6, $resultSets[1]->getTotalHits());
     $search1->setOption(Search::OPTION_SEARCH_TYPE, Search::OPTION_SEARCH_TYPE_QUERY_AND_FETCH);
     $multiResultSet = $multiSearch->search();
     $this->assertInstanceOf('Elastica\\Multi\\ResultSet', $multiResultSet);
     $this->assertCount(2, $multiResultSet);
     $this->assertInstanceOf('Elastica\\Response', $multiResultSet->getResponse());
     $resultSets = $multiResultSet->getResultSets();
     $this->assertInternalType('array', $resultSets);
     $this->assertArrayHasKey(0, $resultSets);
     $this->assertInstanceOf('Elastica\\ResultSet', $resultSets[0]);
     $this->assertCount(2, $resultSets[0]);
     $this->assertSame($query1, $resultSets[0]->getQuery());
     $this->assertEquals(3, $resultSets[0]->getTotalHits());
     $this->assertArrayHasKey(1, $resultSets);
     $this->assertInstanceOf('Elastica\\ResultSet', $resultSets[1]);
     $this->assertCount(0, $resultSets[1]);
     $this->assertSame($query2, $resultSets[1]->getQuery());
     $this->assertEquals(6, $resultSets[1]->getTotalHits());
 }

 /**
  * @return ScanAndScroll
  */
 protected function getScanAndScroll()
 {
     $search = new Search($this->client);
     $search->addIndex($this->elasticaIndex);
     // type не обязателен, бэкапить можно весь индекс со всеми типами
     if ($this->typeName) {
         $search->addType($this->elasticaType);
     }
     $scanAndScroll = new ScanAndScroll($search);
     $scanAndScroll->sizePerShard = $this->sizePerShard;
     $scanAndScroll->expiryTime = $this->expiryTime;
     return $scanAndScroll;
 }

 /**
  * Invoke Elasticsearch count.
  *
  * @param Query  $query
  * @param string $index
  * @param string $type
  * @param array  $options
  *
  * @return \Elastica\ResultSet
  */
 public function count($query, $type, $index = 'activehire', $options = [])
 {
     $search = new Search($this->client);
     $search->addType($type);
     $search->addIndex($index);
     $search->setOptions($options);
     $result = $search->count($query);
     return $result;
 }

 /**
  * @group functional
  */
 public function testQueryCacheOption()
 {
     $client = $this->_getClient();
     $index = $client->getIndex('zero');
     $index->create(array('index' => array('number_of_shards' => 1, 'number_of_replicas' => 0)), true);
     $type = $index->getType('zeroType');
     $type->addDocuments(array(new Document(1, array('id' => 1, 'username' => 'farrelley')), new Document(2, array('id' => 2, 'username' => 'bunny'))));
     $index->refresh();
     $aggregation = new Aggregation\Terms('username');
     $aggregation->setField('username');
     $query = new Query();
     $query->addAggregation($aggregation);
     $search = new Search($client);
     $search->addIndex($index);
     $search->setQuery($query);
     $search->setOption(Search::OPTION_SEARCH_TYPE, Search::OPTION_SEARCH_TYPE_COUNT);
     $search->setOption(Search::OPTION_QUERY_CACHE, true);
     // before search query cache should be empty
     $statsData = $index->getStats()->getData();
     $queryCache = $statsData['_all']['primaries']['query_cache'];
     $this->assertEquals(0, $queryCache['memory_size_in_bytes']);
     $this->assertEquals(0, $queryCache['evictions']);
     $this->assertEquals(0, $queryCache['hit_count']);
     $this->assertEquals(0, $queryCache['miss_count']);
     // first search should result in cache miss and save data to cache
     $search->search();
     $index->getStats()->refresh();
     $statsData = $index->getStats()->getData();
     $queryCache = $statsData['_all']['primaries']['query_cache'];
     $this->assertNotEquals(0, $queryCache['memory_size_in_bytes']);
     $this->assertEquals(0, $queryCache['evictions']);
     $this->assertEquals(0, $queryCache['hit_count']);
     $this->assertEquals(1, $queryCache['miss_count']);
     // next search should result in cache hit
     $search->search();
     $index->getStats()->refresh();
     $statsData = $index->getStats()->getData();
     $queryCache = $statsData['_all']['primaries']['query_cache'];
     $this->assertNotEquals(0, $queryCache['memory_size_in_bytes']);
     $this->assertEquals(0, $queryCache['evictions']);
     $this->assertEquals(1, $queryCache['hit_count']);
     $this->assertEquals(1, $queryCache['miss_count']);
 }

 protected function buildQuery(array $classes)
 {
     $searchQuery = new Search($this->client);
     $searchQuery->setOption(Search::OPTION_VERSION, true);
     foreach ($classes as $class) {
         if ($class->index) {
             $indexObject = $this->getIndex($class->index);
             $searchQuery->addIndex($indexObject);
             if ($class->type) {
                 $searchQuery->addType($indexObject->getType($class->type));
             }
         }
     }
     return $searchQuery;
 }