统计聚合 - 表格存储 - 阿里云

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

功能	说明
最小值	返回一个字段中的最小值，类似于SQL中的min。
最大值	返回一个字段中的最大值，类似于SQL中的max。
和	返回数值字段的总数，类似于SQL中的sum。
平均值	返回数值字段的平均值，类似于SQL中的avg。
统计行数	返回指定字段值的数量或者多元索引数据总行数，类似于SQL中的count。
去重统计行数	返回指定字段不同值的数量，类似于SQL中的count（distinct）。
百分位统计	百分位统计常用来统计一组数据的百分位分布情况，例如在日常系统运维中统计每次请求访问的耗时情况时，需要关注系统请求耗时的P25、P50、P90、P99值等分布情况。
字段值分组	根据一个字段的值对查询结果进行分组，相同的字段值放到同一分组内，返回每个分组的值和该值对应的个数。
范围分组	根据一个字段的范围对查询结果进行分组，字段值在某范围内放到同一分组内，返回每个范围中相应的item个数。
地理位置分组	根据距离某一个中心点的范围对查询结果进行分组，距离差值在某范围内放到同一分组内，返回每个范围中相应的item个数。
过滤条件分组	按照过滤条件对查询结果进行分组，获取每个过滤条件匹配到的数量，返回结果的顺序和添加过滤条件的顺序一致。
直方图统计	按照指定数据间隔对查询结果进行分组，字段值在相同范围内放到同一分组内，返回每个分组的值和该值对应的个数。

参数	说明
name	自定义的统计聚合名称，用于区分不同的统计聚合，可根据此名称获取本次统计聚合结果。
field	用于统计聚合的字段，仅支持Long、Double和Date类型。
missing	当某行数据中的字段为空时，字段值的默认值。如果未设置missing值，则在统计聚合时会忽略该行。如果设置了missing值，则使用missing值作为字段值的默认值参与统计聚合。

query = TermQuery('age', 18)
agg = Min('score', name = 'min')
search_response = client.search(table_name, index_name,
                                SearchQuery(query, next_token = None, limit=0, aggs=[agg]),
                                columns_to_get = ColumnsToGet(return_type = ColumnReturnType.ALL_FROM_INDEX))
for agg_result in search_response.agg_results:
    print('{\n"name":"%s",\n"value":%s\n}\n' % (agg_result.name, str(agg_result.value)))

参数	说明
name	自定义的统计聚合名称，用于区分不同的统计聚合，可根据此名称获取本次统计聚合结果。
field	用于统计聚合的字段，仅支持Long、Double和Date类型。
missing	当某行数据中的字段为空时，字段值的默认值。如果未设置missing值，则在统计聚合时会忽略该行。如果设置了missing值，则使用missing值作为字段值的默认值参与统计聚合。

query = TermQuery('age', 18)
agg = Max('score', missing_value = 0, name = 'max')
search_response = client.search(table_name, index_name,
                                SearchQuery(query, next_token = None, limit=0, aggs=[agg]),
                                columns_to_get = ColumnsToGet(return_type = ColumnReturnType.ALL_FROM_INDEX))
for agg_result in search_response.agg_results:
    print('{\n"name":"%s",\n"value":%s\n}\n' % (agg_result.name, str(agg_result.value)))

参数	说明
name	自定义的统计聚合名称，用于区分不同的统计聚合，可根据此名称获取本次统计聚合结果。
field	用于统计聚合的字段，仅支持Long和Double类型。
missing	当某行数据中的字段为空时，字段值的默认值。如果未设置missing值，则在统计聚合时会忽略该行。如果设置了missing值，则使用missing值作为字段值的默认值参与统计聚合。

query = TermQuery('age', 18)
agg = Sum('score', name = 'sum')
search_response = client.search(table_name, index_name,
                                SearchQuery(query, next_token = None, limit=2, aggs=[agg]),
                                columns_to_get = ColumnsToGet(return_type = ColumnReturnType.ALL_FROM_INDEX))
for agg_result in search_response.agg_results:
    print('{\n"name":"%s",\n"value":%s\n}\n' % (agg_result.name, str(agg_result.value)))

