使用统计聚合功能可以实现求最小值、求最大值、求和、求平均值、统计行数、去重统计行数、按字段值分组、按范围分组、按地理位置分组、按过滤条件分组、嵌套查询等;同时多个统计聚合功能可以组合使用,满足复杂的查询需求。

最小值

返回一个字段中的最小值,类似于SQL中的min。

  • 参数
    参数 说明
    aggregationName 自定义的统计聚合名称,用于区分不同的统计聚合,可根据此名称获取本次统计聚合结果。
    fieldName 用于统计聚合的字段,仅支持Long和Double类型。
    missing

    当某行数据中的字段为空时,字段值的默认值。

    • 如果未设置missing值,则在统计聚合时会忽略该行。
    • 如果设置了missing值,则使用missing值作为字段值的默认值参与统计聚合。
  • 示例
    /**
     *  商品库中有每一种商品的价格,求产地为浙江省的商品中,价格最低的商品价格是多少。
     *  等效的SQL语句是SELECT min(column_price) FROM product where place_of_production="浙江省"。
     */
    public void min(SyncClient client) {
        //构建查询语句。
        SearchRequest searchRequest = SearchRequest.newBuilder()
            .tableName("tableName")
            .indexName("indexName")
            .searchQuery(
                SearchQuery.newBuilder()
                    .query(QueryBuilders.term("place_of_production","浙江省"))
                    .limit(0) //如果只关心统计聚合结果,返回匹配到的结果数量设置为0有助于提高响应速度。
                    .addAggregation(AggregationBuilders.min("min_agg_1", "column_price").missing(100))
                    .build())
            .build();
        //执行查询。
        SearchResponse resp = client.search(searchRequest);
        //获取统计聚合结果。
        System.out.println(resp.getAggregationResults().getAsMinAggregationResult("min_agg_1").getValue());
    }

最大值

返回一个字段中的最大值,类似于SQL中的max。

  • 参数
    参数 说明
    aggregationName 自定义的统计聚合名称,用于区分不同的统计聚合,可根据此名称获取本次统计聚合结果。
    fieldName 用于统计聚合的字段,仅支持Long和Double类型。
    missing

    当某行数据中的字段为空时,字段值的默认值。

    • 如果未设置missing值,则在统计聚合时会忽略该行。
    • 如果设置了missing值,则使用missing值作为字段值的默认值参与统计聚合。
  • 示例
    /**
     * 商品库中有每一种商品的价格,求产地为浙江省的商品中,价格最高的商品价格是多少。
     * 等效的SQL语句是SELECT max(column_price) FROM product where place_of_production="浙江省"。
     */
    public void max(SyncClient client) {
        //构建查询语句。
        SearchRequest searchRequest = SearchRequest.newBuilder()
            .tableName("tableName")
            .indexName("indexName")
            .searchQuery(
                SearchQuery.newBuilder()
                    .query(QueryBuilders.term("place_of_production", "浙江省"))
                    .limit(0) //如果只关心统计聚合结果,返回匹配到的结果数量设置为0有助于提高响应速度。
                    .addAggregation(AggregationBuilders.max("max_agg_1", "column_price").missing(0))
                    .build())
            .build();
        //执行查询。
        SearchResponse resp = client.search(searchRequest);
        //获取统计聚合结果。
        System.out.println(resp.getAggregationResults().getAsMaxAggregationResult("max_agg_1").getValue());
    }

返回数值字段的总数,类似于SQL中的sum。

  • 参数
    参数 说明
    aggregationName 自定义的统计聚合名称,用于区分不同的统计聚合,可根据此名称获取本次统计聚合结果。
    fieldName 用于统计聚合的字段,仅支持Long和Double类型。
    missing

    当某行数据中的字段为空时,字段值的默认值。

    • 如果未设置missing值,则在统计聚合时会忽略该行。
    • 如果设置了missing值,则使用missing值作为字段值的默认值参与统计聚合。
  • 示例
    /**
     * 商品库中有每一种商品的售出数量,求产地为浙江省的商品中,一共售出了多少件商品。如果某一件商品没有该值,默认售出了10件。
     * 等效的SQL语句是SELECT sum(column_price) FROM product where place_of_production="浙江省"。
     */
    public void sum(SyncClient client) {
        //构建查询语句。
        SearchRequest searchRequest = SearchRequest.newBuilder()
            .tableName("tableName")
            .indexName("indexName")
            .searchQuery(
                SearchQuery.newBuilder()
                    .query(QueryBuilders.term("place_of_production", "浙江省"))
                    .limit(0) //如果只关心统计聚合结果,返回匹配到的结果数量设置为0有助于提高响应速度。
                    .addAggregation(AggregationBuilders.sum("sum_agg_1", "column_number").missing(10))
                    .build())
            .build();
        //执行查询。
        SearchResponse resp = client.search(searchRequest);
        //获取统计聚合结果。
        System.out.println(resp.getAggregationResults().getAsSumAggregationResult("sum_agg_1").getValue());
    }

