public function testQueryInsideHasParentSearch() { $index = $this->prepareSearchData(); $f = new \Elastica\Query\Term(); $f->setTerm('user', 'parent1'); $filter = new HasParent($f, 'parent'); $searchQuery = new \Elastica\Query(); $searchQuery->setFilter($filter); $searchResults = $index->search($searchQuery); $this->assertEquals(1, $searchResults->count()); $result = $searchResults->current()->getData(); $expected = array('id' => 'child1', 'user' => 'child1', 'email' => '*****@*****.**'); $this->assertEquals($expected, $result); }
public function testFilter() { $index = $this->_createIndex('geohash_filter_test'); $type = $index->getType('test'); $mapping = new \Elastica\Type\Mapping($type, array('pin' => array('type' => 'geo_point', 'geohash' => true, 'geohash_prefix' => true))); $type->setMapping($mapping); $type->addDocument(new \Elastica\Document(1, array('pin' => '9q8yyzm0zpw8'))); $type->addDocument(new \Elastica\Document(2, array('pin' => '9mudgb0yued0'))); $index->refresh(); $filter = new GeohashCell('pin', array('lat' => 32.828326, 'lon' => -117.255854)); $query = new \Elastica\Query(); $query->setFilter($filter); $results = $type->search($query); $this->assertEquals(1, $results->count()); //test precision parameter $filter = new GeohashCell('pin', '9', 1); $query = new \Elastica\Query(); $query->setFilter($filter); $results = $type->search($query); $this->assertEquals(2, $results->count()); $index->delete(); }
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(); }
/** * To respect the design, 3 searches will be executed: * 1st: retrieves the main facet (Text / Media / Portfolio / Users / Group) and the count for each of them * 2nd: - retrieves the results of the first non empty facet term for display in the tab * - retrieves the secondary facet to enable / disable the filter items * 3nd: - retrieves the results with all filters applied * @param unknown $query_string * @param unknown $limit * @param unknown $offset * @param unknown $options * @param unknown $mainfacetterm * @param unknown $USER * @return multitype:number boolean unknown Ambigous <boolean, NULL> Ambigous <boolean, unknown> multitype:multitype:string number Ambigous <string, unknown> |multitype:multitype: */ public static function search($query_string, $limit, $offset, $options, $mainfacetterm, $USER) { $result = array('count' => 0, 'limit' => $limit, 'offset' => $offset, 'data' => false, 'selected' => isset($mainfacetterm) && strlen($mainfacetterm) > 0 ? $mainfacetterm : false, 'totalresults' => 0, 'facets' => array(array('term' => "Text", 'count' => 0, 'display' => "Text"), array('term' => "Media", 'count' => 0, 'display' => "Media"), array('term' => "Portfolio", 'count' => 0, 'display' => "Portfolio"), array('term' => "User", 'count' => 0, 'display' => "Users"), array('term' => "Group", 'count' => 0, 'display' => "Group")), 'content-filter' => array(array('term' => "all", 'count' => 0, 'display' => "All"), array('term' => "Audio", 'count' => 0, 'display' => "Audio"), array('term' => "Comment", 'count' => 0, 'display' => "Comment"), array('term' => "Document", 'count' => 0, 'display' => "Document"), array('term' => "Folder", 'count' => 0, 'display' => "Folder"), array('term' => "Forum", 'count' => 0, 'display' => "Forum"), array('term' => "Forumpost", 'count' => 0, 'display' => "Forum post"), array('term' => "Image", 'count' => 0, 'display' => "Image"), array('term' => "Journal", 'count' => 0, 'display' => "Journal"), array('term' => "Journalentry", 'count' => 0, 'display' => "Journal entry"), array('term' => "Note", 'count' => 0, 'display' => "Note"), array('term' => "Plan", 'count' => 0, 'display' => "Plan"), array('term' => "Profile", 'count' => 0, 'display' => "Profile"), array('term' => "Resume", 'count' => 0, 'display' => "Résumé"), array('term' => "Video", 'count' => 0, 'display' => "Video"), array('term' => "Wallpost", 'count' => 0, 'display' => "Wall post"), array('term' => "Collection", 'count' => 0, 'display' => "Collection"), array('term' => "Page", 'count' => 0, 'display' => "Page")), 'content-filter-selected' => isset($options['secfacetterm']) && strlen($options['secfacetterm']) > 0 ? $options['secfacetterm'] : 'all', 'owner-filter' => array(array('term' => "all", 'count' => 0, 'display' => "All"), array('term' => "me", 'count' => 0, 'display' => "Me"), array('term' => "others", 'count' => 0, 'display' => "Others")), 'owner-filter-selected' => isset($options['owner']) && strlen($options['owner']) > 0 ? $options['owner'] : 'all', 'tagsonly' => isset($options['tagsonly']) && $options['tagsonly'] == true ? true : Null, 'sort' => isset($options['sort']) && strlen($options['sort']) > 0 ? $options['sort'] : 'score', 'license' => isset($options['license']) && strlen($options['license']) > 0 ? $options['license'] : 'all'); if (strlen($query_string) <= 0) { return $result; } // 1- Get main facet // ------------------------------------------------------------------------------------------ $records = array(); $elasticaClient = PluginSearchElasticsearch::make_client(); $elasticaIndex = $elasticaClient->getIndex(get_config_plugin('search', 'elasticsearch', 'indexname')); $elasticaQueryString = new \Elastica\Query\QueryString(); $elasticaAnalyzer = get_config_plugin('search', 'elasticsearch', 'analyzer'); $elasticaQueryString->setAnalyzer($elasticaAnalyzer); $elasticaQueryString->setDefaultOperator('AND'); $elasticaQueryString->setQuery($query_string); // if tags only => set fields to tags if ($result['tagsonly'] === true) { $elasticaQueryString->setFields(array('tags')); } // Create the $elasticaQuery object $elasticaQuery = new \Elastica\Query(); $elasticaQuery->setFrom($offset); $elasticaQuery->setLimit($limit); $elasticaQuery->setQuery($elasticaQueryString); $elasticaFilterAnd = new \Elastica\Filter\BoolAnd(); // Apply ACL filters $elasticaFilterACL = new ElasticsearchFilterAcl($USER); $elasticaFilterAnd->addFilter($elasticaFilterACL); $elasticaQuery->setFilter($elasticaFilterAnd); // Define a new facet: mainFacetTerm - WARNING: don't forget to apply the same filter to the facet $elasticaFacet = new \Elastica\Facet\Terms('mainFacetTerm'); $elasticaFacet->setField('mainfacetterm'); $elasticaFacet->setOrder('count'); $elasticaFacet->setFilter($elasticaFilterAnd); $elasticaQuery->addFacet($elasticaFacet); $elasticaResultSet = $elasticaIndex->search($elasticaQuery); $result['totalresults'] = $elasticaResultSet->getTotalHits(); $elasticaFacets = $elasticaResultSet->getFacets(); $facets = self::process_facets($elasticaFacets['mainFacetTerm']['terms']); if (count($facets) == 0) { return $result; } array_walk($result['facets'], 'self::process_tabs', $facets); if ($result['selected'] === false || $facets[$result['selected']] == 0) { $result['selected'] = self::get_selected_facet($result['facets']); } // 2- Retrieve results of selected facet // ------------------------------------------------------------------------------------------ $elasticaFilterType = new \Elastica\Filter\Term(array('mainfacetterm' => $result['selected'])); $elasticaFilterAnd->addFilter($elasticaFilterType); $elasticaQuery->setFilter($elasticaFilterAnd); // Define a new facet: secFacetTerm - WARNING: don't forget to apply the same filter to the facet $elasticaFacet = new \Elastica\Facet\Terms('secFacetTerm'); $elasticaFacet->setField('secfacetterm'); $elasticaFacet->setOrder('count'); $elasticaFacet->setFilter($elasticaFilterAnd); $elasticaQuery->addFacet($elasticaFacet); // Sorting // Sorting is defined on a per field level, so we must make sure the field exists in the mapping $sort = explode('_', $result['sort']); if ($sort[0] == 'score') { $sort[0] = '_score'; } // set the second column to sort by the score (to break any 'ties'). $elasticaQuery->setSort(array(array($sort[0] => array('order' => isset($sort[1]) ? $sort[1] : 'desc')), array('_score' => array('order' => 'desc')))); $elasticaResultSet = $elasticaIndex->search($elasticaQuery); $result['count'] = $elasticaResultSet->getTotalHits(); $elasticaFacets = $elasticaResultSet->getFacets(); $facets = $elasticaFacets['secFacetTerm']['terms']; $facets = self::process_facets($elasticaFacets['secFacetTerm']['terms']); array_walk($result['content-filter'], 'self::process_tabs', $facets); // set the count of "all" to the total hits $result['content-filter'][0]['count'] = $result['count']; // 3- Apply filters and retrieve final results // ------------------------------------------------------------------------------------------ // Apply Content filter if different from "all" if ($result['content-filter-selected'] != 'all') { $elasticaFilterContent = new \Elastica\Filter\Term(array('secfacetterm' => $result['content-filter-selected'])); $elasticaFilterAnd->addFilter($elasticaFilterContent); } // Apply Owner filter if different from "all" if ($result['owner-filter-selected'] != 'all') { $uid = $USER->get('id'); $elasticaFilterOwner = new \Elastica\Filter\Term(array('owner' => $uid)); if ($result['owner-filter-selected'] == 'others') { $elasticaFilterOwner = new \Elastica\Filter\BoolNot($elasticaFilterOwner); } $elasticaFilterAnd->addFilter($elasticaFilterOwner); } // Apply license filter if different from "all" if ($result['license'] != 'all') { $elasticaFilterLicense = new \Elastica\Filter\Term(array('license' => $result['license'])); $elasticaFilterAnd->addFilter($elasticaFilterLicense); } $elasticaQuery->setFilter($elasticaFilterAnd); $elasticaResultSet = $elasticaIndex->search($elasticaQuery); $elasticaResults = $elasticaResultSet->getResults(); $result['count'] = $elasticaResultSet->getTotalHits(); foreach ($elasticaResults as $elasticaResult) { $tmp = array(); $tmp['type'] = $elasticaResult->getType(); $ES_class = 'ElasticsearchType_' . $tmp['type']; $tmp = $tmp + $elasticaResult->getData(); // Get all the data from the DB table $dbrec = $ES_class::getRecordDataById($tmp['type'], $tmp['id']); if ($dbrec) { $tmp['db'] = $dbrec; $tmp['db']->deleted = false; } else { // If the record has been deleted, so just pass the cached data // from the search result. Let the template decide how to handle // it. $tmp['db'] = (object) $tmp; $tmp['db']->deleted = true; } $records[] = $tmp; } $result['data'] = $records; return $result; }
/** * @param null $facets * @param $configuration * @param $taxon * @param null $types * * @return mixed */ public function compileElasticaTaxonQuery($facets = null, $configuration, $taxon, $types = null) { $elasticaQuery = new \Elastica\Query(); $boolFilter = new \Elastica\Filter\BoolFilter(); if (!empty($types)) { foreach ($types as $type) { $typeFilter = new \Elastica\Filter\Type($type); $boolFilter->addMust($typeFilter); } $elasticaQuery->setPostFilter($boolFilter); } if ($channel = $this->channelContext->getChannel()) { $channelFilter = new \Elastica\Filter\Terms(); $channelFilter->setTerms('channels', array((string) $channel)); $boolFilter->addMust($channelFilter); $elasticaQuery->setFilter($boolFilter); } $query = new \Elastica\Query\Filtered(); $taxonFromRequestFilter = new \Elastica\Filter\Terms(); $taxonFromRequestFilter->setTerms('taxons', array($taxon)); $boolFilter->addMust($taxonFromRequestFilter); $query->setFilter($boolFilter); $elasticaQuery->setQuery($query); return $this->compileElasticsearchQuery($elasticaQuery, $facets, $configuration); }
/** * Run the search against a sanitized query string via ElasticSearch. * * @param string $string * @param array $scriptProperties The scriptProperties array from the SimpleSearch snippet * @return array */ public function search($string, array $scriptProperties = array()) { $fields = $this->modx->getOption('sisea.elastic.search_fields', null, 'pagetitle^20,introtext^10,alias^5,content^1'); $fields = explode(',', $fields); $fields = array_map('trim', $fields); $fields = array_keys(array_flip($fields)); $fields = array_filter($fields); if (empty($fields)) { return false; } /** @var \Elastica\Query\MultiMatch $query */ $query = new \Elastica\Query\MultiMatch(); $query->setFields($fields); $query->setQuery($string); $customFilterScore = new \Elastica\Query\CustomFiltersScore(); $customFilterScore->setQuery($query); $searchBoosts = $this->modx->getOption('sisea.elastic.search_boost', null, ''); $searchBoosts = explode('|', $searchBoosts); $searchBoosts = array_map('trim', $searchBoosts); $searchBoosts = array_keys(array_flip($searchBoosts)); $searchBoosts = array_filter($searchBoosts); $boosts = array(); foreach ($searchBoosts as $boost) { $arr = array('field' => '', 'value' => '', 'boost' => 1.0); $field = explode('=', $boost); $field = array_map('trim', $field); $field = array_keys(array_flip($field)); $field = array_filter($field); if (count($field) != 2) { continue; } $value = explode('^', $field[1]); $value = array_map('trim', $value); $value = array_keys(array_flip($value)); $value = array_filter($value); if (count($value) != 2) { continue; } $arr['field'] = $field[0]; $arr['value'] = $value[0]; $arr['boost'] = $value[1]; $boosts[] = $arr; } if (empty($boosts)) { $customFilterScore->addFilter(new \Elastica\Filter\Term(array('type' => 'document')), 1); } else { foreach ($boosts as $boost) { $customFilterScore->addFilter(new \Elastica\Filter\Term(array($boost['field'] => $boost['value'])), $boost['boost']); } } /** @var \Elastica\Query $elasticaQuery */ $elasticaQuery = new \Elastica\Query(); $elasticaQuery->setQuery($customFilterScore); /* set limit */ $perPage = $this->modx->getOption('perPage', $scriptProperties, 10); if (!empty($perPage)) { $offset = $this->modx->getOption('start', $scriptProperties, 0); $offsetIndex = $this->modx->getOption('offsetIndex', $scriptProperties, 'sisea_offset'); if (isset($_REQUEST[$offsetIndex])) { $offset = (int) $_REQUEST[$offsetIndex]; } $elasticaQuery->setFrom($offset); $elasticaQuery->setSize($perPage); } $elasticaFilterAnd = new \Elastica\Filter\BoolAnd(); /* handle hidemenu option */ $hideMenu = $this->modx->getOption('hideMenu', $scriptProperties, 2); if ($hideMenu != 2) { $elasticaFilterHideMenu = new \Elastica\Filter\Term(); $elasticaFilterHideMenu->setTerm('hidemenu', $hideMenu ? 1 : 0); $elasticaFilterAnd->addFilter($elasticaFilterHideMenu); } /* handle contexts */ $contexts = $this->modx->getOption('contexts', $scriptProperties, ''); $contexts = !empty($contexts) ? $contexts : $this->modx->context->get('key'); $contexts = explode(',', $contexts); $elasticaFilterContext = new \Elastica\Filter\Terms(); $elasticaFilterContext->setTerms('context_key', $contexts); $elasticaFilterAnd->addFilter($elasticaFilterContext); /* handle restrict search to these IDs */ $ids = $this->modx->getOption('ids', $scriptProperties, ''); if (!empty($ids)) { $idType = $this->modx->getOption('idType', $this->config, 'parents'); $depth = $this->modx->getOption('depth', $this->config, 10); $ids = $this->processIds($ids, $idType, $depth); $elasticaFilterId = new \Elastica\Filter\Term(); $elasticaFilterId->setTerm('id', $ids); $elasticaFilterAnd->addFilter($elasticaFilterId); } /* handle exclude IDs from search */ $exclude = $this->modx->getOption('exclude', $scriptProperties, ''); if (!empty($exclude)) { $exclude = $this->cleanIds($exclude); $exclude = explode(',', $exclude); $elasticaFilterExcludeId = new \Elastica\Filter\Term(); $elasticaFilterExcludeId->setTerm('id', $exclude); $elasticaFilterNotId = new \Elastica\Filter\BoolNot($elasticaFilterExcludeId); $elasticaFilterAnd->addFilter($elasticaFilterNotId); } /* basic always-on conditions */ $elasticaFilterPublished = new \Elastica\Filter\Term(); $elasticaFilterPublished->setTerm('published', 1); $elasticaFilterAnd->addFilter($elasticaFilterPublished); $elasticaFilterSearchable = new \Elastica\Filter\Term(); $elasticaFilterSearchable->setTerm('searchable', 1); $elasticaFilterAnd->addFilter($elasticaFilterSearchable); $elasticaFilterDeleted = new \Elastica\Filter\Term(); $elasticaFilterDeleted->setTerm('deleted', 0); $elasticaFilterAnd->addFilter($elasticaFilterDeleted); $elasticaQuery->setFilter($elasticaFilterAnd); /* sorting */ if (!empty($scriptProperties['sortBy'])) { $sortDir = $this->modx->getOption('sortDir', $scriptProperties, 'desc'); $sortDirs = explode(',', $sortDir); $sortBys = explode(',', $scriptProperties['sortBy']); $dir = 'desc'; $sortArray = array(); for ($i = 0; $i < count($sortBys); $i++) { if (isset($sortDirs[$i])) { $dir = $sortDirs[$i]; } $sortArray[] = array($sortBys[$i] => $dir); } $elasticaQuery->setSort($sortArray); } /* prepare response array */ $response = array('total' => 0, 'start' => !empty($offset) ? $offset : 0, 'limit' => $perPage, 'status' => 0, 'query_time' => 0, 'results' => array()); $elasticaResultSet = $this->index->search($elasticaQuery); $elasticaResults = $elasticaResultSet->getResults(); $totalResults = $elasticaResultSet->getTotalHits(); if ($totalResults > 0) { $response['total'] = $totalResults; $response['query_time'] = $elasticaResultSet->getTotalTime(); $response['status'] = 1; $response['results'] = array(); foreach ($elasticaResults as $doc) { $d = $doc->getData(); /** @var modResource $resource */ $resource = $this->modx->newObject($d['class_key']); if ($resource->checkPolicy('list')) { $response['results'][] = $d; } } } return $response; }
/** * @param $searchTerm * @param null $appliedFilters * @param $configuration * @param $preSearchTaxonFilter * @param $types * * @return mixed */ public function compileElasticSearchStringQuery($searchTerm, $appliedFilters = null, $configuration, $preSearchTaxonFilter, $types = null) { $elasticaQuery = new \Elastica\Query(); $boolFilter = new \Elastica\Filter\Bool(); $query = new \Elastica\Query\QueryString($searchTerm); if (!empty($types)) { foreach ($types as $type) { $typeFilter = new \Elastica\Filter\Type($type); $boolFilter->addMust($typeFilter); } $elasticaQuery->setFilter($boolFilter); } // this is currently the only pre search filter and it's a taxon // this should be abstracted out if other types of pre search filters are desired if ('all' !== $preSearchTaxonFilter) { $query = new \Elastica\Query\Filtered(); $query->setQuery(new \Elastica\Query\QueryString($searchTerm)); $taxonFromRequestFilter = new \Elastica\Filter\Terms(); $taxonFromRequestFilter->setTerms('taxons', array($preSearchTaxonFilter)); $boolFilter->addMust($taxonFromRequestFilter); $elasticaQuery->setFilter($boolFilter); } $elasticaQuery->setQuery($query); return $this->compileElasticsearchQuery($elasticaQuery, $appliedFilters, $configuration); }
public function searchLoans($conditions = array(), $page = 1, $limit = 20) { $conditions += ['search' => false]; $search = $conditions['search']; unset($conditions['search']); $queryString = new \Elastica\Query\QueryString(); $loanIndex = $this->getLoanIndex(); $query = new \Elastica\Query(); if ($search) { $queryString->setDefaultOperator('AND'); $queryString->setQuery($search); $query->setQuery($queryString); } $filterAnd = new \Elastica\Filter\BoolAnd(); foreach ($conditions as $field => $value) { $termFilter = new \Elastica\Filter\Term(); $termFilter->setTerm($field, $value); $filterAnd->addFilter($termFilter); } if ($conditions) { $query->setFilter($filterAnd); } $query->setFrom(($page - 1) * $limit); $query->setSize($page * $limit); $results = $loanIndex->search($query); $ids = []; foreach ($results as $result) { $data = $result->getData(); $ids[$data['id']] = $data['id']; } $loans = LoanQuery::create()->filterById($ids)->find(); $sortedLoans = $ids; foreach ($loans as $loan) { $sortedLoans[$loan->getId()] = $loan; } $sortedLoans = array_filter($sortedLoans, function ($l) { return !is_scalar($l); }); $paginatorFactory = \App::make('paginator'); return $paginatorFactory->make($sortedLoans, $results->getTotalHits(), $limit); }
/** * Main method to make a search */ public function search() { $this->getSearchFields(); $word = JRequest::getString('searchword', null, 'get'); $offset = JRequest::getInt('start', 0, 'get'); $limit = JRequest::getInt('limit', 10, 'get'); if ($limit == 0) { // no limit $limit = 10000; } $this->getSearchAreas(); $elasticaQueryString = new \Elastica\Query\QueryString(); // Log search word only on the first page if ($offset == 0) { SearchHelper::logSearch($word); } // Convert accents $word = htmlentities($word, ENT_NOQUOTES, 'utf-8'); $word = preg_replace('#\\&([A-za-z])(?:uml|circ|tilde|acute|grave|cedil|ring)\\;#', '\\1', $word); $word = preg_replace('#\\&([A-za-z]{2})(?:lig)\\;#', '\\1', $word); $word = preg_replace('#\\&[^;]+\\;#', '', $word); // Check if there are quotes ( for exact search ) $exactSearch = false; if (strlen($word) > 1 && $word[0] == '"' && $word[strlen($word) - 1] == '"') { $exactSearch = true; $word = substr($word, 1, strlen($word) - 2); // Remove external " } $word = Elastica\Util::replaceBooleanWordsAndEscapeTerm($word); // Escape ElasticSearch specials char if ($exactSearch) { $word = '"' . $word . '"'; } if ($word == "") { $word = "*"; } $elasticaQueryString->setQuery($word); //Create the actual search object with some data. $elasticaQuery = new Elastica\Query(); $elasticaQuery->setQuery($elasticaQueryString); if (ElasticSearchConfig::getHighLigthEnable()) { $fields = $this->getHighlightFields(); $hlfields = array(); foreach ($fields as $field) { foreach ($field as $highlight) { $hlfields[] = array($highlight => array('fragment_size' => 1000, 'number_of_fragments' => 1)); } } $highlightFields = array('pre_tags' => array(ElasticSearchConfig::getHighLigthPre()), 'post_tags' => array(ElasticSearchConfig::getHighLigthPost()), "order" => "score", 'fields' => $hlfields); $elasticaQuery->setHighlight($highlightFields); } // Set offset and limit for pagination $elasticaQuery->setFrom($offset); $elasticaQuery->setLimit($limit); //Create a filter for _type $elasticaFilterype = $this->createFilterType($this->areas); // Add filter to the search object. $elasticaQuery->setFilter($elasticaFilterype); //Search on the index. $elasticaResultSet = $this->elasticaIndex->search($elasticaQuery); $this->results = $elasticaResultSet->getResults(); $this->totalHits = $elasticaResultSet->getTotalHits(); }
$sm->persist($user); $sm->flush(); //Execute a single lookup with no results echo PHP_EOL . "*** Single lookup with no results ***" . PHP_EOL; try { $user = $sm->find('Doctrine\\Tests\\Models\\Comments\\User', 'unknownid'); } catch (Doctrine\Search\Exception\NoResultException $exception) { print_r($exception->getMessage()); echo PHP_EOL; } //Search for comments with parent user. Because of the way ES returns //results, you have to explicitly ask for the _parent or _routing field if required. //On single document query e.g. find() the _parent field is returned by ES anyway. echo PHP_EOL . "*** Comments with parent user ***" . PHP_EOL; $query = new Elastica\Query(); $query->setFilter(new Elastica\Filter\HasParent(new Elastica\Filter\Term(array('username' => 'mrhash')), 'users')); $query->setFields(array('_source', '_parent')); $comments = $sm->getRepository('Doctrine\\Tests\\Models\\Comments\\Comment')->search($query); foreach ($comments as $comment) { print_r($comment); } //Paginated response with Pagerfanta library. In this case the Doctrine\Search\Query //wrapper provides a mechanism for specifying the query but it should be possible to //pass an Elastica query directly into a modified pagination adapter. echo PHP_EOL . "*** Pagerfanta paginated results ***" . PHP_EOL; $query = $sm->createQuery()->from('Doctrine\\Tests\\Models\\Comments\\Comment')->searchWith(new Elastica\Query())->setQuery(new Elastica\Query\MatchAll())->setFields(['_source', '_parent'])->setHydrationMode(Doctrine\Search\Query::HYDRATE_INTERNAL); $pager = new Pagerfanta\Pagerfanta(new PagerfantaAdapter($query)); $pager->setAllowOutOfRangePages(true); $pager->setMaxPerPage(1); $pager->setCurrentPage(2); $comments = $pager->getCurrentPageResults();
/** * Get views linked to a particular artefact, applying ACL * This is used to display the list of views in an artefact result, because it's faster to retrieve the info * from Elastic search that running the SQL query. */ public static function views_by_artefact_acl_filter($views = array()) { global $USER; $ret = array(); $elasticaClient = PluginSearchElasticsearch::make_client(); $elasticaIndex = $elasticaClient->getIndex(get_config_plugin('search', 'elasticsearch', 'indexname')); $elasticaQuery = new \Elastica\Query(); // check user access to the views $elasticaFilterAnd = new \Elastica\Filter\BoolAnd(); $elasticaFilterType = new \Elastica\Filter\Term(array('_type' => 'view')); $elasticaFilterAnd->addFilter($elasticaFilterType); $elasticaFilterIds = new \Elastica\Filter\Terms('id', array_keys($views)); $elasticaFilterAnd->addFilter($elasticaFilterIds); // Apply ACL filters $elasticaFilterACL = new ElasticsearchFilterAcl($USER); $elasticaFilterAnd->addFilter($elasticaFilterACL); $elasticaQuery->setFilter($elasticaFilterAnd); $elasticaResultSet = $elasticaIndex->search($elasticaQuery); $elasticaResults = $elasticaResultSet->getResults(); foreach ($elasticaResults as $elasticaResult) { $data = $elasticaResult->getData(); $ret[$data['id']] = $views[$data['id']]; } return $ret; }
/** * @param $queryString * @param int $offset * @param int $limit * @return null|SugarSeachEngineElasticResultSet */ public function search($queryString, $offset = 0, $limit = 20, $options = array()) { if (self::isSearchEngineDown()) { return null; } $appendWildcard = false; if (!empty($options['append_wildcard']) && $this->canAppendWildcard($queryString)) { $appendWildcard = true; } $queryString = DBManagerFactory::getInstance()->sqlLikeString($queryString, self::WILDCARD_CHAR, $appendWildcard); $this->logger->info("Going to search with query {$queryString}"); $results = null; try { $queryObj = $this->buildQueryObject($queryString, $options); $s = new \Elastica\Search($this->_client); $finalTypes = array(); if (!empty($options['moduleFilter'])) { foreach ($options['moduleFilter'] as $moduleName) { // only add the module to the list if it can be viewed if ($this->checkAccess($moduleName)) { $finalTypes[] = $moduleName; } } if (!empty($finalTypes)) { $s->addTypes($finalTypes); } } $s->addIndices($this->getReadIndices($finalTypes)); // main filter $mainFilter = $this->constructMainFilter($finalTypes, $options); $query = new \Elastica\Query($queryObj); $query->setFilter($mainFilter); if (isset($options['sort']) && is_array($options['sort'])) { foreach ($options['sort'] as $sort) { $query->addSort($sort); } } $query->setParam('from', $offset); // set query highlight $fields = $this->getSearchFields($options, false); $highlighArray = $this->constructHighlightArray($fields, $options); $query->setHighlight($highlighArray); // add facets $this->addFacets($query, $options, $mainFilter); $esResultSet = $s->search($query, $limit); $results = new SugarSeachEngineElasticResultSet($esResultSet); } catch (Exception $e) { $this->reportException("Unable to perform search", $e); $this->checkException($e); return null; } return $results; }