参数	说明
name	自定义的统计聚合名称，用于区分不同的统计聚合，可根据此名称获取本次统计聚合结果。
field	用于统计聚合的字段，仅支持Long、Double和Date类型。
missing	当某行数据中的字段为空时，字段值的默认值。如果未设置missing值，则在统计聚合时会忽略该行。如果设置了missing值，则使用missing值作为字段值的默认值参与统计聚合。

query = TermQuery('age', 18)
agg = Avg('score', name = 'avg')
search_response = client.search(table_name, index_name,
                                SearchQuery(query, next_token = None, limit=2, aggs=[agg]),
                                columns_to_get = ColumnsToGet(return_type = ColumnReturnType.ALL_FROM_INDEX))
for agg_result in search_response.agg_results:
    print('{\n"name":"%s",\n"value":%s\n}\n' % (agg_result.name, str(agg_result.value)))

参数	说明
name	自定义的统计聚合名称，用于区分不同的统计聚合，可根据此名称获取本次统计聚合结果。
field	用于统计聚合的字段，仅支持Long、Double、Boolean、Keyword、Geo_point和Date类型。


query = TermQuery('age', 18)
agg = Count('score', name = 'count')
search_response = client.search(table_name, index_name,
                                SearchQuery(query, next_token = None, limit=2, aggs=[agg]),
                                columns_to_get = ColumnsToGet(return_type = ColumnReturnType.ALL_FROM_INDEX))
for agg_result in search_response.agg_results:
    print('{\n"name":"%s",\n"value":%s\n}\n' % (agg_result.name, str(agg_result.value)))

参数	说明
name	自定义的统计聚合名称，用于区分不同的统计聚合，可根据此名称获取本次统计聚合结果。
field	用于统计聚合的字段，仅支持Long、Double、Boolean、Keyword、Geo_point和Date类型。
missing	当某行数据中的字段为空时，字段值的默认值。如果未设置Missing值，则在统计聚合时会忽略该行。如果设置了Missing值，则使用Missing值作为字段值的默认值参与统计聚合。

query = TermQuery('age', 18)
agg = DistinctCount('name', name = 'distinct_name')
search_response = client.search(table_name, index_name,
                                SearchQuery(query, next_token = None, limit=2, aggs=[agg]),
                                columns_to_get = ColumnsToGet(return_type = ColumnReturnType.ALL_FROM_INDEX))
for agg_result in search_response.agg_results:
    print('{\n"name":"%s",\n"value":%s\n}\n' % (agg_result.name, str(agg_result.value)))

参数	说明
name	自定义的统计聚合名称，用于区分不同的统计聚合，可根据此名称获取本次统计聚合结果。
field	用于统计聚合的字段，仅支持Long、Double和Date类型。
percentiles	百分位分布例如50、90、99，可根据需要设置一个或者多个百分位。
missing_value	当某行数据中的字段为空时，字段值的默认值。如果未设置missing_value值，则在统计聚合时会忽略该行。如果设置了missing_value值，则使用missing_value值作为字段值的默认值参与统计聚合。

query = TermQuery('product', '10010')
agg = Percentiles('latency', percentiles_list = [50, 90, 95])
search_response = client.search(table_name, index_name,
                                SearchQuery(query, next_token = None, limit=2, aggs=[agg]),
                                columns_to_get = ColumnsToGet(return_type = ColumnReturnType.ALL_FROM_INDEX))
for agg_result in search_response.agg_results:
    print('percentiles:%s' % agg_result.name)
    for item in agg_result.value:
        print('%s:%s' % (str(item.key), str(item.value)))

参数	说明
name	自定义的统计聚合名称，用于区分不同的统计聚合，可根据此名称获取本次统计聚合结果。
field	用于统计聚合的字段，仅支持Long、Double、Boolean、Keyword和Date类型。
size	返回的分组数量，默认值为10。最大值为2000。当分组数量超过2000时，只会返回前2000个分组。
group_by_sort	分组中的item排序规则，默认按照分组中item的数量降序排序，多个排序则按照添加的顺序进行排列。支持的参数如下：按照值的字典序升序排列按照值的字典序降序排列按照行数升序排列按照行数降序排列按照子统计聚合结果中值升序排列按照子统计聚合结果中值降序排列
sub_aggs和sub_group_bys	子统计聚合，子统计聚合会根据分组内容再进行一次统计聚合分析。场景统计每个类别的商品数量，且统计每个类别价格的最大值和最小值。方法最外层的统计聚合是根据类别进行分组，再添加两个子统计聚合求价格的最大值和最小值。结果示例水果：5个（其中价格的最大值为15，最小值为3）洗漱用品：10个（其中价格的最大值为98，最小值为1）电子设备：3个（其中价格的最大值为8699，最小值为2300）其它：15个（其中价格的最大值为1000，最小值为80）