平均值

返回数值字段的平均值,类似于SQL中的avg。

  • 参数
    参数 说明
    aggregationName 自定义的统计聚合名称,用于区分不同的统计聚合,可根据此名称获取本次统计聚合结果。
    fieldName 用于统计聚合的字段,仅支持Long和Double类型。
    missing

    当某行数据中的字段为空时,字段值的默认值。

    • 如果未设置missing值,则在统计聚合时会忽略该行。
    • 如果设置了missing值,则使用missing值作为字段值的默认值参与统计聚合。
  • 示例
    /**
     * 商品库中有每一种商品的售出数量,求产地为浙江省的商品中,平均价格是多少。
     * 等效的SQL语句是SELECT avg(column_price) FROM product where place_of_production="浙江省"。
     */
    public void avg(SyncClient client) {
        //构建查询语句。
        SearchRequest searchRequest = SearchRequest.newBuilder()
            .tableName("tableName")
            .indexName("indexName")
            .searchQuery(
                SearchQuery.newBuilder()
                    .query(QueryBuilders.term("place_of_production", "浙江省"))
                    .limit(0) //如果只关心统计聚合结果,返回匹配到的结果数量设置为0有助于提高响应速度。
                    .addAggregation(AggregationBuilders.avg("avg_agg_1", "column_number"))
                    .build())
            .build();
        //执行查询。
        SearchResponse resp = client.search(searchRequest);
        //获取统计聚合结果。
        System.out.println(resp.getAggregationResults().getAsAvgAggregationResult("avg_agg_1").getValue());
    }

统计行数

返回指定字段值的数量或者表中数据总行数,类似于SQL中的count。
说明 通过如下方式可以统计表中数据总行数或者某个query匹配的行数。
  • 使用统计聚合的count功能,在请求中设置count(*)。
  • 使用query功能的匹配行数,在query中设置setGetTotalCount(true);如果需要统计表中数据总行数,则使用MatchAllQuery。

如果需要获取表中数据某列出现的次数,则使用count(列名),可应用于稀疏列的场景。

  • 参数
    参数 说明
    aggregationName 自定义的统计聚合名称,用于区分不同的统计聚合,可根据此名称获取本次统计聚合结果。
    fieldName 用于统计聚合的字段,仅支持Long、Double、Boolean、Keyword和Geo_point类型。
  • 示例
    /**
     * 商家库中有每一种商家的惩罚记录,求浙江省的商家中,有惩罚记录的一共有多少个商家。如果商家没有惩罚记录,则商家信息中不存在该字段。
     * 等效的SQL语句是SELECT count(column_history) FROM product where place_of_production="浙江省"。
     */
    public void count(SyncClient client) {
        //构建查询语句。
        SearchRequest searchRequest = SearchRequest.newBuilder()
            .tableName("tableName")
            .indexName("indexName")
            .searchQuery(
                SearchQuery.newBuilder()
                    .query(QueryBuilders.term("place", "浙江省"))
                    .limit(0)
                    .addAggregation(AggregationBuilders.count("count_agg_1", "column_history"))
                    .build())
            .build();
        //执行查询。
        SearchResponse resp = client.search(searchRequest);
        //获取统计聚合结果。
        System.out.println(resp.getAggregationResults().getAsCountAggregationResult("count_agg_1").getValue());
    }

去重统计行数

