private static void addFacets(SearchRequestBuilder esSearch, SearchOptions options, Map<String, QueryBuilder> filters, ProjectMeasuresQuery query) { StickyFacetBuilder facetBuilder = new StickyFacetBuilder(matchAllQuery(), filters); options.getFacets().stream() .filter(FACET_FACTORIES::containsKey) .map(FACET_FACTORIES::get) .forEach(factory -> factory.addFacet(esSearch, query, facetBuilder)); }
/** * Get the number of documents in the search index * * @return the count of all documents in the index */ public long count(String indexName) { return count(QueryBuilders.constantScoreQuery(QueryBuilders.matchAllQuery()), indexName); }
/** * Create filters based on * the Where clause. * * @param where the 'WHERE' part of the SQL query. * @throws SqlParseException */ private void setWhere(Where where) throws SqlParseException { if (where != null) { QueryBuilder whereQuery = QueryMaker.explan(where); request.filter(whereQuery); } else { request.filter(QueryBuilders.matchAllQuery()); } }
/** * Count the number of documents matching the given {@link Query}. * * @param entityType must not be {@literal null}. * @return a {@link Mono} emitting the nr of matching documents. */ default Mono<Long> count(Class<?> entityType) { return count(new StringQuery(QueryBuilders.matchAllQuery().toString()), entityType, null); }
private QueryBuilder mappedQuery(Query query, ElasticsearchPersistentEntity<?> entity) { // TODO: we need to actually map the fields to the according field names! QueryBuilder elasticsearchQuery = null; if (query instanceof CriteriaQuery) { elasticsearchQuery = new CriteriaQueryProcessor().createQueryFromCriteria(((CriteriaQuery) query).getCriteria()); } else if (query instanceof StringQuery) { elasticsearchQuery = new WrapperQueryBuilder(((StringQuery) query).getSource()); } else if (query instanceof NativeSearchQuery) { elasticsearchQuery = ((NativeSearchQuery) query).getQuery(); } else { throw new IllegalArgumentException(String.format("Unknown query type '%s'.", query.getClass())); } return elasticsearchQuery != null ? elasticsearchQuery : QueryBuilders.matchAllQuery(); }
/** * Completely remove a index with all types */ public void clearIndex(IndexType indexType) { BulkIndexer.delete(esClient, indexType, esClient.prepareSearch(indexType.getIndex()).setQuery(matchAllQuery())); }
public long count(final String index, final String histogram_timefield, final long millis) { try { SearchResponse response = elasticsearchClient.prepareSearch(index) .setSize(0) .setQuery(millis <= 0 ? QueryBuilders.constantScoreQuery(QueryBuilders.matchAllQuery()) : QueryBuilders.rangeQuery(histogram_timefield).from(new Date(System.currentTimeMillis() - millis))) .execute() .actionGet(); return response.getHits().getTotalHits(); } catch (Throwable e) { DAO.severe(e); return 0; } }
@Before public void before() { features.set(q -> matchAllQuery(), ComponentTextSearchFeatureRepertoire.FAVORITE); }
@Before public void before() { features.set(query -> matchAllQuery(), ComponentTextSearchFeatureRepertoire.EXACT_IGNORE_CASE); }
@Before public void before() { features.set(query -> matchAllQuery(), ComponentTextSearchFeatureRepertoire.RECENTLY_BROWSED); }
private static void addRangeFacetIncludingNoData(SearchRequestBuilder esSearch, String metricKey, StickyFacetBuilder facetBuilder, Double... thresholds) { esSearch.addAggregation(createStickyFacet(metricKey, facetBuilder, AggregationBuilders.filter("combined_" + metricKey, matchAllQuery()) .subAggregation(createRangeFacet(metricKey, thresholds)) .subAggregation(createNoDataFacet(metricKey)))); }
private SearchResult<String> searchObjectIdsViaExpression(String structuredQuery, int start, int size, List<String> sortOptions, String freeTextQuery, String docType) { try { // Build query QueryBuilder queryBuilder = QueryBuilders.matchAllQuery(); if(StringUtils.isNotEmpty(structuredQuery)) { Expression expression = Expression.fromString(structuredQuery); queryBuilder = expression.getFilterBuilder(); } BoolQueryBuilder filterQuery = QueryBuilders.boolQuery().must(queryBuilder); QueryStringQueryBuilder stringQuery = QueryBuilders.queryStringQuery(freeTextQuery); BoolQueryBuilder fq = QueryBuilders.boolQuery().must(stringQuery).must(filterQuery); return searchObjectIds(indexName, fq, start, size, sortOptions, docType); } catch (Exception e) { throw new ApplicationException(ApplicationException.Code.BACKEND_ERROR, e.getMessage(), e); } }
@Override protected void after() { if (isCustom) { // delete non-core indices String[] existingIndices = SHARED_NODE.client().admin().indices().prepareGetIndex().get().getIndices(); Stream.of(existingIndices) .filter(i -> !CORE_INDICES_NAMES.contains(i)) .forEach(EsTester::deleteIndexIfExists); } BulkIndexer.delete(client(), new IndexType("_all", ""), client().prepareSearch("_all").setQuery(matchAllQuery())); }
private static QueryBuilder buildActivationFilter(RuleQuery query, QProfileDto profile) { // ActiveRule Filter (profile and inheritance) BoolQueryBuilder activeRuleFilter = boolQuery(); addTermFilter(activeRuleFilter, FIELD_ACTIVE_RULE_PROFILE_UUID, profile.getRulesProfileUuid()); addTermFilter(activeRuleFilter, FIELD_ACTIVE_RULE_INHERITANCE, query.getInheritance()); addTermFilter(activeRuleFilter, FIELD_ACTIVE_RULE_SEVERITY, query.getActiveSeverities()); // ChildQuery QueryBuilder childQuery; if (activeRuleFilter.hasClauses()) { childQuery = activeRuleFilter; } else { childQuery = matchAllQuery(); } return childQuery; }
/** * Returns the active users (at most 3) who are associated to the given SCM account. This method can be used * to detect user conflicts. */ public List<UserDoc> getAtMostThreeActiveUsersForScmAccount(String scmAccount, String organizationUuid) { List<UserDoc> result = new ArrayList<>(); if (!StringUtils.isEmpty(scmAccount)) { SearchRequestBuilder request = esClient.prepareSearch(UserIndexDefinition.INDEX_TYPE_USER) .setQuery(boolQuery().must(matchAllQuery()).filter( boolQuery() .must(termQuery(FIELD_ACTIVE, true)) .must(termQuery(FIELD_ORGANIZATION_UUIDS, organizationUuid)) .should(termQuery(FIELD_LOGIN, scmAccount)) .should(matchQuery(SORTABLE_ANALYZER.subField(FIELD_EMAIL), scmAccount)) .should(matchQuery(SORTABLE_ANALYZER.subField(FIELD_SCM_ACCOUNTS), scmAccount)))) .setSize(3); for (SearchHit hit : request.get().getHits().getHits()) { result.add(new UserDoc(hit.getSourceAsMap())); } } return result; }
public List<String> terms(String fields, @Nullable String query, int size) { TermsAggregationBuilder termsAggregation = AggregationBuilders.terms(AGGREGATION_NAME) .field(fields) .size(size) .minDocCount(1); if (query != null) { termsAggregation.includeExclude(new IncludeExclude(".*" + escapeSpecialRegexChars(query) + ".*", null)); } SearchRequestBuilder request = client .prepareSearch(INDEX_TYPE_RULE, INDEX_TYPE_ACTIVE_RULE) .setQuery(matchAllQuery()) .setSize(0) .addAggregation(termsAggregation); SearchResponse esResponse = request.get(); return EsUtils.termsKeys(esResponse.getAggregations().get(AGGREGATION_NAME)); }
private Terms listTermsMatching(String fieldName, IssueQuery query, @Nullable String textQuery, Terms.Order termsOrder, int size) { SearchRequestBuilder requestBuilder = client .prepareSearch(INDEX_TYPE_ISSUE) // Avoids returning search hits .setSize(0); requestBuilder.setQuery(boolQuery().must(QueryBuilders.matchAllQuery()).filter(createBoolFilter(query))); TermsAggregationBuilder aggreg = AggregationBuilders.terms("_ref") .field(fieldName) .size(size) .order(termsOrder) .minDocCount(1L); if (textQuery != null) { aggreg.includeExclude(new IncludeExclude(format(SUBSTRING_MATCH_REGEXP, escapeSpecialRegexChars(textQuery)), null)); } SearchResponse searchResponse = requestBuilder.addAggregation(aggreg).get(); return searchResponse.getAggregations().get("_ref"); }
@Test public void testCollectElasticsearchQueries() throws Exception { CallStackElement total = Profiler.activateProfiling("total"); client.prepareSearch().setQuery(QueryBuilders.matchAllQuery()).get(); client.prepareSearch().setQuery(QueryBuilders.matchAllQuery()).setSearchType(SearchType.DFS_QUERY_THEN_FETCH).get(); Profiler.stop(); Assert.assertEquals(total.toString(), "POST /_search\n" + "{\"query\":{\"match_all\":{\"boost\":1.0}}} ", total.getChildren().get(0).getSignature()); Assert.assertEquals(total.toString(), "POST /_search?search_type=dfs_query_then_fetch\n" + "{\"query\":{\"match_all\":{\"boost\":1.0}}} ", total.getChildren().get(1).getSignature()); } }
/** * Get all the indexed documents (no paginated results). Results are not sorted. */ public List<SearchHit> getDocuments(IndexType indexType) { SearchRequestBuilder req = SHARED_NODE.client().prepareSearch(indexType.getIndex()).setTypes(indexType.getType()).setQuery(matchAllQuery()); EsUtils.optimizeScrollRequest(req); req.setScroll(new TimeValue(60000)) .setSize(100); SearchResponse response = req.get(); List<SearchHit> result = newArrayList(); while (true) { Iterables.addAll(result, response.getHits()); response = SHARED_NODE.client().prepareSearchScroll(response.getScrollId()).setScroll(new TimeValue(600000)).execute().actionGet(); // Break condition: No hits are returned if (response.getHits().getHits().length == 0) { break; } } return result; }
private SearchResponse searchObjectIdsViaExpression(String indexName, String structuredQuery, int start, int size, List<String> sortOptions, String freeTextQuery, String docType) throws ParserException, IOException { // Build query QueryBuilder queryBuilder = QueryBuilders.matchAllQuery(); if(StringUtils.isNotEmpty(structuredQuery)) { Expression expression = Expression.fromString(structuredQuery); queryBuilder = expression.getFilterBuilder(); } BoolQueryBuilder filterQuery = QueryBuilders.boolQuery().must(queryBuilder); QueryStringQueryBuilder stringQuery = QueryBuilders.queryStringQuery(freeTextQuery); BoolQueryBuilder fq = QueryBuilders.boolQuery().must(stringQuery).must(filterQuery); return searchObjectIds(indexName, fq, start, size, sortOptions, docType); }