query = TermQuery('age', 18)
group_by = GroupByField('score', size = 10)
search_response = client.search(table_name, index_name,
                                SearchQuery(query, next_token = None, limit=20, group_bys = [group_by]),
                                columns_to_get = ColumnsToGet(return_type = ColumnReturnType.ALL_FROM_INDEX))
for group_by in search_response.group_by_results:
    print("name:%s" % group_by.name)
    print("groups:")
    for item in group_by.items:
        print("key:%s, count:%d" % (item.key, item.row_count))

group_by = GroupByField('score', size = 2, group_by_sort = [RowCountSort(sort_order=SortOrder.ASC)])
search_response = client.search(table_name, index_name,
                                SearchQuery(TermQuery('age', 18), limit=100, get_total_count=True, group_bys = [group_by]),
                                ColumnsToGet(return_type=ColumnReturnType.ALL_FROM_INDEX))
for group_by in search_response.group_by_results:
    print("name:%s" % group_by.name)
    print("groups:")
    for item in group_by.items:
        print("key:%s, count:%d" % (item.key, item.row_count))

sort = RowCountSort(sort_order = SortOrder.DESC)
sub_agg = [TopRows(limit=3,sort=Sort([PrimaryKeySort(sort_order=SortOrder.DESC)]), name = 't1')]
group_by = GroupByField('l', size = 2, group_by_sort = [sort], sub_aggs = sub_agg)
search_response = client.search(table_name, index_name,
                                SearchQuery(TermQuery('age', 18), limit=100, get_total_count=True, group_bys = [group_by]),
                                ColumnsToGet(return_type=ColumnReturnType.ALL_FROM_INDEX))
for group_by in search_response.group_by_results:
    print("name:%s" % group_by.name)
    print("groups:")
    for item in group_by.items:
        print("\tkey:%s, count:%d" % (item.key, item.row_count))
        for sub_agg in item.sub_aggs:
            print("\t\tname:%s:" % sub_agg.name)
            for entry in sub_agg.value:
                print("\t\t\tvalue:%s" % str(entry))

sort = RowCountSort(sort_order = SortOrder.ASC)
sub_group = GroupByField('sex', size = 10, group_by_sort = [sort])
group_by = GroupByField('score', size = 10, group_by_sort = [sort], sub_group_bys = [sub_group])
search_response = client.search(table_name, index_name,
                                SearchQuery(TermQuery('age', 18), limit=100, get_total_count=True, group_bys = [group_by]),
                                ColumnsToGet(return_type=ColumnReturnType.ALL_FROM_INDEX))
for group_by in search_response.group_by_results:
    print("name:%s" % group_by.name)
    print("groups:")
    for item in group_by.items:
        print("\tkey:%s, count:%d" % (item.key, item.row_count))
        for sub_group in item.sub_group_bys:
            print("\t\tname:%s:" % sub_group.name)
            for sub_item in sub_group.items:
                print("\t\t\tkey:%s, count:%s" % (str(sub_item.key), str(sub_item.row_count)))

参数	说明
name	自定义的统计聚合名称，用于区分不同的统计聚合，可根据此名称获取本次统计聚合结果。
field	用于统计聚合的字段，仅支持Long和Double类型。
range[double_from, double_to)	分组的范围。起始值double_from可以使用最小值Double.MIN_VALUE，结束值double_to可以使用最大值Double.MAX_VALUE。
sub_aggs和sub_group_bys	子统计聚合，子统计聚合会根据分组内容再进行一次统计聚合分析。例如按销量分组后再按省份分组，即可获得某个销量范围内哪个省比重比较大，实现方法是GroupByRange下添加一个GroupByField。

