/** * Add from and size to the ES query based on the 'LIMIT' clause * * @param from * starts from document at position from * @param size * number of documents to return. */ private void setLimit(int from, int size) { request.setFrom(from); if (size > -1) { request.setSize(size); } }
private static void setPagination(SearchOptions options, SearchRequestBuilder esSearch) { esSearch.setFrom(options.getOffset()); esSearch.setSize(options.getLimit()); }
private static void configurePagination(SearchOptions options, SearchRequestBuilder esSearch) { esSearch.setFrom(options.getOffset()).setSize(options.getLimit()); }
private void setLimitFromHint(List<Hint> hints) { int from = 0; int size = 0; for (Hint hint : hints) { if (hint.getType() == HintType.DOCS_WITH_AGGREGATION) { Integer[] params = (Integer[]) hint.getParams(); if (params.length > 1) { // if 2 or more are given, use the first as the from and the second as the size // so it is the same as LIMIT from,size // except written as /*! DOCS_WITH_AGGREGATION(from,size) */ from = params[0]; size = params[1]; } else if (params.length == 1) { // if only 1 parameter is given, use it as the size with a from of 0 size = params[0]; } break; } } request.setFrom(from); request.setSize(size); }
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); } }
public List<Map<String, Object>> queryWithConstraints(final String indexName, final String fieldName, final String fieldValue, final Map<String, String> constraints, boolean latest) throws IOException { SearchRequestBuilder request = this.elasticsearchClient.prepareSearch(indexName) .setSearchType(SearchType.QUERY_THEN_FETCH) .setFrom(0); BoolQueryBuilder bFilter = QueryBuilders.boolQuery(); bFilter.filter(QueryBuilders.constantScoreQuery(QueryBuilders.constantScoreQuery(QueryBuilders.termQuery(fieldName, fieldValue)))); for (Object o : constraints.entrySet()) { @SuppressWarnings("rawtypes") Map.Entry entry = (Map.Entry) o; bFilter.filter(QueryBuilders.constantScoreQuery(QueryBuilders.termQuery((String) entry.getKey(), ((String) entry.getValue()).toLowerCase()))); } request.setQuery(bFilter); // get response SearchResponse response = request.execute().actionGet(); // evaluate search result ArrayList<Map<String, Object>> result = new ArrayList<Map<String, Object>>(); SearchHit[] hits = response.getHits().getHits(); for (SearchHit hit: hits) { Map<String, Object> map = hit.getSource(); result.add(map); } return result; }
private Map<String, Object> getRivers(int page, int count, Client esClient) { int from = (page - 1) * count; SearchResponse searchResponse = esClient.prepareSearch(riverIndexName) .setQuery(QueryBuilders.queryString(MongoDBRiver.TYPE).defaultField("type")).setFrom(from).setSize(count).get(); long totalHits = searchResponse.getHits().totalHits(); logger.trace("totalHits: {}", totalHits);
/** * 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(); }
@Override public Iterable<RawQuery.Result<String>> query(RawQuery query, KeyInformation.IndexRetriever informations, BaseTransaction tx) throws BackendException { SearchRequestBuilder srb = client.prepareSearch(indexName); srb.setTypes(query.getStore()); srb.setQuery(QueryBuilders.queryStringQuery(query.getQuery())); srb.setFrom(query.getOffset()); if (query.hasLimit()) srb.setSize(query.getLimit()); else srb.setSize(maxResultsSize); srb.setNoFields(); //srb.setExplain(true); SearchResponse response = srb.execute().actionGet(); log.debug("Executed query [{}] in {} ms", query.getQuery(), response.getTookInMillis()); SearchHits hits = response.getHits(); if (!query.hasLimit() && hits.totalHits() >= maxResultsSize) log.warn("Query result set truncated to first [{}] elements for query: {}", maxResultsSize, query); List<RawQuery.Result<String>> result = new ArrayList<RawQuery.Result<String>>(hits.hits().length); for (SearchHit hit : hits) { result.add(new RawQuery.Result<String>(hit.id(),hit.getScore())); } return result; }
public LinkedHashMap<String, Long> fullDateHistogram(final String indexName, int timezoneOffset, String histogram_timefield) { // prepare request SearchRequestBuilder request = elasticsearchClient.prepareSearch(indexName) .setSearchType(SearchType.QUERY_THEN_FETCH) .setQuery(QueryBuilders.constantScoreQuery(QueryBuilders.matchAllQuery())) .setFrom(0) .setSize(0); request.clearRescorers(); request.addAggregation(AggregationBuilders.dateHistogram(histogram_timefield).field(histogram_timefield).timeZone("UTC").minDocCount(1).interval(DateHistogramInterval.DAY)); // get response SearchResponse response = request.execute().actionGet(); // evaluate date histogram: InternalHistogram<InternalHistogram.Bucket> dateCounts = response.getAggregations().get(histogram_timefield); LinkedHashMap<String, Long> list = new LinkedHashMap<>(); for (InternalHistogram.Bucket bucket : dateCounts.getBuckets()) { Calendar cal = Calendar.getInstance(DateParser.UTCtimeZone); org.joda.time.DateTime k = (org.joda.time.DateTime) bucket.getKey(); cal.setTime(k.toDate()); cal.add(Calendar.MINUTE, -timezoneOffset); long docCount = bucket.getDocCount(); list.put(DateParser.dayDateFormat.format(cal.getTime()), docCount); } return list; }
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()); }
.setSearchType(SearchType.QUERY_THEN_FETCH) .setQuery(queryBuilder) .setFrom(0) .setSize(resultCount); request.clearRescorers();
/** * Get the search request builder */ public SearchRequestBuilder getBuilder( final SearchEdge searchEdge, final SearchTypes searchTypes, final QueryVisitor visitor, final int limit, final int from, final List<SortPredicate> sortPredicates, final Map<String, Class> fieldsWithType ) { Preconditions .checkArgument( limit <= EntityIndex.MAX_LIMIT, "limit is greater than max " + EntityIndex.MAX_LIMIT ); Preconditions.checkNotNull( visitor, "query visitor cannot be null"); SearchRequestBuilder srb = esProvider.getClient().prepareSearch( alias.getReadAlias() ).setTypes( IndexingUtils.ES_ENTITY_TYPE ) .setSearchType( SearchType.QUERY_THEN_FETCH ); final Optional<QueryBuilder> queryBuilder = visitor.getQueryBuilder(); if ( queryBuilder.isPresent() ) { srb.setQuery( queryBuilder.get() ); } srb.setPostFilter( createFilterBuilder( searchEdge, visitor, searchTypes ) ); srb = srb.setFrom( from ).setSize( limit ); //if we have a geo field, sort by closest to farthest by default final GeoSortFields geoFields = visitor.getGeoSorts(); //no sort predicates, sort by edge time descending, entity id second if ( sortPredicates.size() == 0 ) { applyDefaultSortPredicates( srb, geoFields ); } else { applySortPredicates( srb, sortPredicates, geoFields, fieldsWithType ); } return srb; }
private SearchResult<String> search(String indexName, String structuredQuery, int start, int size, List<String> sortOptions, String freeTextQuery, String docType) { try { 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); final SearchRequestBuilder srb = elasticSearchClient.prepareSearch(indexName) .setQuery(fq) .setTypes(docType) .storedFields("_id") .setFrom(start) .setSize(size); if (sortOptions != null) { sortOptions.forEach(sortOption -> addSortOptionToSearchRequest(srb, sortOption)); } SearchResponse response = srb.get(); LinkedList<String> result = StreamSupport.stream(response.getHits().spliterator(), false) .map(SearchHit::getId) .collect(Collectors.toCollection(LinkedList::new)); long count = response.getHits().getTotalHits(); return new SearchResult<String>(count, result); } catch (ParserException e) { throw new ApplicationException(Code.BACKEND_ERROR, e.getMessage(), e); } }
public Map<String, Object> query(final String indexName, final String fieldKey, final String fieldValue) { if (fieldKey == null || fieldValue.length() == 0) return null; // prepare request BoolQueryBuilder query = QueryBuilders.boolQuery(); query.filter(QueryBuilders.constantScoreQuery(QueryBuilders.termQuery(fieldKey, fieldValue))); SearchRequestBuilder request = elasticsearchClient.prepareSearch(indexName) .setSearchType(SearchType.QUERY_THEN_FETCH) .setQuery(query) .setFrom(0) .setSize(1) .setTerminateAfter(1); // get response SearchResponse response = request.execute().actionGet(); // evaluate search result SearchHit[] hits = response.getHits().getHits(); if (hits.length == 0) return null; assert hits.length == 1; Map<String, Object> map = hits[0].getSource(); return map; }
srb.setFrom(0); if (query.hasLimit()) srb.setSize(query.getLimit()); else srb.setSize(maxResultsSize);
public SearchResult<UserDoc> search(UserQuery userQuery, SearchOptions options) { SearchRequestBuilder request = esClient.prepareSearch(UserIndexDefinition.INDEX_TYPE_USER) .setSize(options.getLimit()) .setFrom(options.getOffset()) .addSort(FIELD_NAME, SortOrder.ASC); BoolQueryBuilder filter = boolQuery().must(termQuery(FIELD_ACTIVE, true)); userQuery.getOrganizationUuid() .ifPresent(o -> filter.must(termQuery(FIELD_ORGANIZATION_UUIDS, o))); userQuery.getExcludedOrganizationUuid() .ifPresent(o -> filter.mustNot(termQuery(FIELD_ORGANIZATION_UUIDS, o))); QueryBuilder esQuery = matchAllQuery(); Optional<String> textQuery = userQuery.getTextQuery(); if (textQuery.isPresent()) { esQuery = QueryBuilders.multiMatchQuery(textQuery.get(), FIELD_LOGIN, USER_SEARCH_GRAMS_ANALYZER.subField(FIELD_LOGIN), FIELD_NAME, USER_SEARCH_GRAMS_ANALYZER.subField(FIELD_NAME), FIELD_EMAIL, USER_SEARCH_GRAMS_ANALYZER.subField(FIELD_EMAIL)) .operator(Operator.AND); } request.setQuery(boolQuery().must(esQuery).filter(filter)); return new SearchResult<>(request.get(), UserDoc::new, system2.getDefaultTimeZone()); }
.setSearchType(SearchType.QUERY_THEN_FETCH) .setQuery(query) .setFrom(0) .setSize(resultCount) .addSort(
private SearchResponse search(String indexName, String structuredQuery, int start, int size, String freeTextQuery, String docType) throws ParserException { 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); final SearchRequestBuilder srb = elasticSearchClient.prepareSearch(indexName) .setQuery(fq) .setTypes(docType) .storedFields("_id") .setFrom(start) .setSize(size); return srb.get(); }
public SearchIdResult<String> search(ComponentQuery query, SearchOptions searchOptions) { SearchRequestBuilder requestBuilder = client .prepareSearch(INDEX_TYPE_COMPONENT) .setFetchSource(false) .setFrom(searchOptions.getOffset()) .setSize(searchOptions.getLimit()); BoolQueryBuilder esQuery = boolQuery(); esQuery.filter(authorizationTypeSupport.createQueryFilter()); setNullable(query.getQuery(), q -> { ComponentTextSearchQuery componentTextSearchQuery = ComponentTextSearchQuery.builder() .setQueryText(q) .setFieldKey(FIELD_KEY) .setFieldName(FIELD_NAME) .build(); esQuery.must(ComponentTextSearchQueryFactory.createQuery(componentTextSearchQuery, ComponentTextSearchFeatureRepertoire.values())); }); setEmptiable(query.getQualifiers(), q -> esQuery.must(termsQuery(FIELD_QUALIFIER, q))); setNullable(query.getLanguage(), l -> esQuery.must(termQuery(FIELD_LANGUAGE, l))); setNullable(query.getOrganizationUuid(), o -> esQuery.must(termQuery(FIELD_ORGANIZATION_UUID, o))); requestBuilder.setQuery(esQuery); requestBuilder.addSort(SORTABLE_ANALYZER.subField(FIELD_NAME), SortOrder.ASC); return new SearchIdResult<>(requestBuilder.get(), id -> id, system2.getDefaultTimeZone()); }