Sets the query.
| public setQuery ( Elastica\Query\AbstractQuery $query ) | ||
| $query | Elastica\Query\AbstractQuery | Query object |
/**
* @return Query
*/
public function getESQuery()
{
if (!$this->esQuery) {
$this->esQuery = new Query();
$this->boolQuery = new Query\BoolQuery();
$this->esQuery->setQuery($this->boolQuery);
$familyQuery = new Query\Match('family', implode(' ', $this->family->getMatchingCodes()));
$this->boolQuery->addMust($familyQuery);
}
return $this->esQuery;
}
public function testTest()
{
$client = $this->_getClient();
$index = $client->getIndex('test');
$index->create(array(), true);
$type = $index->getType('helloworld');
$mapping = new Mapping($type, array('name' => array('type' => 'string', 'store' => 'no'), 'dtmPosted' => array('type' => 'date', 'store' => 'no', 'format' => 'yyyy-MM-dd HH:mm:ss')));
$type->setMapping($mapping);
$doc = new Document(1, array('name' => 'nicolas ruflin', 'dtmPosted' => "2011-06-23 21:53:00"));
$type->addDocument($doc);
$doc = new Document(2, array('name' => 'raul martinez jr', 'dtmPosted' => "2011-06-23 09:53:00"));
$type->addDocument($doc);
$doc = new Document(3, array('name' => 'rachelle clemente', 'dtmPosted' => "2011-07-08 08:53:00"));
$type->addDocument($doc);
$doc = new Document(4, array('name' => 'elastica search', 'dtmPosted' => "2011-07-08 01:53:00"));
$type->addDocument($doc);
$facet = new DateHistogram('dateHist1');
$facet->setInterval("day");
$facet->setField("dtmPosted");
$query = new Query();
$query->addFacet($facet);
$query->setQuery(new MatchAll());
$index->refresh();
$response = $type->search($query);
$facets = $response->getFacets();
$this->assertEquals(4, $response->getTotalHits());
$this->assertEquals(2, count($facets['dateHist1']['entries']));
}
/**
* @group functional
*/
public function testFactor()
{
$client = $this->_getClient();
$index = $client->getIndex('test');
$index->create(array(), true);
$type = $index->getType('helloworld');
$mapping = new Mapping($type, array('name' => array('type' => 'string', 'store' => 'no'), 'dtmPosted' => array('type' => 'long', 'store' => 'no')));
$type->setMapping($mapping);
$doc = new Document(1, array('name' => 'nicolas ruflin', 'dtmPosted' => 1308865980));
$type->addDocument($doc);
$doc = new Document(2, array('name' => 'raul martinez jr', 'dtmPosted' => 1308822780));
$type->addDocument($doc);
$doc = new Document(3, array('name' => 'rachelle clemente', 'dtmPosted' => 1310115180));
$type->addDocument($doc);
$doc = new Document(4, array('name' => 'elastica search', 'dtmPosted' => 1310089980));
$type->addDocument($doc);
$facet = new DateHistogram('dateHist1');
$facet->setInterval('day');
$facet->setField('dtmPosted');
$facet->setFactor(1000);
$query = new Query();
$query->addFacet($facet);
$query->setQuery(new MatchAll());
$index->refresh();
$response = $type->search($query);
$facets = $response->getFacets();
$this->assertEquals(4, $response->getTotalHits());
$this->assertEquals(2, count($facets['dateHist1']['entries']));
}
/**
* @inheritDoc
*/
public function applyQueries($query, $alias = null, string $column = null, string $sort = null, array $ids = [], array $order = [])
{
if (!$query instanceof Filtered) {
throw new \InvalidArgumentException('Expected argument of type "Elastica\\Query\\Filtered", ' . get_class($query) . ' given');
}
if (!empty($ids)) {
/** @var BoolFilter $filter */
$filter = $query->getFilter();
$idsFilter = new Terms();
$idsFilter->setTerms('id', $ids);
$filter->addMust($idsFilter);
$query->setFilter($filter);
}
$newQuery = new Query();
$newQuery->setQuery($query);
$query = $newQuery;
unset($newQuery);
if ($column !== null && $sort !== null) {
$query->addSort([$column => ['order' => strtolower($sort)]]);
}
unset($sort);
if (!empty($order)) {
foreach ($order as $sort => $o) {
if ($column !== $sort) {
$query->addSort([$sort => ['order' => strtolower($o)]]);
}
}
}
return $query;
}
/**
* @group functional
*/
public function testSearch()
{
$client = $this->_getClient();
$index = new Index($client, 'test');
$index->create(array(), true);
$index->getSettings()->setNumberOfReplicas(0);
//$index->getSettings()->setNumberOfShards(1);
$type = new Type($index, 'helloworldmlt');
$mapping = new Mapping($type, array('email' => array('store' => 'yes', 'type' => 'string', 'index' => 'analyzed'), 'content' => array('store' => 'yes', 'type' => 'string', 'index' => 'analyzed')));
$mapping->setSource(array('enabled' => false));
$type->setMapping($mapping);
$doc = new Document(1000, array('email' => '*****@*****.**', 'content' => 'This is a sample post. Hello World Fuzzy Like This!'));
$type->addDocument($doc);
$doc = new Document(1001, array('email' => '*****@*****.**', 'content' => 'This is a fake nospam email address for gmail'));
$type->addDocument($doc);
// Refresh index
$index->refresh();
$mltQuery = new MoreLikeThis();
$mltQuery->setLike('fake gmail sample');
$mltQuery->setFields(array('email', 'content'));
$mltQuery->setMaxQueryTerms(3);
$mltQuery->setMinDocFrequency(1);
$mltQuery->setMinTermFrequency(1);
$query = new Query();
$query->setQuery($mltQuery);
$resultSet = $type->search($query);
$resultSet->getResponse()->getData();
$this->assertEquals(2, $resultSet->count());
}
public function testResponse()
{
$index = $this->_createIndex();
$type = $index->getType('helloworld');
$mapping = new Mapping($type, array('name' => array('type' => 'string', 'store' => 'no'), 'dtmPosted' => array('type' => 'date', 'store' => 'no', 'format' => 'yyyy-MM-dd HH:mm:ss')));
$type->setMapping($mapping);
$doc = new Document(1, array('name' => 'nicolas ruflin', 'dtmPosted' => "2011-06-23 21:53:00"));
$type->addDocument($doc);
$doc = new Document(2, array('name' => 'raul martinez jr', 'dtmPosted' => "2011-06-23 09:53:00"));
$type->addDocument($doc);
$doc = new Document(3, array('name' => 'rachelle clemente', 'dtmPosted' => "2011-07-08 08:53:00"));
$type->addDocument($doc);
$doc = new Document(4, array('name' => 'elastica search', 'dtmPosted' => "2011-07-08 01:53:00"));
$type->addDocument($doc);
$query = new Query();
$query->setQuery(new MatchAll());
$index->refresh();
$resultSet = $type->search($query);
$engineTime = $resultSet->getResponse()->getEngineTime();
$shardsStats = $resultSet->getResponse()->getShardsStatistics();
$this->assertInternalType('int', $engineTime);
$this->assertTrue(is_array($shardsStats));
$this->assertArrayHasKey('total', $shardsStats);
$this->assertArrayHasKey('successful', $shardsStats);
}
/**
* @param string $search
* @return ResultSet
*/
public function search($search)
{
$query = new Query();
$query->setQuery($this->getBoolQuery($search));
$query = $this->searchManager->createQuery()->searchWith($query)->hydrateWith($this->getHydrateQuery())->setMaxResults(50);
$this->onSearch($search, $query);
return $query->getResult();
}
/**
* Remove all outdated documents in the index of the configured type
*
* @return void
*/
public function cleanUp()
{
$dateRange = new Range();
$dateRange->addField(self::$ETL_TIMESTAMP, array('lt' => $this->timestamp));
$query = new Query();
$query->setQuery($dateRange);
$this->type->deleteByQuery($query);
$this->log("Removed outdated documents that were outdated.");
}
/**
* @param Request $request
* @param int $page
* @return \Symfony\Component\HttpFoundation\Response
*/
public function indexAction(Request $request, $page = 1)
{
$getRoles = $request->query->get('role_filters');
$getSubjects = $request->query->get('subject_filters');
$getJournals = $request->query->get('journal_filters');
$roleFilters = !empty($getRoles) ? explode(',', $getRoles) : [];
$subjectFilters = !empty($getSubjects) ? explode(',', $getSubjects) : [];
$journalFilters = !empty($getJournals) ? explode(',', $getJournals) : [];
$userSearcher = $this->get('fos_elastica.index.search.user');
$userQuery = new Query('*');
if (!empty($roleFilters) || !empty($subjectFilters) || !empty($journalFilters)) {
$boolQuery = new Query\Bool();
foreach ($roleFilters as $role) {
$match = new Query\Match();
$match->setField('journalUsers.roles', $role);
$boolQuery->addMust($match);
}
foreach ($subjectFilters as $subject) {
$match = new Query\Match();
$match->setField('subjects', $subject);
$boolQuery->addMust($match);
}
foreach ($journalFilters as $journal) {
$match = new Query\Match();
$match->setField('journalUsers.journal.title', $journal);
$boolQuery->addMust($match);
}
$userQuery->setQuery($boolQuery);
}
$roleAgg = new Aggregation\Terms('roles');
$roleAgg->setField('journalUsers.roles');
$roleAgg->setOrder('_term', 'asc');
$roleAgg->setSize(0);
$userQuery->addAggregation($roleAgg);
$subjectAgg = new Aggregation\Terms('subjects');
$subjectAgg->setField('subjects');
$subjectAgg->setOrder('_term', 'asc');
$subjectAgg->setSize(0);
$userQuery->addAggregation($subjectAgg);
$journalAgg = new Aggregation\Terms('journals');
$journalAgg->setField('journalUsers.journal.title');
$journalAgg->setOrder('_term', 'asc');
$journalAgg->setSize(0);
$userQuery->addAggregation($journalAgg);
$adapter = new ElasticaAdapter($userSearcher, $userQuery);
$pagerfanta = new Pagerfanta($adapter);
$pagerfanta->setMaxPerPage(20);
$pagerfanta->setCurrentPage($page);
$people = $pagerfanta->getCurrentPageResults();
$roles = $adapter->getResultSet()->getAggregation('roles')['buckets'];
$subjects = $adapter->getResultSet()->getAggregation('subjects')['buckets'];
$journals = $adapter->getResultSet()->getAggregation('journals')['buckets'];
$data = ['people' => $people, 'roles' => $roles, 'subjects' => $subjects, 'journals' => $journals, 'pagerfanta' => $pagerfanta, 'role_filters' => $roleFilters, 'subject_filters' => $subjectFilters, 'journal_filters' => $journalFilters, 'page' => 'ojs_site_people_index'];
return $this->render('OjsSiteBundle:People:index.html.twig', $data);
}
/**
* @param \Elastica\Query $baseQuery
*
* @return \Elastica\Query
*/
protected function addFulltextSearchToQuery(Query $baseQuery)
{
if (!empty($this->searchString)) {
$matchQuery = $this->createFulltextSearchQuery($this->searchString);
} else {
$matchQuery = new MatchAll();
}
$boolQuery = (new BoolQuery())->addMust($matchQuery);
$baseQuery->setQuery($boolQuery);
return $baseQuery;
}
/**
* @param $keyword
* @return \Elastica\ResultSet
*/
public function search($keyword)
{
$query = new Query();
$query->setSize(1000);
$fuzzyQuery = new Query\FuzzyLikeThis();
$fuzzyQuery->setLikeText($keyword);
$fuzzyQuery->setMinSimilarity(0.7);
$query->setQuery($fuzzyQuery);
$results = $this->search->search($query);
return $results;
}
/**
* @group functional
*/
public function testQuery()
{
$query = new Query();
$match = new Match();
$match->setField('make', 'ford');
$query->setQuery($match);
$filter = new Term();
$filter->setTerm('color', 'green');
$query->setPostFilter($filter);
$results = $this->_getTestIndex()->search($query);
$this->assertEquals(1, $results->getTotalHits());
}
/**
* @inheritdoc
*/
public function findPaginatedByQueryAndCategory(\string $queryString = null, \string $category = null, \int $priceFrom = null, \int $priceTo = null, \bool $availability = null)
{
$queryObject = new Query();
$filter = new BoolAnd();
if ($queryString) {
$query = new Match('_all', ['query' => $queryString, 'operator' => 'AND']);
} else {
$query = new Query\MatchAll();
}
if ($availability !== null) {
$filter->addFilter(new Term(['availability' => $availability]));
}
$range = [];
if ($priceFrom) {
$range['gte'] = $priceFrom;
}
if ($priceTo) {
$range['lte'] = $priceTo;
}
if ($range) {
$filter->addFilter(new Range('price', $range));
}
if ($category) {
$term = new Term(['category.id' => $category]);
$queryObject->setPostFilter($term);
}
$terms = new Terms('categories');
$terms->setField('category.id');
$terms->setSize(0);
$queryObject->addAggregation($terms);
if ($filter->getFilters()) {
$filtered = new Query\Filtered($query, $filter);
$queryObject->setQuery($filtered);
} else {
$queryObject->setQuery($query);
}
$queryObject->setSort(['updated' => 'desc']);
$queryObject->setMinScore(0.5);
return $this->findPaginated($queryObject);
}
/**
* Search revisions with provided term.
*
* @param string $term Term to search
* @return Status
*/
public function searchText($term)
{
// full-text search
$queryString = new QueryString($term);
$queryString->setFields(array('revisions.text'));
$this->query->setQuery($queryString);
// add aggregation to determine exact amount of matching search terms
$terms = $this->getTerms($term);
$this->query->addAggregation($this->termsAggregation($terms));
// @todo: abstract-away this config? (core/cirrus also has this - share it somehow?)
$this->query->setHighlight(array('fields' => array(static::HIGHLIGHT_FIELD => array('type' => 'plain', 'order' => 'score', 'number_of_fragments' => 1, 'fragment_size' => 10000)), 'pre_tags' => array(static::HIGHLIGHT_PRE), 'post_tags' => array(static::HIGHLIGHT_POST)));
// @todo: support insource: queries (and perhaps others)
$searchable = Connection::getFlowIndex($this->indexBaseName);
if ($this->type !== false) {
$searchable = $searchable->getType($this->type);
}
$search = $searchable->createSearch($this->query);
// @todo: PoolCounter config at PoolCounterSettings-eqiad.php
// @todo: do we want this class to extend from ElasticsearchIntermediary and use its success & failure methods (like CirrusSearch/Searcher does)?
// Perform the search
$work = new PoolCounterWorkViaCallback('Flow-Search', "_elasticsearch", array('doWork' => function () use($search) {
try {
$result = $search->search();
return Status::newGood($result);
} catch (ExceptionInterface $e) {
if (strpos($e->getMessage(), 'dynamic scripting for [groovy] disabled')) {
// known issue with default ES config, let's display a more helpful message
return Status::newFatal(new \RawMessage("Couldn't complete search: dynamic scripting needs to be enabled. " . "Please add 'script.disable_dynamic: false' to your elasticsearch.yml"));
}
return Status::newFatal('flow-error-search');
}
}, 'error' => function (Status $status) {
$status = $status->getErrorsArray();
wfLogWarning('Pool error searching Elasticsearch: ' . $status[0][0]);
return Status::newFatal('flow-error-search');
}));
$result = $work->execute();
return $result;
}
/**
* @param Search $search
* @return Result[]
*/
public function search(Search $search)
{
$bool = new Bool();
$match = new Match();
$match->setField('text', $search->getInput());
$bool->addMust($match);
$query = new Query();
$query->setQuery($bool);
$query->setHighlight(['pre_tags' => ['<mark>'], 'post_tags' => ['</mark>'], 'fields' => ['text' => ['highlight_query' => [$bool->toArray()]]]]);
$results = $this->getIndex()->search($query, 50)->getResults();
$this->onSearch($search, $results);
return $results;
}
/**
* @group functional
*/
public function testTypeInsideHasChildSearch()
{
$index = $this->_getTestIndex();
$f = new Match();
$f->setField('alt.name', 'testname');
$query = new HasChild($f, 'child');
$searchQuery = new Query();
$searchQuery->setQuery($query);
$searchResults = $index->search($searchQuery);
$this->assertEquals(1, $searchResults->count());
$result = $searchResults->current()->getData();
$expected = array('id' => 'parent2', 'user' => 'parent2', 'email' => '*****@*****.**');
$this->assertEquals($expected, $result);
}
/**
* @return \Elastica\Query\MatchAll|\Elastica\Query
*/
public function getSearchQuery()
{
$baseQuery = new Query();
if (!empty($this->searchString)) {
$query = $this->createFullTextSearchQuery($this->searchString);
} else {
$query = new MatchAll();
}
$baseQuery->setQuery($query);
$this->setLimit($baseQuery);
$this->setOffset($baseQuery);
$baseQuery->setExplain(true);
return $baseQuery;
}
/**
* @depends testAddDocument
* @dataProvider providerTransport
*/
public function testRandomRead(array $config, $transport)
{
$type = $this->getType($config);
$type->search('test');
$times = array();
for ($i = 0; $i < $this->_max; $i++) {
$test = rand(1, $this->_max);
$query = new Query();
$query->setQuery(new MatchAllQuery());
$query->setFilter(new TermFilter(array('test' => $test)));
$result = $type->search($query);
$times[] = $result->getResponse()->getQueryTime();
}
self::logResults('random read', $transport, $times);
}
/**
* @depends testAddDocument
* @dataProvider providerTransport
* @group benchmark
*/
public function testRandomRead(array $config, $transport)
{
$this->_checkTransport($config, $transport);
$type = $this->getType($config);
$type->search('test');
$times = array();
for ($i = 0; $i < $this->_max; ++$i) {
$test = rand(1, $this->_max);
$query = new Query();
$query->setQuery(new \Elastica\Query\MatchAll());
$query->setPostFilter(new \Elastica\Filter\Term(array('test' => $test)));
$result = $type->search($query);
$times[] = $result->getResponse()->getQueryTime();
}
self::logResults('random read', $transport, $times);
}
public function tagSearchAction(Request $request)
{
$q = $request->get('q');
$search = $this->container->get('fos_elastica.index.search');
$prefix = new Query\Prefix();
$prefix->setPrefix('tags', strtolower($q));
$qe = new Query();
$qe->setQuery($prefix);
$results = $search->search($prefix);
$data = [];
foreach ($results as $result) {
foreach (explode(',', $result->getData()['tags']) as $tag) {
$data[] = ['id' => $tag, 'text' => $tag];
}
}
return JsonResponse::create($data);
}
public function testQuery()
{
$query = new Query();
$mainQuery = new Match();
$mainQuery = $mainQuery->setFieldQuery('test1', 'foo');
$secQuery = new Term();
$secQuery = $secQuery->setTerm('test2', 'bar', 2);
$queryRescore = new QueryRescore($secQuery);
$queryRescore->setWindowSize(50);
$queryRescore->setQueryWeight(0.7);
$queryRescore->setRescoreQueryWeight(1.2);
$query->setQuery($mainQuery);
$query->setRescore($queryRescore);
$data = $query->toArray();
$results = $this->_index->search($query);
$response = $results->getResponse();
$this->assertEquals(true, $response->isOk());
$this->assertEquals(0, $results->getTotalHits());
}
/**
* @httpMethod GET
* @path /
*/
public function doIndex()
{
$url = new Url($this->base->getSelf());
$count = $url->getParam('count') > 0 ? $url->getParam('count') : 8;
$count = $count > 16 ? 16 : $count;
$search = $this->get->search('string');
if (!empty($search)) {
$search = strlen($search) > 64 ? substr($search, 0, 64) : $search;
$queryString = new QueryString();
//$queryString->setDefaultOperator('AND');
$queryString->setQuery($search);
$query = new Query();
$query->setQuery($queryString);
$query->setFrom($url->getParam('startIndex'));
$query->setLimit($count);
$query->setHighlight(array('pre_tags' => array('<mark>'), 'post_tags' => array('</mark>'), 'fields' => array('title' => new \stdClass(), 'content' => new \stdClass())));
// get elasticsearch client
$client = new Client(array('host' => $this->registry['search.host'], 'port' => $this->registry['search.port']));
$index = $client->getIndex('amun');
$searchResult = $index->search($query);
$result = new ResultSet($searchResult->getTotalHits(), $url->getParam('startIndex'), $count);
foreach ($searchResult as $row) {
$data = $row->getData();
$data['url'] = $this->config['psx_url'] . '/' . $this->config['psx_dispatch'] . $data['path'];
$data['date'] = new DateTime('@' . $data['date']);
// if we have an highlite overwrite the title or content
$highlights = $row->getHighlights();
if (isset($highlights['title'])) {
$data['title'] = implode(' ... ', $highlights['title']);
}
if (isset($highlights['content'])) {
$data['content'] = implode(' ... ', $highlights['content']);
}
$result->addData($data);
}
$this->template->assign('resultSearch', $result);
$paging = new Paging($url, $result);
$this->template->assign('pagingSearch', $paging, 0);
return $result;
}
}
/**
* @group functional
*/
public function testFacetScript()
{
$client = $this->_getClient();
$index = $client->getIndex('test');
$index->create(array(), true);
$type = $index->getType('helloworld');
$doc = new Document(1, array('name' => 'rodolfo', 'last_name' => 'moraes'));
$type->addDocument($doc);
$doc = new Document(2, array('name' => 'jose', 'last_name' => 'honjoya'));
$type->addDocument($doc);
$facet = new Terms('test');
$facet->setField('name');
$facet->setScript('term + " "+doc["last_name"].value');
$query = new Query();
$query->addFacet($facet);
$query->setQuery(new MatchAll());
$index->refresh();
$response = $type->search($query);
$facets = $response->getFacets();
$this->assertEquals(2, count($facets['test']['terms']));
}
public function testQuery()
{
$client = $this->_getClient();
$index = $client->getIndex('test');
$index->create(array(), true);
$type = $index->getType('helloworld');
$doc = new Document(1, array('name' => 'nicolas ruflin'));
$type->addDocument($doc);
$doc = new Document(2, array('name' => 'ruflin test'));
$type->addDocument($doc);
$doc = new Document(2, array('name' => 'nicolas helloworld'));
$type->addDocument($doc);
$facet = new Terms('test');
$facet->setField('name');
$query = new Query();
$query->addFacet($facet);
$query->setQuery(new MatchAll());
$index->refresh();
$response = $type->search($query);
$facets = $response->getFacets();
$this->assertEquals(3, count($facets['test']['terms']));
}
/**
* @return false|\Elastica\Query
* @throws ErrorException
*/
public function getQuery()
{
if ($this->validate() === false) {
return false;
}
$termsAgg = new Terms(self::GROUP_AGGREGATION_NAME);
$termsAgg->setField($this->group['by']);
$termsAgg->setSize(self::MAX_SIZE_AGGREGATION_ITEMS);
$filterBool = new Bool();
if ($this->condition) {
$this->addCondition($filterBool);
}
$this->addAggregation($termsAgg);
$queryFiltred = new \Elastica\Query\Filtered();
$queryFiltred->setFilter($filterBool);
$queryFiltred->setQuery(new \Elastica\Query\MatchAll());
$query = new Query();
// These are not needed only aggregation
$query->setSize(0);
$query->setQuery($queryFiltred);
$query->addAggregation($termsAgg);
return $query;
}
public function testQuery()
{
$client = $this->_getClient();
$index = new Index($client, 'test');
$index->create(array(), true);
$type = new Type($index, 'multi_match');
$doc = new Document(1, array('id' => 1, 'name' => 'Rodolfo', 'last_name' => 'Moraes'));
$type->addDocument($doc);
// Refresh index
$index->refresh();
$multiMatch = new MultiMatch();
$query = new Query();
$multiMatch->setQuery('Rodolfo');
$multiMatch->setFields(array('name', 'last_name'));
$query->setQuery($multiMatch);
$resultSet = $index->search($query);
$this->assertEquals(1, $resultSet->count());
$multiMatch->setQuery('Moraes');
$multiMatch->setFields(array('name', 'last_name'));
$query->setQuery($multiMatch);
$resultSet = $index->search($query);
$this->assertEquals(1, $resultSet->count());
}
public function testQuery()
{
$client = $this->_getClient();
$index = $client->getIndex('test');
$index->create(array(), true);
$type = $index->getType('helloworld');
$doc = new Document(1, array('name' => 'tom', 'paid' => 7));
$type->addDocument($doc);
$doc = new Document(2, array('name' => 'tom', 'paid' => 2));
$type->addDocument($doc);
$doc = new Document(3, array('name' => 'tom', 'paid' => 5));
$type->addDocument($doc);
$doc = new Document(4, array('name' => 'mike', 'paid' => 13));
$type->addDocument($doc);
$doc = new Document(5, array('name' => 'mike', 'paid' => 1));
$type->addDocument($doc);
$doc = new Document(6, array('name' => 'mike', 'paid' => 15));
$type->addDocument($doc);
$facet = new TermsStats('test');
$facet->setKeyField('name');
$facet->setValueField('paid');
$query = new Query();
$query->addFacet($facet);
$query->setQuery(new MatchAll());
$index->refresh();
$response = $type->search($query);
$facets = $response->getFacets();
$this->assertEquals(2, count($facets['test']['terms']));
foreach ($facets['test']['terms'] as $facet) {
if ($facet['term'] === 'tom') {
$this->assertEquals(14, $facet['total']);
}
if ($facet['term'] === 'mike') {
$this->assertEquals(29, $facet['total']);
}
}
}
/**
* @group functional
*/
public function testStatisticalWithSetFields()
{
$client = $this->_getClient();
$index = $client->getIndex('test');
$index->create(array(), true);
$type = $index->getType('helloworld');
$doc = new Document(1, array('price' => 10, 'price2' => 20));
$type->addDocument($doc);
$doc = new Document(2, array('price' => 35, 'price2' => 70));
$type->addDocument($doc);
$doc = new Document(2, array('price' => 45, 'price2' => 90));
$type->addDocument($doc);
$facet = new Statistical('stats');
$facet->setFields(array('price', 'price2'));
$query = new Query();
$query->addFacet($facet);
$query->setQuery(new MatchAll());
$index->refresh();
$response = $type->search($query);
$facets = $response->getFacets();
$this->assertEquals(165, $facets['stats']['total']);
$this->assertEquals(10, $facets['stats']['min']);
$this->assertEquals(90, $facets['stats']['max']);
}
/**
* @group unit
*/
public function testSetQueryToArrayChangeQuery()
{
$query = new Query();
$termQuery = new Term();
$termQuery->setTerm('text', 'value');
$query->setQuery($termQuery);
$queryArray = $query->toArray();
$termQuery = $query->getQuery();
$termQuery->setTerm('text', 'another value');
$this->assertNotEquals($queryArray, $query->toArray());
}
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]);
}
