/**
* @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());
}
/**
* @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 testSignificantTermsAggregationWithBackgroundFilter()
{
$agg = new SignificantTerms('significantTerms');
$agg->setField('temperature');
$agg->setSize(1);
$termsFilter = new TermsFilter();
$termsFilter->setTerms('color', array('blue', 'red', 'green', 'yellow'));
$agg->setBackgroundFilter($termsFilter);
$termsQuery = new Terms();
$termsQuery->setTerms('color', array('blue', 'red', 'green', 'yellow', 'white'));
$query = new Query($termsQuery);
$query->addAggregation($agg);
$results = $this->_getIndexForTest()->search($query)->getAggregation('significantTerms');
$this->assertEquals(15, $results['buckets'][0]['doc_count']);
$this->assertEquals(12, $results['buckets'][0]['bg_count']);
$this->assertEquals('4500', $results['buckets'][0]['key_as_string']);
}
public function findByUserAndTags(User $user, $tags = null)
{
$filterQuery = new Query\Filtered();
$searchFilter = new Filter\Bool();
$searchFilter->addMust(new Filter\Term(array('user' => $user->getId())));
if (!empty($tags)) {
$tagFilter = new Filter\Terms('tags', explode('+', $tags));
$tagFilter->setExecution('and');
$searchFilter->addMust($tagFilter);
}
$filterQuery->setFilter($searchFilter);
$searchQuery = new Query($filterQuery);
$searchQuery->addSort(array('createdAt' => 'desc'));
$agg = new Aggregation\Terms('tags');
$agg->setField('tags')->setOrder('_count', 'desc')->setSize(100);
$searchQuery->addAggregation($agg);
return $searchQuery;
}
public function testLookup()
{
$index = $this->_createIndex('terms_filter_test');
$type1 = $index->getType('musicians');
$type2 = $index->getType('bands');
//index some test data
$type1->addDocument(new \Elastica\Document(1, array('name' => 'robert', 'lastName' => 'plant')));
$type1->addDocument(new \Elastica\Document(2, array('name' => 'jimmy', 'lastName' => 'page')));
$type1->addDocument(new \Elastica\Document(3, array('name' => 'john paul', 'lastName' => 'jones')));
$type1->addDocument(new \Elastica\Document(4, array('name' => 'john', 'lastName' => 'bonham')));
$type1->addDocument(new \Elastica\Document(5, array('name' => 'jimi', 'lastName' => 'hendrix')));
$type2->addDocument(new \Elastica\Document('led zeppelin', array('members' => array('plant', 'page', 'jones', 'bonham'))));
$index->refresh();
//use the terms lookup feature to query for some data
$termsFilter = new Terms();
$termsFilter->setLookup('lastName', $type2, 'led zeppelin', 'members', NULL);
$query = new \Elastica\Query();
$query->setFilter($termsFilter);
$results = $index->search($query);
$this->assertEquals($results->count(), 4, 'Terms lookup with null index');
$termsFilter->setLookup('lastName', $type2, 'led zeppelin', 'members', $index);
$query->setFilter($termsFilter);
$results = $index->search($query);
$this->assertEquals($results->count(), 4, 'Terms lookup with index as object');
//Query with index given as string
$termsFilter->setLookup('lastName', $type2, 'led zeppelin', 'members', $index->getName());
$query->setFilter($termsFilter);
$results = $index->search($query);
$this->assertEquals($results->count(), 4, 'Terms lookup with index as string');
//Query with array of options
$termsFilter->setLookup('lastName', $type2, 'led zeppelin', 'members', array('index' => $index, 'cache' => false));
$query->setFilter($termsFilter);
$results = $index->search($query);
$this->assertEquals($results->count(), 4, 'Terms lookup with options array');
$index->delete();
}
/**
* @group unit
* @expectedException \Elastica\Exception\InvalidException
*/
public function testToArrayInvalidException()
{
$filter = new Terms();
$filter->toArray();
}
/**
* Build a Search that will count all pages that link to $titles.
* @param string $titles title in prefixedDBKey form
* @return Search that counts all pages that link to $titles
*/
private function buildCount($titles)
{
$filter = new Terms('outgoing_link', $titles);
$filter->setCached(false);
// We're not going to be redoing this any time soon.
$type = $this->connection->getPageType(wfWikiId());
$search = new Search($type->getIndex()->getClient());
$search->addIndex($type->getIndex());
$search->addType($type);
$search->setOption(Search::OPTION_SEARCH_TYPE, Search::OPTION_SEARCH_TYPE_COUNT);
$matchAll = new MatchAll();
$search->setQuery(new Filtered($matchAll, $filter));
$search->getQuery()->addParam('stats', 'link_count');
return $search;
}
/**
* @param $appliedFilters
* @param $elasticaQuery
*
* @return array
*/
public function applyFilterToElasticaQuery($appliedFilters, $elasticaQuery)
{
$rangeFilters = new BoolOr();
$boolFilter = new BoolFilter();
$filters = [];
$termFilters = [];
foreach ($appliedFilters as $facet) {
if (strpos($facet[key($facet)], '|') !== false) {
$filters[key($facet)][] = ['range' => explode('|', $facet[key($facet)])];
} else {
$filters[key($facet)][] = $facet[key($facet)];
}
}
foreach ($filters as $name => $value) {
if (is_array($value[0])) {
foreach ($value as $range) {
$rangeFilter = new FilterRange();
$rangeFilter->addField($name, ['gte' => $range['range'][0], 'lte' => $range['range'][1]]);
$rangeFilters->addFilter($rangeFilter);
}
$boolFilter->addShould($rangeFilters);
} else {
$termFilters = new FilterTerms();
$termFilters->setTerms($name, $value);
$boolFilter->addShould($termFilters);
}
}
$elasticaQuery->setFilter($boolFilter);
return [$termFilters, $rangeFilters, $boolFilter, $filters];
}
public function testShouldReturnTheRightNumberOfResult()
{
$f = new Nested();
$this->assertEquals(array('nested' => array()), $f->toArray());
$q = new Terms();
$q->setTerms('hobby', array('guitar'));
$f->setPath('hobbies');
$f->setFilter($q);
$c = $this->_getClient();
$s = new Search($c);
$i = $c->getIndex('elastica_test_filter_nested_abstract_filter');
$s->addIndex($i);
$r = $s->search($f);
$this->assertEquals(1, $r->getTotalHits());
$f = new Nested();
$this->assertEquals(array('nested' => array()), $f->toArray());
$q = new Terms();
$q->setTerms('hobby', array('opensource'));
$f->setPath('hobbies');
$f->setFilter($q);
$c = $this->_getClient();
$s = new Search($c);
$i = $c->getIndex('elastica_test_filter_nested_abstract_filter');
$s->addIndex($i);
$r = $s->search($f);
$this->assertEquals(2, $r->getTotalHits());
}
