public function indexAction(Request $request, $page = 1) { $getTypes = $request->query->get('type_filters'); $getSubjects = $request->query->get('subject_filters'); $getPublishers = $request->query->get('publisher_filters'); $typeFilters = !empty($getTypes) ? explode(',', $getTypes) : []; $subjectFilters = !empty($getSubjects) ? explode(',', $getSubjects) : []; $publisherFilters = !empty($getPublishers) ? explode(',', $getPublishers) : []; $journalSearcher = $this->get('fos_elastica.index.search.journal'); $boolQuery = new Query\Bool(); $match = new Query\Match(); $match->setField('status', 1); $boolQuery->addMust($match); $match = new Query\Match(); $match->setField('published', true); $boolQuery->addMust($match); if (!empty($typeFilters) || !empty($subjectFilters) || !empty($publisherFilters)) { foreach ($typeFilters as $type) { $match = new Query\Match(); $match->setField('publisher.publisher_type.name', $type); $boolQuery->addMust($match); } foreach ($subjectFilters as $subject) { $match = new Query\Match(); $match->setField('subjects.subject', $subject); $boolQuery->addMust($match); } foreach ($publisherFilters as $publisher) { $match = new Query\Match(); $match->setField('publisher.name', $publisher); $boolQuery->addMust($match); } } $journalQuery = new Query($boolQuery); $typeAgg = new Aggregation\Terms('types'); $typeAgg->setField('publisher.publisher_type.name'); $typeAgg->setOrder('_term', 'asc'); $typeAgg->setSize(0); $journalQuery->addAggregation($typeAgg); $subjectAgg = new Aggregation\Terms('subjects'); $subjectAgg->setField('subjects.subject'); $subjectAgg->setOrder('_term', 'asc'); $subjectAgg->setSize(0); $journalQuery->addAggregation($subjectAgg); $publisherAgg = new Aggregation\Terms('publishers'); $publisherAgg->setField('publisher.name'); $publisherAgg->setOrder('_term', 'asc'); $publisherAgg->setSize(0); $journalQuery->addAggregation($publisherAgg); $adapter = new ElasticaAdapter($journalSearcher, $journalQuery); $pagerfanta = new Pagerfanta($adapter); $pagerfanta->setMaxPerPage(21); $pagerfanta->setCurrentPage($page); $journals = $pagerfanta->getCurrentPageResults(); $types = $adapter->getResultSet()->getAggregation('types')['buckets']; $subjects = $adapter->getResultSet()->getAggregation('subjects')['buckets']; $publishers = $adapter->getResultSet()->getAggregation('publishers')['buckets']; $data = ['types' => $types, 'subjects' => $subjects, 'publishers' => $publishers, 'type_filters' => $typeFilters, 'subject_filters' => $subjectFilters, 'publisher_filters' => $publisherFilters, 'journals' => $journals, 'pagerfanta' => $pagerfanta, 'page' => 'explore']; return $this->render('OjsSiteBundle:Explore:index.html.twig', $data); }
/** * @group functional */ public function testReverseNestedAggregation() { $agg = new Nested('comments', 'comments'); $names = new Terms('name'); $names->setField('comments.name'); $tags = new Terms('tags'); $tags->setField('tags'); $reverseNested = new ReverseNested('main'); $reverseNested->addAggregation($tags); $names->addAggregation($reverseNested); $agg->addAggregation($names); $query = new Query(); $query->addAggregation($agg); $results = $this->_getIndexForTest()->search($query)->getAggregation('comments'); $this->assertArrayHasKey('name', $results); $nameResults = $results['name']; $this->assertCount(3, $nameResults['buckets']); // bob $this->assertEquals('bob', $nameResults['buckets'][0]['key']); $tags = array(array('key' => 'foo', 'doc_count' => 2), array('key' => 'bar', 'doc_count' => 1), array('key' => 'baz', 'doc_count' => 1)); $this->assertEquals($tags, $nameResults['buckets'][0]['main']['tags']['buckets']); // john $this->assertEquals('john', $nameResults['buckets'][1]['key']); $tags = array(array('key' => 'bar', 'doc_count' => 1), array('key' => 'foo', 'doc_count' => 1)); $this->assertEquals($tags, $nameResults['buckets'][1]['main']['tags']['buckets']); // susan $this->assertEquals('susan', $nameResults['buckets'][2]['key']); $tags = array(array('key' => 'baz', 'doc_count' => 1), array('key' => 'foo', 'doc_count' => 1)); $this->assertEquals($tags, $nameResults['buckets'][2]['main']['tags']['buckets']); }
public function publisherAction(Request $request, $page = 1) { $getTypes = $request->query->get('type_filters'); $typeFilters = !empty($getTypes) ? explode(',', $getTypes) : []; $publisherSearcher = $this->get('fos_elastica.index.search.publisher'); $boolQuery = new Query\Bool(); if (!empty($typeFilters)) { foreach ($typeFilters as $type) { $match = new Query\Match(); $match->setField('publisherType', $type); $boolQuery->addMust($match); } } $publisherQuery = new Query($boolQuery); $typeAgg = new Aggregation\Terms('types'); $typeAgg->setField('publisherType'); $typeAgg->setOrder('_term', 'asc'); $typeAgg->setSize(0); $publisherQuery->addAggregation($typeAgg); $adapter = new ElasticaAdapter($publisherSearcher, $publisherQuery); $pagerfanta = new Pagerfanta($adapter); $pagerfanta->setMaxPerPage(20); $pagerfanta->setCurrentPage($page); $publishers = $pagerfanta->getCurrentPageResults(); $types = $adapter->getResultSet()->getAggregation('types')['buckets']; $data = ['types' => $types, 'page' => 'ojs_site_explore_publisher', 'publishers' => $publishers, 'pagerfanta' => $pagerfanta, 'type_filters' => $typeFilters]; return $this->render('OjsSiteBundle:Explore:publisher.html.twig', $data); }
/** * Returns a query setup for getting the 'type' aggregation * * @param Cake\ElasticSearch\Query $query The Query Object * @return Cake\ElasticSearch\Query */ public function findTypes($query) { $facet = new TermsAggregation('type'); $facet->setField('_type'); $facet->setSize(200); $query->aggregate($facet); return $query->limit(1); }
/** * @group functional */ public function testTermsAggregation() { $agg = new Terms('terms'); $agg->setField('color'); $query = new Query(); $query->addAggregation($agg); $results = $this->_getIndexForTest()->search($query)->getAggregation('terms'); $this->assertEquals(2, $results['buckets'][0]['doc_count']); $this->assertEquals('blue', $results['buckets'][0]['key']); }
public function testTermsAggregation() { $agg = new Terms("terms"); $agg->setField("color"); $query = new Query(); $query->addAggregation($agg); $results = $this->_index->search($query)->getAggregation("terms"); $this->assertEquals(2, $results['buckets'][0]['doc_count']); $this->assertEquals("blue", $results['buckets'][0]['key']); }
/** * @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 Terms $termsAgg * @throws ErrorException */ private function addAggregation(Terms $termsAgg) { foreach ($this->aggregation as $parameter => $queryAttr) { $aggregationModel = new Aggregation(); $aggregationModel->parameter = $parameter; $aggregationModel->attributes = $queryAttr; $itemAgg = $aggregationModel->getElasticaAggregations(); $itemAgg->setField($parameter); $termsAgg->addAggregation($itemAgg); $this->aggregationList[] = ['type' => $aggregationModel->type, 'index' => $aggregationModel->getAggregationName(), 'title' => (string) $aggregationModel]; } }
private function getStatsQuery(Journal $journal) { $filter = new Term(); $filter->setTerm('journal.id', $journal->getId()); $filterQuery = new Filtered(); $filterQuery->setFilter($filter); $query = new Query($filterQuery); $dateHistogram = new DateHistogram('dateHistogram', 'created', 'month'); $dateHistogram->setFormat("YYYY-MM-dd"); $query->addAggregation($dateHistogram); $genderAggregation = new Terms('language'); $genderAggregation->setField('locale'); $query->addAggregation($genderAggregation); $query->setSize(0); return $query; }
private function getStatsQuery(Journal $journal) { $filter = new Term(); $filter->setTerm('journalUsers.journal.id', $journal->getId()); $filterQuery = new Query\Filtered(); $filterQuery->setFilter($filter); $query = new Query($filterQuery); $titleAggregation = new Terms('title'); $titleAggregation->setField('title'); $query->addAggregation($titleAggregation); $genderAggregation = new Terms('gender'); $genderAggregation->setField('gender'); $query->addAggregation($genderAggregation); $query->setSize(0); return $query; }
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; }
protected function getStates() { $results = []; $query = new Elastica\Query(); $query->setSize(0); $agg = new Elastica\Aggregation\Nested('states', 'state'); $st_terms = new Elastica\Aggregation\Terms('abbrev'); $st_terms->setField('state.abbrev'); $st_terms->setOrder('_term', 'asc'); $st_terms->setSize(0); $state_terms = new Elastica\Aggregation\Terms('full'); $state_terms->setField('state.full'); $st_terms->addAggregation($state_terms); $agg->addAggregation($st_terms); $query->addAggregation($agg); /* @var $elastica_client Elastica\Client */ $elastica_client = $this->getServiceLocator()->getServiceLocator()->get('elastica-client'); try { /* @var $response \Elastica\Response */ $response = $elastica_client->request('usgeodb/locality/_search?query_cache=true', Request::GET, $query->toArray()); $data = $response->getData(); $aggregations = isset($data['aggregations']['states']['abbrev']['buckets']) ? $data['aggregations']['states']['abbrev']['buckets'] : []; foreach ($aggregations as $aggregation) { $key = strtoupper($aggregation['key']); $value = ucwords($aggregation['full']['buckets'][0]['key']); $results[$key] = $value; } } catch (\Exception $e) { } return $results; }
/** * @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); }
/** * Get a list of all projects. * @return array */ public function getProjects() { $agg = new Terms('projects'); $agg->setField('project'); $agg->setSize(0); $agg->setShardSize(0); $agg->setOrder('_term', 'asc'); $query = new Query(); $query->addAggregation($agg); $res = $this->doSearch($query)->getAggregation('projects'); return array_map(function ($b) { return $b['key']; }, $res['buckets']); }
protected function getOuterAggregationResult($innerAggr) { $outerAggr = new Terms('top_tags'); $outerAggr->setField('tags'); $outerAggr->setMinimumDocumentCount(2); $outerAggr->addAggregation($innerAggr); $query = new Query(new MatchAll()); $query->addAggregation($outerAggr); return $this->_getIndexForTest()->search($query)->getAggregation('top_tags'); }
/** * Add a number of facets to the FlickrPhoto query * @param \Elastica\Query &$query the existing query object to be augmented. */ public function augmentQuery(&$query) { // set the order to be taken at in reverse if query is blank other than aggs $params = $query->getParams(); // add Aperture aggregate $agg1 = new Terms("Aperture"); $agg1->setField("Aperture"); $agg1->setSize(0); $agg1->setOrder('_term', 'asc'); $query->addAggregation($agg1); // add shutter speed aggregate $agg2 = new Terms("ShutterSpeed"); $agg2->setField("ShutterSpeed"); $agg2->setSize(0); $agg2->setOrder('_term', 'asc'); $query->addAggregation($agg2); // this currently needs to be same as the field name // needs fixed // Add focal length aggregate, may range this $agg3 = new Terms("FocalLength35mm"); $agg3->setField("FocalLength35mm"); $agg3->setSize(0); $agg3->setOrder('_term', 'asc'); $query->addAggregation($agg3); // add film speed $agg4 = new Terms("ISO"); $agg4->setField("ISO"); $agg4->setSize(0); $agg4->setOrder('_term', 'asc'); $query->addAggregation($agg4); $aspectRangedAgg = RangedAggregation::getByTitle('Aspect'); $query->addAggregation($aspectRangedAgg->getRangeAgg()); // remove NearestTo from the request so it does not get used as a term filter unset(Controller::curr()->request['NearestTo']); }
/** * Tag cloud page * @return \Symfony\Component\HttpFoundation\Response */ public function tagCloudAction() { $search = $this->container->get('fos_elastica.index.search'); $searchQuery = new Query(); $searchQuery->setSize(0); //get tags aggregation $tagsAgg = new Aggregation\Terms('tags'); $tagsAgg->setField('tags'); $tagsAgg->setSize(500); $searchQuery->addAggregation($tagsAgg); /** * @var ResultSet $results */ $results = $search->search($searchQuery); $data['tags'] = []; foreach ($results->getAggregations()['tags']['buckets'] as $result) { $keys = array_filter(explode(',', $result['key'])); if (is_array($keys)) { foreach ($keys as $key) { $data['tags'][] = trim($key); } } } return $this->render('OjsSiteBundle:Search:tags_cloud.html.twig', $data); }
/** * Tag cloud page * @return \Symfony\Component\HttpFoundation\Response */ public function tagCloudAction() { $search = $this->container->get('fos_elastica.index.search'); $searchQuery = new Query('_all'); //get tags aggregation $tagsAgg = new Aggregation\Terms('tags'); $tagsAgg->setField('tags'); $tagsAgg->setOrder('_term', 'asc'); $tagsAgg->setSize(0); $searchQuery->addAggregation($tagsAgg); /** * @var ResultSet $results */ $results = $search->search($searchQuery); $data['tags'] = []; foreach ($results->getAggregations()['tags']['buckets'] as $result) { $data['tags'][] = $result['key']; } return $this->render('OjsSiteBundle:Search:tags_cloud.html.twig', $data); }
/** * @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']); }
public function search() { //$finder = $this->container->get('fos_elastica.finder.search.articles'); $bool = new Query\Bool(); $multiMatch = new Query\MultiMatch(); $multiMatch->setFields(['subjects', 'title', 'keywords', 'subtitle', 'citations.raw', 'journal.title', 'journal.subtitle']); $multiMatch->setType('phrase_prefix'); $multiMatch->setQuery($this->getParam('term')); $bool->addMust($multiMatch); if ($this->filter) { foreach ($this->filter as $key => $filter) { $filterObj = new Query\Match(); $this->applyFilter($filterObj, $key, $filter); $bool->addMust($filterObj); } } $missing = new Filter\Missing("issue"); $not = new Filter\BoolNot($missing); $notQ = new Query\Filtered(); $notQ->setFilter($not); $bool->addMust($notQ); $query = new Query(); $query->setQuery($bool); $query->setFrom($this->getPage() * $this->getLimit()); $query->setSize($this->getLimit()); $aggregation = new Terms('journals'); $aggregation->setField('journal.id'); $aggregation->setOrder('_count', 'desc'); $qb = $this->em->createQueryBuilder(); $qb->select('count(r.id)')->from('OjsJournalBundle:Journal', 'r')->where($qb->expr()->eq('r.status', 3)); $aggregation->setSize($qb->getQuery()->getSingleScalarResult()); $query->addAggregation($aggregation); $aggregation = new Terms('authors'); $aggregation->setField('articleAuthors.author.id'); $aggregation->setOrder('_count', 'desc'); $qb = $this->em->createQueryBuilder(); $qb->select('count(r.id)')->from('OjsJournalBundle:Author', 'r'); $aggregation->setSize($qb->getQuery()->getSingleScalarResult()); $query->addAggregation($aggregation); $elasticaAdapter = new ElasticaAdapter($this->index, $query); $pagerFanta = new Pagerfanta($elasticaAdapter); $pagerFanta->setMaxPerPage($this->getLimit()); $pagerFanta->setCurrentPage($this->getPage()); /** @var ResultSet $search */ $search = $pagerFanta->getCurrentPageResults(); $result = $search->getResults(); //$search->getResults(); $this->pager = $pagerFanta; $transformer = new ElasticaToModelTransformer($this->registry, 'OjsJournalBundle:Article'); $transformer->setPropertyAccessor($this->propertyAccessor); $this->result = $transformer->transform($result); $this->setCount($pagerFanta->getNbResults()); $this->addAggregation('journal', $this->transform($search->getAggregation('journals')['buckets'], 'OjsJournalBundle:Journal')); $this->addAggregation('author', $this->transform($search->getAggregation('authors')['buckets'], 'OjsJournalBundle:Author')); return $this; }
/** * @param AbstractElasticaSearcher $searcher * @param Request $request * @param RenderContext $context */ protected function applySearchParams(AbstractElasticaSearcher $searcher, Request $request, RenderContext &$context) { // Retrieve the search parameters $queryString = trim($request->query->get('query')); $queryType = $request->query->get('type'); $lang = $request->getLocale(); $context['q_query'] = $queryString; $context['q_type'] = $queryType; $searcher->setData($this->sanitizeSearchQuery($queryString))->setContentType($queryType)->setLanguage($lang); $query = $searcher->getQuery(); // Aggregations $termsAggregation = new Terms('type'); $termsAggregation->setField('type'); $query->addAggregation($termsAggregation); }
/** * @param Query $elasticaQuery */ private function addAggregations($elasticaQuery) { $catAggregation = new Terms('Category'); $catAggregation->setField('category.name'); $elasticaQuery->addAggregation($catAggregation); $trackerAggregation = new Terms('Tracker'); $trackerAggregation->setField('tracker.name'); $elasticaQuery->addAggregation($trackerAggregation); $status = new Terms('Status'); $status->setField('status.name'); $elasticaQuery->addAggregation($status); $priority = new Terms('Priority'); $priority->setField('priority.name'); $elasticaQuery->addAggregation($priority); $t3ver = new Terms('TYPO3 Version'); $t3ver->setField('typo3_version'); $elasticaQuery->addAggregation($t3ver); $targetver = new Terms('Target Version'); $targetver->setField('fixed_version.name'); $elasticaQuery->addAggregation($targetver); $phpVer = new Terms('PHP Version'); $phpVer->setField('php_version'); $elasticaQuery->addAggregation($phpVer); /*$age = new \Elastica\Aggregation\Range('Age'); $age->setParams(array( 'script' => 'DateTime.now().year - doc[\'updated_on\'].date.year', 'ranges' => array( array('from' => 0,'to' => 1), array('from' => 2,'to' => 3), array('from' => 4,'to' => 5), ) )); $elasticaQuery->addAggregation($age);*/ }