private AbstractAggregationBuilder addFieldOrScriptToAggregation( MethodField field, ValuesSourceMetricsAggregationBuilder builder) { KVValue kvValue = field.getParams().get(0); if (kvValue.key != null && kvValue.key.equals("script")) { // todo: support different lang script return builder.script(((MethodField) kvValue.value).getParams().get(1).toString()); } else if (kvValue.key != null && (kvValue.key.equals("nested") || kvValue.key.equals("reverse_nested"))) { NestedType nestedType = (NestedType) kvValue.value; builder.field(nestedType.field); AggregationBuilder nestedBuilder; String nestedAggName = nestedType.field + "@NESTED"; if (nestedType.isReverse()) { if (nestedType.path != null && nestedType.path.startsWith("~")) { String realPath = nestedType.path.substring(1); nestedBuilder = AggregationBuilders.nested(nestedAggName).path(realPath); nestedBuilder = nestedBuilder.subAggregation(builder); return AggregationBuilders.reverseNested(nestedAggName + "_REVERSED") .subAggregation(nestedBuilder); } else { nestedBuilder = AggregationBuilders.reverseNested(nestedAggName).path(nestedType.path); } } else { nestedBuilder = AggregationBuilders.nested(nestedAggName).path(nestedType.path); } return nestedBuilder.subAggregation(builder); } return builder.field(kvValue.toString()); }
/* * 统计每种兴趣下职工的平均年龄 * 聚合也允许分级汇总 */ @Test public void subAggregationTest() { Client client = ClientTemplate.getClient(); SearchResponse response = client .prepareSearch("fccs") .setTypes("employee") .addAggregation( AggregationBuilders.terms("by_interests") .field("interests") .subAggregation(AggregationBuilders.avg("avg_age").field("age"))) .get(); Terms terms = response.getAggregations().get("by_interests"); List<Bucket> buckets = terms.getBuckets(); for (Bucket bucket : buckets) { Avg avg = bucket.getAggregations().get("avg_age"); System.out.println( "key:" + bucket.getKey() + " doc_count:" + bucket.getDocCount() + " avg_age:" + avg.getValue()); } client.close(); }
void assertBasicAggregationWorks(String indexName) { // histogram on a long SearchResponse searchRsp = client() .prepareSearch(indexName) .addAggregation(AggregationBuilders.histogram("histo").field("long_sort").interval(10)) .get(); ElasticsearchAssertions.assertSearchResponse(searchRsp); Histogram histo = searchRsp.getAggregations().get("histo"); assertNotNull(histo); long totalCount = 0; for (Histogram.Bucket bucket : histo.getBuckets()) { totalCount += bucket.getDocCount(); } assertEquals(totalCount, searchRsp.getHits().getTotalHits()); // terms on a boolean searchRsp = client() .prepareSearch(indexName) .addAggregation(AggregationBuilders.terms("bool_terms").field("bool")) .get(); Terms terms = searchRsp.getAggregations().get("bool_terms"); totalCount = 0; for (Terms.Bucket bucket : terms.getBuckets()) { totalCount += bucket.getDocCount(); } assertEquals(totalCount, searchRsp.getHits().getTotalHits()); }
private AggregationBuilder createNestedAggregation(Field field) { AggregationBuilder nestedBuilder; String nestedPath = field.getNestedPath(); if (field.isReverseNested()) { if (nestedPath == null || !nestedPath.startsWith("~")) return AggregationBuilders.reverseNested(getNestedAggName(field)).path(nestedPath); nestedPath = nestedPath.substring(1); } nestedBuilder = AggregationBuilders.nested(getNestedAggName(field)).path(nestedPath); return nestedBuilder; }
public void run() { Client client = null; TransportClient transportClient = null; try { transportClient = new TransportClient(); client = transportClient.addTransportAddress(new InetSocketTransportAddress("192.168.1.40", 9300)); SearchResponse response = client .prepareSearch("tms-allflat") .setTypes("personal") .setQuery(QueryBuilders.matchAllQuery()) .addAggregation( AggregationBuilders.terms("aggs1") .field("skill_1") .size(20) .order(Terms.Order.count(false))) .execute() .actionGet(); Terms terms = response.getAggregations().get("aggs1"); terms .getBuckets() .stream() .forEach(s -> System.out.println(s.getKeyAsText() + "(" + s.getDocCount() + ")")); } finally { transportClient.close(); client.close(); } }
@Test public void givenAnalyzedQuery_whenMakeAggregationOnTermCount_thenEachTokenCountsSeparately() { TermsBuilder aggregation = AggregationBuilders.terms("top_tags").field("title"); SearchResponse response = client .prepareSearch("blog") .setTypes("article") .addAggregation(aggregation) .execute() .actionGet(); Map<String, Aggregation> results = response.getAggregations().asMap(); StringTerms topTags = (StringTerms) results.get("top_tags"); List<String> keys = topTags.getBuckets().stream().map(b -> b.getKey()).collect(toList()); Collections.sort(keys); assertEquals( asList( "about", "article", "data", "elasticsearch", "engines", "search", "second", "spring", "tutorial"), keys); }
private ValuesSourceAggregationBuilder<?> dateRange(MethodField field) { String alias = gettAggNameFromParamsOrAlias(field); DateRangeBuilder dateRange = AggregationBuilders.dateRange(alias).format(TIME_FARMAT); String value = null; List<String> ranges = new ArrayList<>(); for (KVValue kv : field.getParams()) { value = kv.value.toString(); if ("field".equals(kv.key)) { dateRange.field(value); continue; } else if ("format".equals(kv.key)) { dateRange.format(value); continue; } else if ("from".equals(kv.key)) { dateRange.addUnboundedFrom(kv.value); continue; } else if ("to".equals(kv.key)) { dateRange.addUnboundedTo(kv.value); continue; } else if ("alias".equals(kv.key)) { continue; } else { ranges.add(value); } } for (int i = 1; i < ranges.size(); i++) { dateRange.addRange(ranges.get(i - 1), ranges.get(i)); } return dateRange; }
private AggregationBuilder<?> termsAgg(MethodField field) throws SqlParseException { String aggName = gettAggNameFromParamsOrAlias(field); TermsBuilder terms = AggregationBuilders.terms(aggName); String value = null; for (KVValue kv : field.getParams()) { value = kv.value.toString(); switch (kv.key.toLowerCase()) { case "field": terms.field(value); break; case "size": terms.size(Integer.parseInt(value)); break; case "shard_size": terms.shardSize(Integer.parseInt(value)); break; case "min_doc_count": terms.minDocCount(Integer.parseInt(value)); break; case "alias": case "nested": case "reverse_nested": break; default: throw new SqlParseException("terms aggregation err or not define field " + kv.toString()); } } return terms; }
private AggregationBuilder<?> geohashGrid(MethodField field) throws SqlParseException { String aggName = gettAggNameFromParamsOrAlias(field); GeoHashGridBuilder geoHashGrid = AggregationBuilders.geohashGrid(aggName); String value = null; for (KVValue kv : field.getParams()) { value = kv.value.toString(); switch (kv.key.toLowerCase()) { case "precision": geoHashGrid.precision(Integer.parseInt(value)); break; case "field": geoHashGrid.field(value); break; case "size": geoHashGrid.size(Integer.parseInt(value)); break; case "shard_size": geoHashGrid.shardSize(Integer.parseInt(value)); break; case "alias": case "nested": case "reverse_nested": break; default: throw new SqlParseException("geohash grid err or not define field " + kv.toString()); } } return geoHashGrid; }
public Map<String, Long> countByField(IndexField indexField, FilterBuilder filter) { Map<String, Long> counts = new HashMap<>(); SearchRequestBuilder request = client .prepareSearch(this.getIndexName()) .setTypes(this.getIndexType()) .setQuery(QueryBuilders.filteredQuery(QueryBuilders.matchAllQuery(), filter)) .setSize(0) .addAggregation( AggregationBuilders.terms(indexField.field()) .field(indexField.field()) .order(Terms.Order.count(false)) .size(Integer.MAX_VALUE) .minDocCount(0)); SearchResponse response = request.get(); Terms values = response.getAggregations().get(indexField.field()); for (Terms.Bucket value : values.getBuckets()) { counts.put(value.getKey(), value.getDocCount()); } return counts; }
public void testDisabledAggsDynamicScripts() { // dynamic scripts don't need to be enabled for an indexed script to be indexed and later on // executed assertAcked( client() .admin() .cluster() .preparePutStoredScript() .setScriptLang(GroovyScriptEngineService.NAME) .setId("script1") .setSource(new BytesArray("{\"script\":\"2\"}"))); client().prepareIndex("test", "scriptTest", "1").setSource("{\"theField\":\"foo\"}").get(); refresh(); SearchResponse searchResponse = client() .prepareSearch("test") .setSource( new SearchSourceBuilder() .aggregation( AggregationBuilders.terms("test") .script(new Script("script1", ScriptType.STORED, null, null)))) .get(); assertHitCount(searchResponse, 1); assertThat(searchResponse.getAggregations().get("test"), notNullValue()); }
@Override @CheckForNull public Date getLastSynchronization(Map<String, String> params) { SearchRequestBuilder request = client .prepareSearch(this.getIndexName()) .setTypes(this.getIndexType()) .setQuery( QueryBuilders.filteredQuery( QueryBuilders.matchAllQuery(), getLastSynchronizationBuilder(params))) .setSize(0) .addAggregation( AggregationBuilders.max("latest").field(BaseNormalizer.UPDATED_AT_FIELD)); SearchResponse response = request.get(); Max max = response.getAggregations().get("latest"); if (max.getValue() > 0) { Date date = new DateTime((long) max.getValue()).toDate(); LOG.debug( "Index {}:{} has last update of {}", this.getIndexName(), this.getIndexType(), date); return date; } else { LOG.debug("Index {}:{} has no last update date", this.getIndexName(), this.getIndexType()); return null; } }
@Test public void testDynamicTemplateCopyTo() throws Exception { assertAcked( client() .admin() .indices() .prepareCreate("test-idx") .addMapping("doc", createDynamicTemplateMapping())); int recordCount = between(1, 200); for (int i = 0; i < recordCount * 2; i++) { client() .prepareIndex("test-idx", "doc", Integer.toString(i)) .setSource("test_field", "test " + i, "even", i % 2 == 0) .get(); } client().admin().indices().prepareRefresh("test-idx").execute().actionGet(); SubAggCollectionMode aggCollectionMode = randomFrom(SubAggCollectionMode.values()); SearchResponse response = client() .prepareSearch("test-idx") .setQuery(QueryBuilders.termQuery("even", true)) .addAggregation( AggregationBuilders.terms("test") .field("test_field") .size(recordCount * 2) .collectMode(aggCollectionMode)) .addAggregation( AggregationBuilders.terms("test_raw") .field("test_field_raw") .size(recordCount * 2) .collectMode(aggCollectionMode)) .execute() .actionGet(); assertThat(response.getHits().totalHits(), equalTo((long) recordCount)); assertThat( ((Terms) response.getAggregations().get("test")).getBuckets().size(), equalTo(recordCount + 1)); assertThat( ((Terms) response.getAggregations().get("test_raw")).getBuckets().size(), equalTo(recordCount)); }
private AbstractAggregationBuilder wrapNestedIfNeeded( AggregationBuilder nestedBuilder, boolean reverseNested) { if (!reverseNested) return nestedBuilder; if (reverseNested && !(nestedBuilder instanceof NestedBuilder)) return nestedBuilder; // we need to jump back to root return AggregationBuilders.reverseNested(nestedBuilder.getName() + "_REVERSED") .subAggregation(nestedBuilder); }
/** * 分组查的聚合函数 * * @param field * @return * @throws SqlParseException */ public AggregationBuilder<?> makeGroupAgg(Field field) throws SqlParseException { if (field instanceof MethodField) { MethodField methodField = (MethodField) field; if (methodField.getName().equals("filter")) { Map<String, Object> paramsAsMap = methodField.getParamsAsMap(); Where where = (Where) paramsAsMap.get("where"); return AggregationBuilders.filter(paramsAsMap.get("alias").toString()) .filter(FilterMaker.explan(where)); } return makeRangeGroup(methodField); } else { TermsBuilder termsBuilder = AggregationBuilders.terms(field.getName()).field(field.getName()); groupMap.put(field.getName(), new KVValue("KEY", termsBuilder)); return termsBuilder; } }
private AggregationBuilder<?> updateAggIfNested(AggregationBuilder<?> lastAgg, Field field) { if (field.isNested()) { lastAgg = AggregationBuilders.nested(field.getName() + "Nested") .path(field.getNestedPath()) .subAggregation(lastAgg); } return lastAgg; }
/** * Create count aggregation. * * @param field The count function * @return AggregationBuilder use to count result */ private AbstractAggregationBuilder makeCountAgg(MethodField field) { // Cardinality is approximate DISTINCT. if ("DISTINCT".equals(field.getOption())) { return AggregationBuilders.cardinality(field.getAlias()) .precisionThreshold(40000) .field(field.getParams().get(0).value.toString()); } String fieldName = field.getParams().get(0).value.toString(); // In case of count(*) we use '_index' as field parameter to count all documents if ("*".equals(fieldName)) { return AggregationBuilders.count(field.getAlias()).field("_index"); } else { return AggregationBuilders.count(field.getAlias()).field(fieldName); } }
public Map<QualityProfileKey, Multimap<String, FacetValue>> getStatsByProfileKey( List<QualityProfileKey> keys) { String[] stringKeys = new String[keys.size()]; for (int i = 0; i < keys.size(); i++) { stringKeys[i] = keys.get(i).toString(); } SearchResponse response = getClient() .prepareSearch(this.getIndexName()) .setQuery( QueryBuilders.filteredQuery( QueryBuilders.matchAllQuery(), FilterBuilders.termsFilter( ActiveRuleNormalizer.ActiveRuleField.PROFILE_KEY.field(), stringKeys))) .addAggregation( AggregationBuilders.terms(ActiveRuleNormalizer.ActiveRuleField.PROFILE_KEY.field()) .field(ActiveRuleNormalizer.ActiveRuleField.PROFILE_KEY.field()) .subAggregation( AggregationBuilders.terms( ActiveRuleNormalizer.ActiveRuleField.INHERITANCE.field()) .field(ActiveRuleNormalizer.ActiveRuleField.INHERITANCE.field())) .subAggregation( AggregationBuilders.terms( ActiveRuleNormalizer.ActiveRuleField.SEVERITY.field()) .field(ActiveRuleNormalizer.ActiveRuleField.SEVERITY.field()))) .setSize(0) .setTypes(this.getIndexType()) .get(); Map<QualityProfileKey, Multimap<String, FacetValue>> stats = new HashMap<QualityProfileKey, Multimap<String, FacetValue>>(); Aggregation aggregation = response.getAggregations().get(ActiveRuleNormalizer.ActiveRuleField.PROFILE_KEY.field()); for (Terms.Bucket value : ((Terms) aggregation).getBuckets()) { stats.put( QualityProfileKey.parse(value.getKey()), this.processAggregations(value.getAggregations())); } return stats; }
@Override public void runAggregations() { System.out.println("get aggregations:"); System.out.println("connecting cluster..."); Node node = nodeBuilder().clusterName("ron-es").client(true).node(); Client client = node.client(); AbstractAggregationBuilder maxAgg = AggregationBuilders.max("max-km").field("km"); AbstractAggregationBuilder minAgg = AggregationBuilders.min("min-km").field("km"); AbstractAggregationBuilder avgAgg = AggregationBuilders.avg("avg-km").field("km"); AbstractAggregationBuilder sumAgg = AggregationBuilders.sum("sum-km").field("km"); String startTime = Util.getDateTimeNow(); SearchResponse response = client .prepareSearch("vehicles") .setTypes("cars") .addAggregation(maxAgg) .addAggregation(minAgg) .addAggregation(avgAgg) .addAggregation(sumAgg) .execute() .actionGet(); String stopTime = Util.getDateTimeNow(); _timeElapssed = Util.getDateDiff(startTime, stopTime); // SearchResponse response = // client.prepareSearch("vehicles").setTypes("cars").addAggregation(AggregationBuilders.max("max-km").field("km")).execute().actionGet(); client.close(); System.out.println("node closed"); // SearchResponse response = client.prepareSearch().execute().actionGet(); // Stats agg = response.getAggregations().get("km"); // double max = agg.getMax(); System.out.println(response); }
@Override public void execute(Client esClient, String index, boolean verbose) { FilterBuilder fb = new OrFilterBuilder( new TermFilterBuilder("eventName", "TopBrowser"), new TermFilterBuilder("data.playerEvent", "str-start")); AbstractAggregationBuilder aggregations = AggregationBuilders.terms("by_browser") .field("data.browser") .size(50) .subAggregation(AggregationBuilders.sum("sum").field("counter")) .order(Terms.Order.aggregation("sum", false)); if (index.equals("")) { this.searchResponse = esClient .prepareSearch() .setQuery( org.elasticsearch.index.query.QueryBuilders.filteredQuery( new MatchAllQueryBuilder(), fb)) .setSize(50) .setPostFilter(fb) .addAggregation(aggregations) .get(); } else { this.searchResponse = esClient .prepareSearch(index) .setQuery( org.elasticsearch.index.query.QueryBuilders.filteredQuery( new MatchAllQueryBuilder(), fb)) .setSize(50) .setPostFilter(fb) .addAggregation(aggregations) .get(); } fileLog.info(String.valueOf(this.searchResponse.getTookInMillis())); if (verbose) printResult(); }
public void testSpecialValueVariable() throws Exception { // i.e. _value for aggregations createIndex("test"); ensureGreen("test"); indexRandom( true, client().prepareIndex("test", "doc", "1").setSource("x", 5, "y", 1.2), client().prepareIndex("test", "doc", "2").setSource("x", 10, "y", 1.4), client().prepareIndex("test", "doc", "3").setSource("x", 13, "y", 1.8)); SearchRequestBuilder req = client().prepareSearch().setIndices("test"); req.setQuery(QueryBuilders.matchAllQuery()) .addAggregation( AggregationBuilders.stats("int_agg") .field("x") .script( new Script( "_value * 3", ScriptType.INLINE, ExpressionScriptEngineService.NAME, null))) .addAggregation( AggregationBuilders.stats("double_agg") .field("y") .script( new Script( "_value - 1.1", ScriptType.INLINE, ExpressionScriptEngineService.NAME, null))); SearchResponse rsp = req.get(); assertEquals(3, rsp.getHits().getTotalHits()); Stats stats = rsp.getAggregations().get("int_agg"); assertEquals(39.0, stats.getMax(), 0.0001); assertEquals(15.0, stats.getMin(), 0.0001); stats = rsp.getAggregations().get("double_agg"); assertEquals(0.7, stats.getMax(), 0.0001); assertEquals(0.1, stats.getMin(), 0.0001); }
private HistogramBuilder histogram(MethodField field) throws SqlParseException { String aggName = gettAggNameFromParamsOrAlias(field); HistogramBuilder histogram = AggregationBuilders.histogram(aggName); String value = null; for (KVValue kv : field.getParams()) { value = kv.value.toString(); switch (kv.key.toLowerCase()) { case "interval": histogram.interval(Long.parseLong(value)); break; case "field": histogram.field(value); break; case "min_doc_count": histogram.minDocCount(Long.parseLong(value)); break; case "extended_bounds": String[] bounds = value.split(":"); if (bounds.length == 2) histogram.extendedBounds(Long.valueOf(bounds[0]), Long.valueOf(bounds[1])); break; case "alias": case "nested": case "reverse_nested": break; case "order": Histogram.Order order = null; switch (value) { case "key_desc": order = Histogram.Order.KEY_DESC; break; case "count_asc": order = Histogram.Order.COUNT_ASC; break; case "count_desc": order = Histogram.Order.COUNT_DESC; break; case "key_asc": default: order = Histogram.Order.KEY_ASC; break; } histogram.order(order); break; default: throw new SqlParseException("histogram err or not define field " + kv.toString()); } } return histogram; }
/* * 所有姓氏为"Smith"的员工的最大的共同点(兴趣爱好)是什么 * 聚合变成只包含和查询语句想匹配的文档 */ @Test public void queryAggregationTest() { Client client = ClientTemplate.getClient(); SearchResponse response = client .prepareSearch("fccs") .setTypes("employee") .setQuery(QueryBuilders.matchQuery("lastName", "Smith")) .addAggregation(AggregationBuilders.terms("by_interests").field("interests")) .get(); Terms terms = response.getAggregations().get("by_interests"); for (Terms.Bucket bucket : terms.getBuckets()) { System.out.println("key:" + bucket.getKey() + " doc_count:" + bucket.getDocCount()); } client.close(); }
/** * 构建范围查询 * * @param field * @return */ private RangeBuilder rangeBuilder(MethodField field) { LinkedList<KVValue> params = new LinkedList<>(field.getParams()); String fieldName = params.poll().toString(); double[] ds = Util.KV2DoubleArr(params); RangeBuilder range = AggregationBuilders.range(field.getAlias()).field(fieldName); for (int i = 1; i < ds.length; i++) { range.addRange(ds[i - 1], ds[i]); } return range; }
@Test public void givenNotAnalyzedQuery_whenMakeAggregationOnTermCount_thenEachTermCountsIndividually() { TermsBuilder aggregation = AggregationBuilders.terms("top_tags") .field("tags") .order(Terms.Order.aggregation("_count", false)); SearchResponse response = client .prepareSearch("blog") .setTypes("article") .addAggregation(aggregation) .execute() .actionGet(); Map<String, Aggregation> results = response.getAggregations().asMap(); StringTerms topTags = (StringTerms) results.get("top_tags"); List<String> keys = topTags.getBuckets().stream().map(b -> b.getKey()).collect(toList()); assertEquals(asList("elasticsearch", "spring data", "search engines", "tutorial"), keys); }
public void testStringSpecialValueVariable() throws Exception { // i.e. expression script for term aggregations, which is not allowed createIndex("test"); ensureGreen("test"); indexRandom( true, client().prepareIndex("test", "doc", "1").setSource("text", "hello"), client().prepareIndex("test", "doc", "2").setSource("text", "goodbye"), client().prepareIndex("test", "doc", "3").setSource("text", "hello")); SearchRequestBuilder req = client().prepareSearch().setIndices("test"); req.setQuery(QueryBuilders.matchAllQuery()) .addAggregation( AggregationBuilders.terms("term_agg") .field("text") .script( new Script( "_value", ScriptType.INLINE, ExpressionScriptEngineService.NAME, null))); String message; try { // shards that don't have docs with the "text" field will not fail, // so we may or may not get a total failure SearchResponse rsp = req.get(); assertThat( rsp.getShardFailures().length, greaterThan(0)); // at least the shards containing the docs should have failed message = rsp.getShardFailures()[0].reason(); } catch (SearchPhaseExecutionException e) { message = e.toString(); } assertThat( message + "should have contained ExpressionScriptExecutionException", message.contains("ExpressionScriptExecutionException"), equalTo(true)); assertThat( message + "should have contained text variable error", message.contains("text variable"), equalTo(true)); }
/** * 按照时间范围分组 * * @param field * @return * @throws SqlParseException */ private DateHistogramBuilder dateHistogram(MethodField field) throws SqlParseException { String alias = gettAggNameFromParamsOrAlias(field); DateHistogramBuilder dateHistogram = AggregationBuilders.dateHistogram(alias).format(TIME_FARMAT); String value = null; for (KVValue kv : field.getParams()) { value = kv.value.toString(); switch (kv.key.toLowerCase()) { case "interval": dateHistogram.interval(new DateHistogram.Interval(kv.value.toString())); break; case "field": dateHistogram.field(value); break; case "format": dateHistogram.format(value); break; case "time_zone": case "pre_zone": dateHistogram.preZone(value); break; case "post_zone": dateHistogram.postZone(value); break; case "post_offset": dateHistogram.postOffset(value); break; case "pre_offset": dateHistogram.preOffset(value); break; case "alias": case "nested": case "reverse_nested": break; default: throw new SqlParseException("date range err or not define field " + kv.toString()); } } return dateHistogram; }
private AggregationBuilder<?> geoBounds(MethodField field) throws SqlParseException { String aggName = gettAggNameFromParamsOrAlias(field); GeoBoundsBuilder boundsBuilder = AggregationBuilders.geoBounds(aggName); String value = null; for (KVValue kv : field.getParams()) { value = kv.value.toString(); switch (kv.key.toLowerCase()) { case "field": boundsBuilder.field(value); break; case "wrap_longitude": boundsBuilder.wrapLongitude(Boolean.getBoolean(value)); break; case "alias": case "nested": case "reverse_nested": break; default: throw new SqlParseException("geo_bounds err or not define field " + kv.toString()); } } return boundsBuilder; }
@Override public Map<String, Integer> countTermsByField(SearchCriteria searchCriteria, String field) { ElasticSearchCriteria criteria = (ElasticSearchCriteria) searchCriteria; if (criteria == null) return null; SearchRequestBuilder srb = criteria2builder(criteria); srb.setFrom(0); srb.setSize(0); TermsBuilder tb = AggregationBuilders.terms(field); tb.field(field); srb.addAggregation(tb); try { SearchResponse response = srb.execute().get(); StringTerms aggr = response.getAggregations().get(field); Map<String, Integer> result = new LinkedHashMap<>(); for (Terms.Bucket bucket : aggr.getBuckets()) { result.put(bucket.getKey(), (int) bucket.getDocCount()); } return result; } catch (Exception e) { logger.error(e.getMessage(), e); } return Collections.emptyMap(); }
/** * TOPHITS查询 * * @param field * @return */ private AbstractAggregationBuilder makeTopHitsAgg(MethodField field) { String alias = gettAggNameFromParamsOrAlias(field); TopHitsBuilder topHits = AggregationBuilders.topHits(alias); List<KVValue> params = field.getParams(); for (KVValue kv : params) { switch (kv.key) { case "from": topHits.setFrom((int) kv.value); break; case "size": topHits.setSize((int) kv.value); break; case "alias": case "nested": case "reverse_nested": break; default: topHits.addSort(kv.key, SortOrder.valueOf(kv.value.toString().toUpperCase())); break; } } return topHits; }