返回指定字段不同值的数量,类似于SQL中的count(distinct)。
说明 去重统计行数的计算结果是个近似值。
  • 当去重统计行数小于1万时,计算结果是一个精确值。
  • 当去重统计行数达到1亿时,计算结果的误差为2%左右。
  • 参数
    参数 说明
    aggregationName 自定义的统计聚合名称,用于区分不同的统计聚合,可根据此名称获取本次统计聚合结果。
    fieldName 用于统计聚合的字段,仅支持Long、Double、Boolean、Keyword和Geo_point类型。
    missing 当某行数据中的字段为空时,字段值的默认值。
    • 如果未设置missing值,则在统计聚合时会忽略该行。
    • 如果设置了missing值,则使用missing值作为字段值的默认值参与统计聚合。
  • 示例
    /**
     * 求所有的商品,产地一共来自多少个省份。
     * 等效的SQL语句是SELECT count(distinct column_place) FROM product。
     */
    public void distinctCount(SyncClient client) {
        //构建查询语句。
        SearchRequest searchRequest = SearchRequest.newBuilder()
            .tableName("tableName")
            .indexName("indexName")
            .searchQuery(
                SearchQuery.newBuilder()
                    .query(QueryBuilders.matchAll())
                    .limit(0)
                    .addAggregation(AggregationBuilders.distinctCount("dis_count_agg_1", "column_place"))
                    .build())
            .build();
        //执行查询。
        SearchResponse resp = client.search(searchRequest);
        //获取统计聚合结果。
        System.out.println(resp.getAggregationResults().getAsDistinctCountAggregationResult("dis_count_agg_1").getValue());
    }

字段值分组

