private TermsAggregationBuilder buildTermsFacetAggregation(String fieldName, String facetName, int size) { TermsAggregationBuilder termsAggregation = AggregationBuilders.terms(facetName) .field(fieldName) .order(order) .size(size) .minDocCount(FACET_DEFAULT_MIN_DOC_COUNT); if (subAggregation != null) { termsAggregation = termsAggregation.subAggregation(subAggregation); } return termsAggregation; }
.field(FIELD_RULE_EXTENSION_TAGS) .size(size) .order(Terms.Order.term(true)) .minDocCount(1); ofNullable(query)
case "order": if ("asc".equalsIgnoreCase(value)) { terms.order(BucketOrder.key(true)); } else if ("desc".equalsIgnoreCase(value)) { terms.order(BucketOrder.key(false)); } else { List<BucketOrder> orderElements = new ArrayList<>(); throw new SqlParseException("couldn't parse order: " + e.getMessage()); terms.order(orderElements);
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 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"); }
.size(MAX_PAGE_SIZE) .minDocCount(1) .order(Terms.Order.count(false))); request.addAggregation(AggregationBuilders.nested(FIELD_NCLOC_LANGUAGE_DISTRIBUTION, FIELD_NCLOC_LANGUAGE_DISTRIBUTION) .subAggregation(AggregationBuilders.terms(FIELD_NCLOC_LANGUAGE_DISTRIBUTION + "_terms") .size(MAX_PAGE_SIZE) .minDocCount(1) .order(Terms.Order.count(false)) .subAggregation(sum(FIELD_DISTRIB_NCLOC).field(FIELD_DISTRIB_NCLOC))));
String orderName = order.getName(); if (isAliasFiled(orderName)) { termsBuilder.order(BucketOrder.aggregation(orderName, isASC(order))); } else { termsBuilder.order(BucketOrder.count(isASC(order))); termsBuilder.order(BucketOrder.key(isASC(order))); termsBuilder.order(BucketOrder.aggregation(order.getName(), isASC(order))); break; default:
/** * Sets the order in which the buckets will be returned. A tie-breaker may be added to avoid non-deterministic * ordering. */ public TermsAggregationBuilder order(List<BucketOrder> orders) { if (orders == null) { throw new IllegalArgumentException("[orders] must not be null: [" + name + "]"); } // if the list only contains one order use that to avoid inconsistent xcontent order(orders.size() > 1 ? BucketOrder.compound(orders) : orders.get(0)); return this; }
.field(keyField) .subAggregation(AggregationBuilders.stats(AGG_STATS).field(valueField)) .order(termsOrder) .size(size) );
private TermsAggregationBuilder getGroupsTermBuilder(GroupRequest groupRequest, int index) { List<Group> groups = groupRequest.getGroups(); Group group = groups.get(index); String aggregationName = getGroupByAggregationName(group.getField()); TermsAggregationBuilder termsBuilder = AggregationBuilders.terms(aggregationName); termsBuilder .field(group.getField()) .size(accessConfig.getMaxSearchGroups()) .order(getElasticsearchGroupOrder(group.getOrder())); if (index < groups.size() - 1) { termsBuilder.subAggregation(getGroupsTermBuilder(groupRequest, index + 1)); } Optional<String> scoreField = groupRequest.getScoreField(); if (scoreField.isPresent()) { SumAggregationBuilder scoreSumAggregationBuilder = AggregationBuilders.sum(getSumAggregationName(scoreField.get())).field(scoreField.get()).missing(0); termsBuilder.subAggregation(scoreSumAggregationBuilder); } return termsBuilder; }
/** * Sets the order in which the buckets will be returned. */ public TermsAggregationBuilder order(List<Terms.Order> orders) { if (orders == null) { throw new IllegalArgumentException("[orders] must not be null: [" + name + "]"); } order(Terms.Order.compound(orders)); return this; }
/** * Sets the order in which the buckets will be returned. A tie-breaker may be added to avoid non-deterministic * ordering. */ public TermsAggregationBuilder order(List<BucketOrder> orders) { if (orders == null) { throw new IllegalArgumentException("[orders] must not be null: [" + name + "]"); } // if the list only contains one order use that to avoid inconsistent xcontent order(orders.size() > 1 ? BucketOrder.compound(orders) : orders.get(0)); return this; }
/** * Sets the order in which the buckets will be returned. A tie-breaker may be added to avoid non-deterministic * ordering. */ public TermsAggregationBuilder order(List<BucketOrder> orders) { if (orders == null) { throw new IllegalArgumentException("[orders] must not be null: [" + name + "]"); } // if the list only contains one order use that to avoid inconsistent xcontent order(orders.size() > 1 ? BucketOrder.compound(orders) : orders.get(0)); return this; }
private TermsAggregationBuilder buildTermsFacetAggregation(String fieldName, String facetName, int size) { TermsAggregationBuilder termsAggregation = AggregationBuilders.terms(facetName) .field(fieldName) .order(order) .size(size) .minDocCount(FACET_DEFAULT_MIN_DOC_COUNT); if (subAggregation != null) { termsAggregation = termsAggregation.subAggregation(subAggregation); } return termsAggregation; }
private TermsAggregationBuilder createTermsBuilder(String termsFieldName, int termBuckets) { return AggregationBuilders.terms(AGG_BUCKET_KEY_PREFIX + termsFieldName) .field(termsFieldName) .minDocCount(1).shardMinDocCount(1) .shardSize(termBuckets << 1).size(termBuckets).order(Terms.Order.count(false)); }
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()); }
public List<String> listTags(@Nullable OrganizationDto organization, @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(); } BoolQueryBuilder esQuery = boolQuery() .filter(createAuthorizationFilter(true)); if (organization != null) { esQuery.filter(termQuery(FIELD_ISSUE_ORGANIZATION_UUID, organization.getUuid())); } SearchRequestBuilder requestBuilder = client .prepareSearch(INDEX_TYPE_ISSUE) .setQuery(esQuery) .setSize(0); TermsAggregationBuilder termsAggregation = AggregationBuilders.terms(AGGREGATION_NAME_FOR_TAGS) .field(IssueIndexDefinition.FIELD_ISSUE_TAGS) .size(size) .order(Terms.Order.term(true)) .minDocCount(1L); if (textQuery != null) { String escapedTextQuery = escapeSpecialRegexChars(textQuery); termsAggregation.includeExclude(new IncludeExclude(format(SUBSTRING_MATCH_REGEXP, escapedTextQuery), null)); } requestBuilder.addAggregation(termsAggregation); SearchResponse searchResponse = requestBuilder.get(); Terms issuesResult = searchResponse.getAggregations().get(AGGREGATION_NAME_FOR_TAGS); return EsUtils.termsKeys(issuesResult); }
private Terms listTermsMatching(String fieldName, IssueQuery query, @Nullable String textQuery, Terms.Order termsOrder, int maxNumberOfTags) { 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(maxNumberOfTags) .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"); }