query = TermQuery('age', 18)
group_by = GroupByRange(field_name = 'score', ranges = [(80, 90),(90, 100)])
search_response = client.search(table_name, index_name,
                                SearchQuery(query, next_token = None, limit=0, group_bys = [group_by]),
                                columns_to_get = ColumnsToGet(return_type = ColumnReturnType.ALL_FROM_INDEX))
for group_by in search_response.group_by_results:
    print("name:%s" % group_by.name)
    print("groups:")
    for item in group_by.items:
        print("range:%.1f~%.1f, count:%d" % (item.range_from, item.range_to, item.row_count))

参数	说明
name	自定义的统计聚合名称，用于区分不同的统计聚合，可根据此名称获取本次统计聚合结果。
field	用于统计聚合的字段，仅支持Geo_point类型。
origin(double lat, double lon)	起始中心点的经纬度。 lat是起始中心点坐标纬度，lon是起始中心点坐标经度。
range[double_from, double_to)	分组的范围，单位为米。起始值double_from可以使用最小值Double.MIN_VALUE，结束值double_to可以使用最大值Double.MAX_VALUE。
sub_aggs和sub_group_bys	子统计聚合，子统计聚合会根据分组内容再进行一次统计聚合分析。

query = TermQuery('age', 18)
group_by = GroupByGeoDistance(field_name = 'address', origin=GeoPoint(31, 116), ranges = [(0, 1000), (1000,2000)])
search_response = client.search(table_name, index_name,
                                SearchQuery(query, next_token = None, limit=2, group_bys = [group_by]),
                                columns_to_get = ColumnsToGet(return_type = ColumnReturnType.ALL_FROM_INDEX))
for group_by in search_response.group_by_results:
    print("name:%s" % group_by.name)
    print("groups:")
    for item in group_by.items:
        print("range:%.1f~%.1f, count:%d" % (item.range_from, item.range_to, item.row_count))

参数	说明
name	自定义的统计聚合名称，用于区分不同的统计聚合，可根据此名称获取本次统计聚合结果。
filter	过滤条件，返回结果的顺序和添加过滤条件的顺序一致。
sub_aggs和sub_group_bys	子统计聚合，子统计聚合会根据分组内容再进行一次统计聚合分析。

query = TermQuery('age', 18)
filter1 = TermQuery('math', 100)
filter2 = TermQuery('chinese', 100)
filters = [filter1, filter2]
group_by = GroupByFilter(filters)
search_response = client.search(
    table_name, index_name,
    SearchQuery(query, next_token = None, limit=2, group_bys = [group_by]),
    columns_to_get = ColumnsToGet(return_type = ColumnReturnType.ALL_FROM_INDEX))
for group_by in search_response.group_by_results:
    print("name:%s" % group_by.name)
    print("groups:")
    i = 0
    for item in group_by.items:
        print("filter:%s=%s, count:%d" % (str(filters[i].field_name), str(filters[i].column_value), item.row_count))
        i=i+1

参数	说明
name	自定义的统计聚合名称，用于区分不同的统计聚合，可根据此名称获取本次统计聚合结果。
field	用于统计聚合的字段，仅支持Long和Double类型。
interval	统计间隔。
field_range[min,max]	统计范围，与interval参数配合使用限制分组的数量。 `(fieldRange.max-fieldRange.min)/interval` 的值不能超过2000。
min_doc_count	最小行数。当分组中的行数小于最小行数时，不会返回此分组的统计结果。
missing_value	当某行数据中的字段为空时，字段值的默认值。如果未设置missing_value值，则在统计聚合时会忽略该行。如果设置了missing_value值，则使用missing_value值作为字段值的默认值参与统计聚合。

query = TermQuery('product', '10010')
group_by = GroupByHistogram(field_name = 'latency', interval = 100, field_range = FieldRange(0, 10000), missing_value = 0)
search_response = client.search(table_name, index_name,
                                SearchQuery(query, next_token = None, limit=2, group_bys = [group_by]),
                                columns_to_get = ColumnsToGet(return_type = ColumnReturnType.ALL_FROM_INDEX))
for group_by in search_response.group_by_results:
    print("name:%s" % group_by.name)
    print("groups:")
    for item in group_by.items:
        print("%s:%s" % (item.key, item.value))

背景信息

前提条件

最小值

最大值

和

平均值

统计行数

去重统计行数

百分位统计

字段值分组

范围分组

地理位置分组

过滤条件分组

直方图统计