根据一个字段的值对查询结果进行分组,相同的字段值放到同一分组内,返回每个分组的值和该值对应的个数。
说明 当分组较大时,按字段值分组可能会存在误差。
  • 参数
    参数 说明
    groupByName 自定义的统计聚合名称,用于区分不同的统计聚合,可根据此名称获取本次统计聚合结果。
    fieldName 用于统计聚合的字段,仅支持Long、Double、Boolean和Keyword类型。
    groupBySorter 分组中的item排序规则,默认按照分组中item的数量降序排序,多个排序则按照添加的顺序进行排列。支持的参数如下。
    • 按照值的字典序升序排列
    • 按照值的字典序降序排列
    • 按照行数升序排列
    • 按照行数降序排列
    • 按照子统计聚合结果中值升序排列
    • 按照子统计聚合结果中值降序排列
    size 返回的分组数量。
    subAggregation和subGroupBy 子统计聚合,子统计聚合会根据分组内容再进行一次统计聚合分析。
    • 场景

      统计每个类别的商品数量,且统计每个类别价格的最大值和最小值。

    • 方法

      最外层的统计聚合是根据类别进行分组,再添加两个子统计聚合求价格的最大值和最小值。

    • 结果示例
      • 水果:5个(其中价格最高15元,最低3元)
      • 洗漱用品:10个(其中价格最高98元,最低1元)
      • 电子设备:3个(其中价格最高8699元,最低2300元)
      • 其它:15个(其中价格最高1000元,最低80元)
  • 示例1
    /**
     * 所有商品中每一个类别各有多少个,且统计每一个类别的价格最大值和最小值。
     * 返回结果举例:"水果:5个(其中价格最贵15元,最便宜3元),洗漱用品:10个(其中价格最贵98元,最便宜1元),电子设备:3个(其中价格最贵8699元,最便宜2300元),其它:15个(其中价格最贵1000
     * 元,最便宜80元)"。
     */
    public void groupByField(SyncClient client) {
        //构建查询语句。
        SearchRequest searchRequest = SearchRequest.newBuilder()
            .tableName("tableName")
            .indexName("indexName")
            .searchQuery(
                SearchQuery.newBuilder()
                    .query(QueryBuilders.matchAll())
                    .limit(0)
                    .addGroupBy(GroupByBuilders
                        .groupByField("name1", "column_type")
                        .addSubAggregation(AggregationBuilders.min("subName1", "column_price"))
                        .addSubAggregation(AggregationBuilders.max("subName2", "column_price"))
                    )
                    .build())
            .build();
        //执行查询。
        SearchResponse resp = client.search(searchRequest);
        //获取统计聚合结果。
        for (GroupByFieldResultItem item : resp.getGroupByResults().getAsGroupByFieldResult("name1").getGroupByFieldResultItems()) {
            //打印值。
            System.out.println(item.getKey());
            //打印个数。
            System.out.println(item.getRowCount());
            //打印最低价格。
            System.out.println(item.getSubAggregationResults().getAsMinAggregationResult("subName1").getValue());
            //打印最高价格。
            System.out.println(item.getSubAggregationResults().getAsMaxAggregationResult("subName2").getValue());
        }
    }
  • 示例2
        /**
         * 按照多字段分组的示例。
         * 多元索引目前不能原生支持SQL中的groupBy多字段,但是可以通过嵌套使用两个groupBy完成相似功能。
         * 等效的SQL语句是select a,d, sum(b),sum(c) from user group by a,d。
         */
        public void GroupByMultiField() {
            SearchRequest searchRequest = SearchRequest.newBuilder()
                .tableName("tableName")
                .indexName("indexName")
                .returnAllColumns(true)   //设置为false时,指定addColumnsToGet,性能会高。
                //.addColumnsToGet("col_1","col_2")
                .searchQuery(SearchQuery.newBuilder()
                    .query(QueryBuilders.matchAll())   //此处相当于SQL中的where条件,可以通过QueryBuilders.bool()嵌套查询实现复杂的查询。
                    .addGroupBy(
                        GroupByBuilders
                            .groupByField("任意唯一名字标识_1", "field_a")
                            .size(20)
                            .addSubGroupBy(
                                GroupByBuilders
                                    .groupByField("任意唯一名字标识_2", "field_d")
                                    .size(20)
                                    .addSubAggregation(AggregationBuilders.sum("任意唯一名字标识_3", "field_b"))
                                    .addSubAggregation(AggregationBuilders.sum("任意唯一名字标识_4", "field_c"))
                            )
                    )
                    .build())
                .build();
            SearchResponse response = client.search(searchRequest);
            //查询符合条件的行。
            List<Row> rows = response.getRows();
            //获取统计聚合结果。
            GroupByFieldResult groupByFieldResult1 = response.getGroupByResults().getAsGroupByFieldResult("任意唯一名字标识_1");
            for (GroupByFieldResultItem resultItem : groupByFieldResult1.getGroupByFieldResultItems()) {
                System.out.println("field_a key:" + resultItem.getKey() + " Count:" + resultItem.getRowCount());
                //获取子统计聚合结果。
                GroupByFieldResult subGroupByResult = resultItem.getSubGroupByResults().getAsGroupByFieldResult("任意唯一名字标识_2");
                for (GroupByFieldResultItem item : subGroupByResult.getGroupByFieldResultItems()) {
                    System.out.println("field_a " + resultItem.getKey() + " field_d key:" + item.getKey() + " Count:" + item.getRowCount());
                    double sumOf_field_b = item.getSubAggregationResults().getAsSumAggregationResult("任意唯一名字标识_3").getValue();
                    double sumOf_field_c = item.getSubAggregationResults().getAsSumAggregationResult("任意唯一名字标识_4").getValue();
                    System.out.println("sumOf_field_b:" + sumOf_field_b);
                    System.out.println("sumOf_field_c:" + sumOf_field_c);
                }
            }
        }
  • 示例3
        /**
         * 使用统计聚合排序的示例。
         * 使用方法:按顺序添加GroupBySorter即可,添加多个GroupBySorter时排序结果按照添加顺序生效。GroupBySorter支持升序和降序两种方式。
         * 默认排序是按照行数降序排列即GroupBySorter.rowCountSortInDesc()。
         */
        public void groupByFieldWithSort(SyncClient client) {
            //构建查询语句。
            SearchRequest searchRequest = SearchRequest.newBuilder()
                .tableName("tableName")
                .indexName("indexName")
                .searchQuery(
                    SearchQuery.newBuilder()
                        .query(QueryBuilders.matchAll())
                        .limit(0)
                        .addGroupBy(GroupByBuilders
                            .groupByField("name1", "column_type")
                            //.addGroupBySorter(GroupBySorter.subAggSortInAsc("subName1")) //按照子统计聚合结果中的值升序排序。
                            .addGroupBySorter(GroupBySorter.groupKeySortInAsc())           //按照统计聚合结果中的值升序排序。
                            //.addGroupBySorter(GroupBySorter.rowCountSortInDesc())        //按照统计聚合结果中的行数降序排序。
                            .size(20)
                            .addSubAggregation(AggregationBuilders.min("subName1", "column_price"))
                            .addSubAggregation(AggregationBuilders.max("subName2", "column_price"))
                        )
                        .build())
                .build();
            //执行查询。
            SearchResponse resp = client.search(searchRequest);
        }

