/** * Get the number of documents in the search index for a given search query * * @param q * the query * @return the count of all documents in the index which matches with the query */ private long count(final QueryBuilder q, final String indexName) { SearchResponse response = elasticsearchClient.prepareSearch(indexName).setQuery(q).setSize(0).execute().actionGet(); return response.getHits().getTotalHits(); }
public SearchRequestBuilder buildScrollSearchRequest() { String indices = index != null && !index.isEmpty() ? index : "_all"; List<String> fields = columns.stream() .map(ElasticsearchColumnHandle::getColumnName) .collect(toList()); SearchRequestBuilder searchRequestBuilder = client.prepareSearch(indices) .setTypes(type) .setSearchType(QUERY_THEN_FETCH) .setScroll(new TimeValue(scrollTimeout.toMillis())) .setFetchSource(fields.toArray(new String[0]), null) .setQuery(buildSearchQuery()) .setPreference("_shards:" + shard) .setSize(scrollSize); LOG.debug("Elasticsearch Request: %s", searchRequestBuilder); return searchRequestBuilder; }
refreshIfNeeded(); final RangeQueryBuilder query = new RangeQueryBuilder(KEY).gte(startkey); final SearchResponse response = client.prepareSearch(indexKey).setQuery(query).setSize(recordcount).get(); for (final SearchHit hit : response.getHits()) { final HashMap<String, ByteIterator> entry; if (fields != null) {
private OptionalLong getMinCreatedAt(Map<String, QueryBuilder> filters, QueryBuilder esQuery) { String facetNameAndField = CREATED_AT.getFieldName(); SearchRequestBuilder esRequest = client .prepareSearch(INDEX_TYPE_ISSUE) .setSize(0); BoolQueryBuilder esFilter = boolQuery(); filters.values().stream().filter(Objects::nonNull).forEach(esFilter::must); if (esFilter.hasClauses()) { esRequest.setQuery(QueryBuilders.boolQuery().must(esQuery).filter(esFilter)); } else { esRequest.setQuery(esQuery); } esRequest.addAggregation(AggregationBuilders.min(facetNameAndField).field(facetNameAndField)); Min minValue = esRequest.get().getAggregations().get(facetNameAndField); double actualValue = minValue.getValue(); if (Double.isInfinite(actualValue)) { return OptionalLong.empty(); } return OptionalLong.of((long)actualValue); }
SearchRequestBuilder searchRequestBuilder = new SearchRequestBuilder(client); searchRequestBuilder.setIndices("mongoindex"); searchRequestBuilder.setTypes("files"); QueryStringQueryBuilder queryStringQueryBuilder = new QueryStringQueryBuilder("anyword"); queryStringQueryBuilder.field("file.file"); searchRequestBuilder.setQuery(queryStringQueryBuilder); SearchResponse response = searchRequestBuilder.execute().actionGet();
public long countLocal(final String index, final String provider_hash) { try { SearchResponse response = elasticsearchClient.prepareSearch(index) .setSize(0) .setQuery(QueryBuilders.matchQuery("provider_hash", provider_hash)) .execute() .actionGet(); return response.getHits().getTotalHits(); } catch (Throwable e) { DAO.severe(e); return 0; } }
@VisibleForTesting ComponentIndexResults searchSuggestions(SuggestionQuery query, ComponentTextSearchFeature... features) { Collection<String> qualifiers = query.getQualifiers(); if (qualifiers.isEmpty()) { return ComponentIndexResults.newBuilder().build(); } SearchRequestBuilder request = client .prepareSearch(INDEX_TYPE_COMPONENT) .setQuery(createQuery(query, features)) .addAggregation(createAggregation(query)) // the search hits are part of the aggregations .setSize(0); SearchResponse response = request.get(); return aggregationsToQualifiers(response); }
public List<String> findAllViewUuids() { SearchRequestBuilder esSearch = esClient.prepareSearch(ViewIndexDefinition.INDEX_TYPE_VIEW) .addSort("_doc", SortOrder.ASC) .setScroll(TimeValue.timeValueMinutes(SCROLL_TIME_IN_MINUTES)) .setFetchSource(false) .setSize(100) .setQuery(matchAllQuery()); SearchResponse response = esSearch.get(); List<String> result = newArrayList(); while (true) { List<SearchHit> hits = newArrayList(response.getHits()); for (SearchHit hit : hits) { result.add(hit.getId()); } String scrollId = response.getScrollId(); response = esClient.prepareSearchScroll(scrollId) .setScroll(TimeValue.timeValueMinutes(SCROLL_TIME_IN_MINUTES)) .get(); // Break condition: No hits are returned if (response.getHits().getHits().length == 0) { esClient.nativeClient().prepareClearScroll().addScrollId(scrollId).get(); break; } } return result; } }
protected SearchRequestBuilder addFindContentQueueRequestParams(SearchRequestBuilder searchRequestBuilder) { return searchRequestBuilder .setQuery(matchAllQuery()) .setTypes(indexedDocumentType) .setPostFilter( orFilter( missingFilter(SearchService.FIELD_INDEXED), termFilter(SearchService.FIELD_INDEXED, false))) .setSize(contentIndexBatchSize) .addFields(SearchService.FIELD_REFERENCE, SearchService.FIELD_SITEID); }
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; } }
/** * 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; }
protected SearchRequestBuilder getSearchRequestBuilder(List<FilterBuilder> filters, QueryBuilder queryBuilder) { AndFilterBuilder filterBuilder = getFilterBuilder(filters); return getClient() .prepareSearch(getIndicesToQuery()) .setTypes(ElasticSearchSearchIndexBase.ELEMENT_TYPE) .setQuery(QueryBuilders.filteredQuery(queryBuilder, filterBuilder)) .setFrom((int) getParameters().getSkip()) .setSize((int) getParameters().getLimit()); }
try { final RangeQueryBuilder rangeQuery = rangeQuery("_id").gte(startkey); final SearchResponse response = client.prepareSearch(indexKey) .setTypes(table) .setQuery(rangeQuery) .setSize(recordcount) .execute() .actionGet(); for (SearchHit hit : response.getHits()) { entry = new HashMap<>(fields.size()); for (String field : fields) {
public SearchIdResult<String> search(ProjectMeasuresQuery query, SearchOptions searchOptions) { SearchRequestBuilder requestBuilder = client .prepareSearch(INDEX_TYPE_PROJECT_MEASURES) .setFetchSource(false) .setFrom(searchOptions.getOffset()) .setSize(searchOptions.getLimit()); BoolQueryBuilder esFilter = boolQuery(); Map<String, QueryBuilder> filters = createFilters(query); filters.values().forEach(esFilter::must); requestBuilder.setQuery(esFilter); addFacets(requestBuilder, searchOptions, filters, query); addSort(query, requestBuilder); return new SearchIdResult<>(requestBuilder.get(), id -> id, system2.getDefaultTimeZone()); }
.prepareSearch(INDEX_TYPE_PROJECT_MEASURES) .setFetchSource(false) .setSize(0); request.setQuery(esFilter); request.addAggregation(AggregationBuilders.terms(FIELD_LANGUAGES) .field(FIELD_LANGUAGES) statistics.setProjectCount(response.getHits().getTotalHits()); Stream.of(NCLOC_KEY) .map(metric -> (Nested) response.getAggregations().get(metric))
/** * Get a search response for predefined aggregation task on a specific index. * @param index Name of ES index * @param aggr Pre-configured AggregationBuilder object * @return HashMap with parsed aggregations */ private SearchResponse getAggregationResponse(String index, @SuppressWarnings("rawtypes") AggregationBuilder aggr) { return this.elasticsearchClient.prepareSearch(index) .setSearchType(SearchType.QUERY_THEN_FETCH) .setQuery(QueryBuilders.matchAllQuery()) .setFrom(0) .setSize(0) .addAggregation(aggr) .execute().actionGet(); }
public List<String> searchTags(@Nullable String textQuery, int size) { int maxPageSize = 500; checkArgument(size <= maxPageSize, "Page size must be lower than or equals to " + maxPageSize); if (size <= 0) { return emptyList(); } TermsAggregationBuilder tagFacet = AggregationBuilders.terms(FIELD_TAGS) .field(FIELD_TAGS) .size(size) .minDocCount(1) .order(Terms.Order.term(true)); if (textQuery != null) { tagFacet.includeExclude(new IncludeExclude(".*" + escapeSpecialRegexChars(textQuery) + ".*", null)); } SearchRequestBuilder searchQuery = client .prepareSearch(INDEX_TYPE_PROJECT_MEASURES) .setQuery(authorizationTypeSupport.createQueryFilter()) .setFetchSource(false) .setSize(0) .addAggregation(tagFacet); Terms aggregation = searchQuery.get().getAggregations().get(FIELD_TAGS); return aggregation.getBuckets().stream() .map(Bucket::getKeyAsString) .collect(MoreCollectors.toList()); }
private Query(final String indexName, QueryBuilder queryBuilder, String order_field, int resultCount) { //TODO: sort data using order_field // prepare request SearchRequestBuilder request = elasticsearchClient.prepareSearch(indexName) .setSearchType(SearchType.QUERY_THEN_FETCH) .setQuery(queryBuilder) .setFrom(0) .setSize(resultCount); request.clearRescorers(); // get response SearchResponse response = request.execute().actionGet(); hitCount = (int) response.getHits().getTotalHits(); // evaluate search result SearchHit[] hits = response.getHits().getHits(); this.result = new ArrayList<Map<String, Object>>(hitCount); for (SearchHit hit: hits) { Map<String, Object> map = hit.getSource(); this.result.add(map); } }