范围分组

根据一个字段的范围对查询结果进行分组,字段值在某范围内放到同一分组内,返回每个范围中相应的item个数。

  • 参数
    参数 说明
    groupByName 自定义的统计聚合名称,用于区分不同的统计聚合,可根据此名称获取本次统计聚合结果。
    fieldName 用于统计聚合的字段,仅支持Long和Double类型。
    range[double_from, double_to) 分组的范围。

    起始值double_from可以使用最小值Double.MIN_VALUE,结束值double_to可以使用最大值Double.MAX_VALUE。

    subAggregation和subGroupBy 子统计聚合,子统计聚合会根据分组内容再进行一次统计聚合分析。

    例如按销量分组后再按省份分组,即可获得某个销量范围内哪个省比重比较大,实现方法是GroupByRange下添加一个GroupByField。

  • 示例
    /**
     * 求商品销量时按[0,1000)、[1000,5000)、[5000,Double.MAX_VALUE)这些分组计算每个范围的销量。
     */
    public void groupByRange(SyncClient client) {
        //构建查询语句。
        SearchRequest searchRequest = SearchRequest.newBuilder()
            .tableName("tableName")
            .indexName("indexName")
            .searchQuery(
                SearchQuery.newBuilder()
                    .query(QueryBuilders.matchAll())
                    .limit(0)
                    .addGroupBy(GroupByBuilders
                        .groupByRange("name1", "column_number")
                        .addRange(0, 1000)
                        .addRange(1000, 5000)
                        .addRange(5000, Double.MAX_VALUE)
                    )
                    .build())
            .build();
        //执行查询。
        SearchResponse resp = client.search(searchRequest);
        //获取统计聚合结果。
        for (GroupByRangeResultItem item : resp.getGroupByResults().getAsGroupByRangeResult("name1").getGroupByRangeResultItems()) {
    
            //打印个数。
            System.out.println(item.getRowCount());
        }
    }

地理位置分组

根据距离某一个中心点的范围对查询结果进行分组,距离差值在某范围内放到同一分组内,返回每个范围中相应的item个数。

  • 参数
    参数 说明
    groupByName 自定义的统计聚合名称,用于区分不同的统计聚合,可根据此名称获取本次统计聚合结果。
    fieldName 用于统计聚合的字段,仅支持Geo_point类型。
    origin(double lat, double lon) 起始中心点的经纬度。

    double lat是起始中心点纬度,double lon是起始中心点经度。

    range[double_from, double_to) 分组的范围,单位为米。

    起始值double_from可以使用最小值Double.MIN_VALUE,结束值double_to可以使用最大值Double.MAX_VALUE。

    subAggregation和subGroupBy 子统计聚合,子统计聚合会根据分组内容再进行一次统计聚合分析。
  • 示例
    /**
     * 求距离万达广场[0,1000)、[1000,5000)、[5000,Double.MAX_VALUE)这些范围内的人数,距离的单位为米。
     */
    public void groupByGeoDistance(SyncClient client) {
        //构建查询语句。
        SearchRequest searchRequest = SearchRequest.newBuilder()
            .tableName("tableName")
            .indexName("indexName")
            .searchQuery(
                SearchQuery.newBuilder()
                    .query(QueryBuilders.matchAll())
                    .limit(0)
                    .addGroupBy(GroupByBuilders
                        .groupByGeoDistance("name1", "column_geo_point")
                        .origin(3.1, 6.5)
                        .addRange(0, 1000)
                        .addRange(1000, 5000)
                        .addRange(5000, Double.MAX_VALUE)
                    )
                    .build())
            .build();
        //执行查询。
        SearchResponse resp = client.search(searchRequest);
        //获取统计聚合结果。
        for (GroupByGeoDistanceResultItem item : resp.getGroupByResults().getAsGroupByGeoDistanceResult("name1").getGroupByGeoDistanceResultItems()) {
           //打印个数。
            System.out.println(item.getRowCount());
        }
    }

过滤条件分组

按照过滤条件对查询结果进行分组,获取每个过滤条件匹配到的数量,返回结果的顺序和添加过滤条件的顺序一致。

  • 参数
    参数 说明
    groupByName 自定义的统计聚合名称,用于区分不同的统计聚合,可根据此名称获取本次统计聚合结果。
    filter 过滤条件,返回结果的顺序和添加过滤条件的顺序一致。
    subAggregation和subGroupBy 子统计聚合,子统计聚合会根据分组内容再进行一次统计聚合分析。
  • 示例
    /**
     * 按照过滤条件进行分组,例如添加三个过滤条件(销量大于100、产地是浙江省、描述中包含杭州关键词),然后获取每个过滤条件匹配到的数量。
     */
    public void groupByFilter(SyncClient client) {
        //构建查询语句。
        SearchRequest searchRequest = SearchRequest.newBuilder()
            .tableName("tableName")
            .indexName("indexName")
            .searchQuery(
                SearchQuery.newBuilder()
                    .query(QueryBuilders.matchAll())
                    .limit(0)
                    .addGroupBy(GroupByBuilders
                        .groupByFilter("name1")
                        .addFilter(QueryBuilders.range("number").greaterThanOrEqual(100))
                        .addFilter(QueryBuilders.term("place","浙江省"))
                        .addFilter(QueryBuilders.match("text","杭州"))
                    )
                    .build())
            .build();
        //执行查询。
        SearchResponse resp = client.search(searchRequest);
        //按照过滤条件的顺序获取的统计聚合结果。
        for (GroupByFilterResultItem item : resp.getGroupByResults().getAsGroupByFilterResult("name1").getGroupByFilterResultItems()) {
            //打印个数。
            System.out.println(item.getRowCount());
        }
    }

嵌套

分组类型的统计聚合功能支持嵌套,其内部可以添加子统计聚合。

主要用于在分组内再次进行统计聚合,以两层的嵌套为例:
  • GroupBy+SubGroupBy:按省份分组后再按照城市分组,获取每个省份下每个城市的数据。
  • GroupBy+SubAggregation:按照省份分组后再求某个指标的最大值,获取每个省的某个指标最大值。
说明 为了性能、复杂度等综合考虑,嵌套的层级只开放了一定的层数,详情请参见 多元索引限制
示例
/**
 * 嵌套的统计聚合示例。
 * 外层2个Aggregation和1个GroupByField,GroupByField中又添加了2个Aggregation和1个GroupByRange。
 */
public void subGroupBy(SyncClient client) {
    //构建查询语句。
    SearchRequest searchRequest = SearchRequest.newBuilder()
        .indexName("index_name")
        .tableName("table_name")
        .returnAllColumns(true)
        .searchQuery(
            SearchQuery.newBuilder()
                .query(QueryBuilders.match("textField", "hello"))
                .limit(10)
                .addAggregation(AggregationBuilders.min("name1", "fieldName1"))
                .addAggregation(AggregationBuilders.max("name2", "fieldName2"))
                .addGroupBy(GroupByBuilders
                    .groupByField("name3", "fieldName3")
                    .addSubAggregation(AggregationBuilders.max("subName1", "fieldName4"))
                    .addSubAggregation(AggregationBuilders.sum("subName2", "fieldName5"))
                    .addSubGroupBy(GroupByBuilders
                        .groupByRange("subName3", "fieldName6")
                        .addRange(12, 90)
                        .addRange(100, 900)
                    ))
                .build())
        .build();
    //执行查询。
    SearchResponse resp = client.search(searchRequest);
    //获取第一层求最小值和求最大值的统计聚合结果。
    AggregationResults aggResults = resp.getAggregationResults();
    System.out.println(aggResults.getAsMinAggregationResult("name1").getValue());
    System.out.println(aggResults.getAsMaxAggregationResult("name2").getValue());

    //获取第一层按字段值分组的统计聚合结果,并同时获取其嵌套的子统计聚合结果。
    GroupByFieldResult results = resp.getGroupByResults().getAsGroupByFieldResult("someName1");
    for (GroupByFieldResultItem item : results.getGroupByFieldResultItems()) {
        System.out.println("数量:" + item.getRowCount());
        System.out.println("key:" + item.getKey());

        //获取子统计聚合结果。
        //打印求最大值的子统计聚合结果。
        System.out.println(item.getSubAggregationResults().getAsMaxAggregationResult("subName1"));
        //打印求和的子统计聚合结果。
        System.out.println(item.getSubAggregationResults().getAsSumAggregationResult("subName2"));
        //打印按范围分组的子统计聚合结果。
        GroupByRangeResult subResults = resp.getGroupByResults().getAsGroupByRangeResult("subName3");
        for (GroupByRangeResultItem subItem : subResults.getGroupByRangeResultItems()) {
            System.out.println("数量:" + subItem.getRowCount());
            System.out.println("key:" + subItem.getKey());
        }
    }
}

多个统计聚合

多个统计聚合功能可以组合使用。
说明 当多个统计聚合的复杂度较高时可能会影响响应速度。
  • 示例1
    public void multipleAggregation(SyncClient client) {
        //构建查询语句。
        SearchRequest searchRequest = SearchRequest.newBuilder()
            .tableName("tableName")
            .indexName("indexName")
            .searchQuery(
                SearchQuery.newBuilder()
                    .query(QueryBuilders.matchAll())
                    .limit(0)
                    .addAggregation(AggregationBuilders.min("name1", "long"))
                    .addAggregation(AggregationBuilders.sum("name2", "long"))
                    .addAggregation(AggregationBuilders.distinctCount("name3", "long"))
                    .build())
            .build();
        //执行查询。
        SearchResponse resp = client.search(searchRequest);
        //获取求最小值的统计聚合结果。
        System.out.println(resp.getAggregationResults().getAsMinAggregationResult("name1").getValue());
        //获取求和的统计聚合结果。
        System.out.println(resp.getAggregationResults().getAsSumAggregationResult("name2").getValue());
        //获取去重统计行数的统计聚合结果。
        System.out.println(resp.getAggregationResults().getAsDistinctCountAggregationResult("name3").getValue());
    }
  • 示例2
    public void multipleGroupBy(SyncClient client) {
        //构建查询语句。
        SearchRequest searchRequest = SearchRequest.newBuilder()
            .tableName("tableName")
            .indexName("indexName")
            .searchQuery(
                SearchQuery.newBuilder()
                    .query(QueryBuilders.matchAll())
                    .limit(0)
                    .addAggregation(AggregationBuilders.min("name1", "long"))
                    .addAggregation(AggregationBuilders.sum("name2", "long"))
                    .addAggregation(AggregationBuilders.distinctCount("name3", "long"))
                    .addGroupBy(GroupByBuilders.groupByField("name4", "type"))
                    .addGroupBy(GroupByBuilders.groupByRange("name5", "long").addRange(1, 15))
                    .build())
            .build();
        //执行查询。
        SearchResponse resp = client.search(searchRequest);
        //获取求最小值的统计聚合结果。
        System.out.println(resp.getAggregationResults().getAsMinAggregationResult("name1").getValue());
        //获取求和的统计聚合结果。
        System.out.println(resp.getAggregationResults().getAsSumAggregationResult("name2").getValue());
        //获取去重统计行数的统计聚合结果。
        System.out.println(resp.getAggregationResults().getAsDistinctCountAggregationResult("name3").getValue());
        //获取按字段值分组的统计聚合结果。
        for (GroupByFieldResultItem item : resp.getGroupByResults().getAsGroupByFieldResult("name4").getGroupByFieldResultItems()) {
            //打印key。
            System.out.println(item.getKey());
            //打印个数。
            System.out.println(item.getRowCount());
        }
        //获取按范围分组的统计聚合结果。
        for (GroupByRangeResultItem item : resp.getGroupByResults().getAsGroupByRangeResult("name5").getGroupByRangeResultItems()) {
            //打印个数。
            System.out.println(item.getRowCount());
        }
    }