表格存储：统计聚合

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

• 参数

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

• 示例

  /**
   *  商品库中有每一种商品的价格，求产地为浙江省的商品中，价格最低的商品价格是多少。
   *  等效的SQL语句是SELECT min(column_price) FROM product where place_of_production="浙江省";
   */
  func min(client *tablestore.TableStoreClient, tableName string, indexName string) {
      searchRequest := &tablestore.SearchRequest{}
  
      searchRequest.
          SetTableName(tableName).    //设置数据表名称。
          SetIndexName(indexName).    //设置多元索引名称。
          SetSearchQuery(search.NewSearchQuery().
              SetQuery(&search.TermQuery{"place_of_production", "浙江省"}).
              SetLimit(0).    //如果只关心统计聚合结果，不关心具体数据，您可以将limit设置为0来提高性能。
              Aggregation(search.NewMinAggregation("min_agg_1", "column_price").Missing(0.00)))
  
      searchResponse, err := client.Search(searchRequest)    //执行查询。
      aggResults := searchResponse.AggregationResults        //获取统计聚合结果。
      agg1, err := aggResults.Min("min_agg_1")        //获取名称为"min_agg_1"的统计聚合结果。
      if err != nil {
          panic(err)
      }
      if agg1.HasValue() {        //名称为"min_agg_1"的统计聚合结果是否有Value值。
          fmt.Println(agg1.Value)    //打印统计聚合结果。
      }
  }

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

• 参数

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

• 示例

  /**
   * 商品库中有每一种商品的价格，求产地为浙江省的商品中，价格最高的商品价格是多少。
   * 等效的SQL语句是SELECT max(column_price) FROM product where place_of_production="浙江省"。
   */
  func max(client *tablestore.TableStoreClient, tableName string, indexName string) {
      searchRequest := &tablestore.SearchRequest{}
  
      searchRequest.
          SetTableName(tableName).    //设置数据表名称。
          SetIndexName(indexName).    //设置多元索引名称。
          SetSearchQuery(search.NewSearchQuery().
              SetQuery(&search.TermQuery{"place_of_production", "浙江省"}).
              SetLimit(0).    //如果只关心统计聚合结果，不关心具体数据，您可以将limit设置为0来提高性能。
              Aggregation(search.NewMaxAggregation("max_agg_1", "column_price").Missing(0.00)))
  
      searchResponse, err := client.Search(searchRequest)    //执行查询。
      aggResults := searchResponse.AggregationResults        //获取统计聚合结果。
      agg1, err := aggResults.Max("max_agg_1")        //获取名称为"max_agg_1"的统计聚合结果。
      if err != nil {
          panic(err)
      }
      if agg1.HasValue() {        //名称为"max_agg_1"的统计聚合结果是否有Value值。
          fmt.Println(agg1.Value)    //打印统计聚合结果。
      }
  }

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

• 参数

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

• 示例

  /**
   * 商品库中有每一种商品的售出数量，求产地为浙江省的商品中，一共售出了多少件商品。如果某一件商品没有该值，默认售出了10件。
   * 等效的SQL语句是SELECT sum(column_price) FROM product where place_of_production="浙江省"。
   */
  func sum(client *tablestore.TableStoreClient, tableName string, indexName string) {
      searchRequest := &tablestore.SearchRequest{}
  
      searchRequest.
          SetTableName(tableName).    //设置数据表名称。
          SetIndexName(indexName).    //设置多元索引名称。
          SetSearchQuery(search.NewSearchQuery().
              SetQuery(&search.TermQuery{"place_of_production", "浙江省"}).
              SetLimit(0).    //如果只关心统计聚合结果，不关心具体数据，您可以将limit设置为0来提高性能。
              Aggregation(search.NewSumAggregation("sum_agg_1", "column_price").Missing(0.00)))
  
      searchResponse, err := client.Search(searchRequest)    //执行查询。
      aggResults := searchResponse.AggregationResults        //获取统计聚合结果。
      agg1, err := aggResults.Sum("sum_agg_1")        //获取名称为"sum_agg_1"的统计聚合结果。
      if err != nil {
          panic(err)
      }
      fmt.Println(agg1.Value)    //打印统计聚合结果。
  }

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

• 参数

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

• 示例

  /**
   * 商品库中有每一种商品的售出数量，求产地为浙江省的商品中，平均价格是多少。
   * 等效的SQL语句是SELECT avg(column_price) FROM product where place_of_production="浙江省"。
   */
  func avg(client *tablestore.TableStoreClient, tableName string, indexName string) {
      searchRequest := &tablestore.SearchRequest{}
  
      searchRequest.
          SetTableName(tableName).    //设置数据表名称。
          SetIndexName(indexName).    //设置多元索引名称。
          SetSearchQuery(search.NewSearchQuery().
              SetQuery(&search.TermQuery{"place_of_production", "浙江省"}).
              SetLimit(0).    //如果只关心统计聚合结果，不关心具体数据，您可以将limit设置为0来提高性能。
              Aggregation(search.NewAvgAggregation("avg_agg_1", "column_price").Missing(0.00)))
  
      searchResponse, err := client.Search(searchRequest)    //执行查询。
      aggResults := searchResponse.AggregationResults        //获取统计聚合结果。
      agg1, err := aggResults.Avg("avg_agg_1")        //获取名称为"avg_agg_1"的统计聚合结果。
      if err != nil {
          panic(err)
      }
      if agg1.HasValue() {        //名称为"agg1"的统计聚合结果是否有Value值。
          fmt.Println(agg1.Value)    //打印统计聚合结果。
      }
  }

• 参数

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

• 示例

  /**
   * 商家库中有每一种商家的惩罚记录，求浙江省的商家中，有惩罚记录的一共有多少个商家。如果商家没有惩罚记录，则商家信息中不存在该字段。
   * 等效的SQL语句是SELECT count(column_history) FROM product where place_of_production="浙江省"。
   */
  func count(client *tablestore.TableStoreClient, tableName string, indexName string) {
      searchRequest := &tablestore.SearchRequest{}
  
      searchRequest.
          SetTableName(tableName).    //设置数据表名称。
          SetIndexName(indexName).    //设置多元索引名称。
          SetSearchQuery(search.NewSearchQuery().
              SetQuery(&search.TermQuery{"place_of_production", "浙江省"}).
              SetLimit(0).    //如果只关心统计聚合结果，不关心具体数据，您可以将limit设置为0来提高性能。
              Aggregation(search.NewCountAggregation("count_agg_1", "column_price")))
  
      searchResponse, err := client.Search(searchRequest)    //执行查询。
      aggResults := searchResponse.AggregationResults        //获取统计聚合结果。
      agg1, err := aggResults.Count("count_agg_1")        //获取名称为"count_agg_1"的统计聚合结果。
      if err != nil {
          panic(err)
      }
      fmt.Println(agg1.Value)    //打印统计聚合结果。
  }

• 参数

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

• 示例

  /**
   * 求所有的商品，产地一共来自多少个省份。
   * 等效的SQL语句是SELECT count(distinct column_place) FROM product。
   */
  func distinctCount(client *tablestore.TableStoreClient, tableName string, indexName string) {
      searchRequest := &tablestore.SearchRequest{}
  
      searchRequest.
          SetTableName(tableName).    //设置数据表名称。
          SetIndexName(indexName).    //设置多元索引名称。
          SetSearchQuery(search.NewSearchQuery().
              SetQuery(&search.TermQuery{"place_of_production", "浙江省"}).
              SetLimit(0).    //如果只关心统计聚合结果，不关心具体数据，您可以将limit设置为0来提高性能。
              Aggregation(search.NewDistinctCountAggregation("distinct_count_agg_1", "column_price").Missing(0.00)))
  
      searchResponse, err := client.Search(searchRequest)    //执行查询。
      aggResults := searchResponse.AggregationResults        //获取统计聚合结果。
      agg1, err := aggResults.DistinctCount("distinct_count_agg_1")        //获取名称为"distinct_count_agg_1"的统计聚合结果。
      if err != nil {
          panic(err)
      }
      fmt.Println(agg1.Value)    //打印统计聚合结果。
  }

根据一个字段的值对查询结果进行分组，相同的字段值放到同一分组内，返回每个分组的值和该值对应的个数。

• 参数

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

• 示例

  /**
   * 所有商品中每一个类别各有多少个，且统计每一个类别的价格最大值和最小值。
   * 返回结果举例："水果：5个（其中价格的最大值为15，最小值为3），洗漱用品：10个（其中价格的最大值为98，最小值为1），电子设备：3个（其中价格的最大值为8699，最小值为2300），
   * 其它：15个（其中价格的最大值为1000，最小值为80）"。
   */
  func GroupByField(client *tablestore.TableStoreClient, tableName string, indexName string) {
      searchRequest := &tablestore.SearchRequest{}
  
      searchRequest.
          SetTableName(tableName).    //设置数据表名称。
          SetIndexName(indexName).    //设置多元索引名称。
          SetSearchQuery(search.NewSearchQuery().
              SetQuery(&search.MatchAllQuery{}).    //匹配所有行。
              SetLimit(0).
              GroupBy(search.NewGroupByField("group1", "column_type").    //按商品类别的字段值进行分组。
                  SubAggregation(search.NewMinAggregation("min_price", "column_price")).    //分组中最便宜的商品。
                  SubAggregation(search.NewMaxAggregation("max_price", "column_price"))))    //分组中最贵的商品。
  
      searchResponse, err := client.Search(searchRequest)
      if err != nil {
          fmt.Printf("%#v", err)
          return
      }
      groupByResults := searchResponse.GroupByResults    //获取统计聚合结果。
      group, err := groupByResults.GroupByField("group1")
      if err != nil {
          fmt.Printf("%#v", err)
          return
      }
  
      for _, item := range group.Items {    //遍历返回的所有分组。
          //打印分组的值和分组中的记录行数。
          fmt.Println("\tkey: ", item.Key, ", rowCount: ", item.RowCount) 
  
          //打印价格的最小值。
          minPrice, _ := item.SubAggregations.Min("min_price")
          if minPrice.HasValue() {
              fmt.Println("\t\tmin_price: ", minPrice.Value)
          }
  
          //打印价格的最大值。
          maxPrice, _ := item.SubAggregations.Max("max_price")
          if maxPrice.HasValue() {
              fmt.Println("\t\tmax_price: ", maxPrice.Value)
          }
      }
  }

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

• 参数

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

• 示例

  /**
   * 求商品销量时按[NegInf，1000）、[1000，5000）、[5000，Inf）这些分组计算每个范围的销量。
   */
  func GroupByRange(client *tablestore.TableStoreClient, tableName string, indexName string) {
      searchRequest := &tablestore.SearchRequest{}
  
      searchRequest.
          SetTableName(tableName).    //设置数据表名称。
          SetIndexName(indexName).    //设置多元索引名称。
          SetSearchQuery(search.NewSearchQuery().
              SetQuery(&search.MatchAllQuery{}).    //匹配所有行。
              SetLimit(0).
              GroupBy(search.NewGroupByRange("group1", "column_number").
                  Range(search.NegInf, 1000).
                  Range(1000, 5000).
                  Range(5000, search.Inf)))
  
      searchResponse, err := client.Search(searchRequest)
      if err != nil {
          fmt.Printf("%#v", err)
          return
      }
      groupByResults := searchResponse.GroupByResults    //获取统计聚合结果。
      group, err := groupByResults.GroupByRange("group1")
      if err != nil {
          fmt.Printf("%#v", err)
          return
      }
      for _, item := range group.Items {    //遍历返回的所有分组。
          fmt.Println("\t[", item.From, ", ", item.To, "), rowCount: ", item.RowCount)    //打印本次分组的行数。
      }
  }

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

• 参数

  参数	说明
  Name	自定义的统计聚合名称，用于区分不同的统计聚合，可根据此名称获取本次统计聚合结果。
  FieldName	用于统计聚合的字段，仅支持Geo_point类型。
  CenterPoint(latitude float64, longitude float64)	起始中心点的经纬度。 latitude是起始中心点坐标纬度，longitude是起始中心点坐标经度。
  Range(fromInclusive float64, toExclusive float64)	分组的范围，单位为米。 起始值fromInclusive可以使用最小值NegInf，结束值toExclusive可以使用最大值Inf。
  SubAggregation和SubGroupBy	子统计聚合，子统计聚合会根据分组内容再进行一次统计聚合分析。

• 示例

  
  /**
   * 求距离万达广场[NegInf，1000）、[1000，5000）、[5000，Inf）这些范围内的人数，单位为米。
   */
  func GroupByGeoDistance(client *tablestore.TableStoreClient, tableName string, indexName string) {
      searchRequest := &tablestore.SearchRequest{}
  
      searchRequest.
          SetTableName(tableName).    //设置数据表名称。
          SetIndexName(indexName).    //设置多元索引名称。
          SetSearchQuery(search.NewSearchQuery().
              SetQuery(&search.MatchAllQuery{}).    //匹配所有行。
              SetLimit(0).
              GroupBy(search.NewGroupByGeoDistance("group1", "Col_GeoPoint", search.GeoPoint{Lat: 30.137817, Lon:120.08681}).
                  Range(search.NegInf, 1000).
                  Range(1000, 5000).
                  Range(5000, search.Inf)))
  
      searchResponse, err := client.Search(searchRequest)
      if err != nil {
          fmt.Printf("%#v", err)
          return
      }
      groupByResults := searchResponse.GroupByResults    //获取统计聚合结果。
      group, err := groupByResults.GroupByGeoDistance("group1")
      if err != nil {
          fmt.Printf("%#v", err)
          return
      }
      for _, item := range group.Items {    //遍历返回的所有分组。
          fmt.Println("\t[", item.From, ", ", item.To, "), rowCount: ", item.RowCount)    //打印本次分组的行数。
      }
  }

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

• 参数

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

• 示例

  /**
   * 按照过滤条件进行分组，例如添加三个过滤条件（销量大于100、产地是浙江省、描述中包含杭州关键词），然后获取每个过滤条件匹配到的数量。
   */
  func GroupByFilter(client *tablestore.TableStoreClient, tableName string, indexName string) {
      searchRequest := &tablestore.SearchRequest{}
  
      searchRequest.
          SetTableName(tableName).    //设置数据表名称。
          SetIndexName(indexName).    //设置多元索引名称。
          SetSearchQuery(search.NewSearchQuery().
              SetQuery(&search.MatchAllQuery{}).    //匹配所有行。
              SetLimit(0).
              GroupBy(search.NewGroupByFilter("group1").
                  Query(&search.RangeQuery{
                      FieldName: "number",
                      From: 100,
                      IncludeLower: true}).
                  Query(&search.TermQuery{
                      FieldName: "place",
                      Term:      "浙江省",
                  }).
                  Query(&search.MatchQuery{
                      FieldName: "description",
                      Text: "杭州",
                  })))
  
      searchResponse, err := client.Search(searchRequest)
      if err != nil {
          fmt.Printf("%#v", err)
          return
      }
      groupByResults := searchResponse.GroupByResults    //获取统计聚合结果。
      group, err := groupByResults.GroupByFilter("group1")
      if err != nil {
          fmt.Printf("%#v", err)
          return
      }
      for _, item := range group.Items {    //遍历返回的所有分组。
          fmt.Println("\trowCount: ", item.RowCount)    //打印本次分组的行数。
      }
  }

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

主要用于在分组内再次进行统计聚合，以两层的嵌套为例：

• GroupBy+SubGroupBy：按省份分组后再按照城市分组，获取每个省份下每个城市的数据。

• GroupBy+SubAggregation：按照省份分组后再求某个指标的最大值，获取每个省的某个指标最大值。

示例

/**
 * 嵌套的统计聚合示例。
 * 外层GroupByField中添加了2个Aggregation和1个GroupByRange。
 */
func NestedSample(client *tablestore.TableStoreClient, tableName string, indexName string) {
    searchRequest := &tablestore.SearchRequest{}

    searchRequest.
        SetTableName(tableName).    //设置数据表名称。
        SetIndexName(indexName).    //设置多元索引名称。
        SetSearchQuery(search.NewSearchQuery().
            SetQuery(&search.MatchAllQuery{}).    //匹配所有行。
            SetLimit(0).
            GroupBy(search.NewGroupByField("group1", "field1").
                SubAggregation(search.NewMinAggregation("sub_agg1", "sub_field1")).
                SubAggregation(search.NewMaxAggregation("sub_agg2", "sub_field2")).
                SubGroupBy(search.NewGroupByRange("sub_group1", "sub_field3").
                    Range(search.NegInf, 3).
                    Range(3, 5).
                    Range(5, search.Inf))))

    searchResponse, err := client.Search(searchRequest)
    if err != nil {
        fmt.Printf("%#v", err)
        return
    }
    groupByResults := searchResponse.GroupByResults    //获取统计聚合结果。
    group, err := groupByResults.GroupByField("group1")
    if err != nil {
        fmt.Printf("%#v", err)
        return
    }

    for _, item := range group.Items {    //遍历返回的所有分组。
        //打印分组的值和分组中的记录行数。
        fmt.Println("\tkey: ", item.Key, ", rowCount: ", item.RowCount) 

        //获取名称为"sub_agg1"的统计聚合结果。
        subAgg1, _ := item.SubAggregations.Min("sub_agg1")
        if subAgg1.HasValue() {
            fmt.Println("\t\tsub_agg1: ", subAgg1.Value)
        }

        //获取名称为"sub_agg2"的统计聚合结果。
        subAgg2, _ := item.SubAggregations.Max("sub_agg2")
        if subAgg2.HasValue() {
            fmt.Println("\t\tsub_agg2: ", subAgg2.Value)
        }

        //获取名称为"sub_group1"的统计聚合结果。
        subGroup, _ := item.SubGroupBys.GroupByRange("sub_group1")
        for _, item := range subGroup.Items {
            fmt.Println("\t\t[", item.From, ", ", item.To, "), rowCount: ", item.RowCount)
        }
    }
}

多个统计聚合功能可以组合使用。

• 示例1

  func MultipleAggregations(client *tablestore.TableStoreClient, tableName string, indexName string) {
      searchRequest := &tablestore.SearchRequest{}
  
      searchRequest.
          SetTableName(tableName).    //设置数据表名称。
          SetIndexName(indexName).    //设置多元索引名称。
          SetSearchQuery(search.NewSearchQuery().
              SetQuery(&search.MatchAllQuery{}).    //匹配所有行。
              SetLimit(0).
              Aggregation(search.NewAvgAggregation("agg1", "Col_Long")).              //计算Col_Long字段的平均值。
              Aggregation(search.NewDistinctCountAggregation("agg2", "Col_Long")).    //计算Col_Long字段不同取值的个数。
              Aggregation(search.NewMaxAggregation("agg3", "Col_Long")).              //计算Col_Long字段的最大值。
              Aggregation(search.NewSumAggregation("agg4", "Col_Long")).              //计算Col_Long字段的和。
              Aggregation(search.NewCountAggregation("agg5", "Col_Long")))            //计算存在Col_Long字段的行数。
  
      //设置返回所有列。
      searchRequest.SetColumnsToGet(&tablestore.ColumnsToGet{
          ReturnAll: true,
      })
      searchResponse, err := client.Search(searchRequest)
      if err != nil {
          fmt.Printf("%#v", err)
          return
      }
      aggResults := searchResponse.AggregationResults    //获取统计聚合结果。
  
      //获取求平均值的统计聚合结果。
      agg1, err := aggResults.Avg("agg1")            //获取名称为"agg1"的统计聚合结果，类型为Avg。
      if err != nil {
          panic(err)
      }
      if agg1.HasValue() {                           //名称为"agg1"的统计聚合结果是否有Value值。
          fmt.Println("(avg) agg1: ", agg1.Value)    //打印Col_Long字段平均值。
      } else {
          fmt.Println("(avg) agg1: no value")        //所有行都不存在Col_Long字段时的打印信息。
      }
  
      //获取去重统计行数的统计聚合结果。
      agg2, err := aggResults.DistinctCount("agg2")  //获取名称为"agg2"的统计聚合结果，类型为DistinctCount。
      if err != nil {
          panic(err)
      }
      fmt.Println("(distinct) agg2: ", agg2.Value)   //打印Col_Long字段不同取值的个数。
  
      //获取求最大值的统计聚合结果。
      agg3, err := aggResults.Max("agg3")            //获取名称为"agg3"的统计聚合结果，类型为Max。
      if err != nil {
          panic(err)
      }
      if agg3.HasValue() {
          fmt.Println("(max) agg3: ", agg3.Value)    //打印Col_Long字段最大值。
      } else {
          fmt.Println("(max) agg3: no value")        //所有行都不存在Col_Long字段时的打印信息。
      }
  
      //获取求和的统计聚合结果。
      agg4, err := aggResults.Sum("agg4")            //获取名称为"agg4"的统计聚合结果，类型为Sum。
      if err != nil {
          panic(err)
      }
      fmt.Println("(sum) agg4: ", agg4.Value)        //打印Col_Long字段的和。
  
      //获取统计行数的统计聚合结果。
      agg5, err := aggResults.Count("agg5")          //获取名称为"agg5"的统计聚合结果，类型为Count。
      if err != nil {
          panic(err)
      }
      fmt.Println("(count) agg6: ", agg5.Value)      //打印存在Col_Long字段的个数。
  }

• 示例2

  func MultipleAggregationsAndGroupBysSample(client *tablestore.TableStoreClient, tableName string, indexName string) {
      searchRequest := &tablestore.SearchRequest{}
  
      searchRequest.
          SetTableName(tableName).    //设置数据表名称。
          SetIndexName(indexName).    //设置多元索引名称。
          SetSearchQuery(search.NewSearchQuery().
              SetQuery(&search.MatchAllQuery{}).    //匹配所有行。
              SetLimit(0).
              Aggregation(search.NewAvgAggregation("agg1", "Col_Long")).              //计算Col_Long字段的平均值。
              Aggregation(search.NewDistinctCountAggregation("agg2", "Col_Long")).    //计算Col_Long字段不同取值的个数。
              Aggregation(search.NewMaxAggregation("agg3", "Col_Long")).              //计算Col_Long字段的最大值。
              GroupBy(search.NewGroupByField("group1", "Col_Keyword").    //对Col_Keyword字段做GroupByField取值统计聚合。
                  GroupBySorters([]search.GroupBySorter{}).    //指定返回结果分组的顺序。
                  Size(2).                                     //仅返回前2个分组。
                  SubAggregation(search.NewAvgAggregation("sub_agg1", "Col_Long")).    //对每个分组进行子统计聚合。
                  SubGroupBy(search.NewGroupByField("sub_group1", "Col_Keyword2"))).   //对每个分组进行子统计聚合。
              GroupBy(search.NewGroupByRange("group2", "Col_Long").        //对Col_Long字段做GroupByRange范围。
                  Range(search.NegInf, 3).     //第一个分组包含Col_Long在(NegInf, 3)的索引行。
                  Range(3, 5).                 //第二个分组包含Col_Long在[3, 5)的索引行。
                  Range(5, search.Inf)))       //第三个分组包含Col_Long在[5, Inf)的索引行。
  
      // 设置返回所有列。
      searchResponse, err := client.Search(searchRequest)
      if err != nil {
          fmt.Printf("%#v", err)
          return
      }
  
      aggResults := searchResponse.AggregationResults    //获取统计聚合结果。
      //获取求平均值的统计聚合结果。
      agg1, err := aggResults.Avg("agg1")            //获取名称为"agg1"的统计聚合结果，类型为Avg。
      if err != nil {
          panic(err)
      }
      if agg1.HasValue() {                           //名称为"agg1"的统计聚合结果是否有Value值。
          fmt.Println("(avg) agg1: ", agg1.Value)    //打印Col_Long字段平均值。
      } else {
          fmt.Println("(avg) agg1: no value")        //所有行都不存在Col_Long字段时的打印信息。
      }
  
      //获取去重统计行数的统计聚合结果。
      agg2, err := aggResults.DistinctCount("agg2")  //获取名称为"agg2"的统计聚合结果，类型为DistinctCount。
      if err != nil {
          panic(err)
      }
      fmt.Println("(distinct) agg2: ", agg2.Value)   //打印Col_Long字段不同取值的个数。
  
      //获取求最大值的统计聚合结果。
      agg3, err := aggResults.Max("agg3")        //获取名称为"agg3"的统计聚合结果，类型为Max。
      if err != nil {
          panic(err)
      }
      if agg3.HasValue() {
          fmt.Println("(max) agg3: ", agg3.Value)    //打印Col_Long字段最大值。
      } else {
          fmt.Println("(max) agg3: no value")        //所有行都不存在Col_Long字段时的打印信息。
      }
  
      groupByResults := searchResponse.GroupByResults    //获取统计聚合结果。
      //获取按字段值分组的统计聚合结果。
      group1, err := groupByResults.GroupByField("group1")    //获取名称为"group1"的统计聚合结果，类型为GroupByField。
      if err != nil {
          panic(err)
      }
      fmt.Println("group1: ")
      for _, item := range group1.Items {    //遍历返回的所有分组。
          //item
          fmt.Println("\tkey: ", item.Key, ", rowCount: ", item.RowCount)    //打印本次分组的行数。
  
          //获取求平均值的子统计聚合结果。
          subAgg1, err := item.SubAggregations.Avg("sub_agg1")    //获取名称为"sub_agg1"的子统计聚合结果，类型为Avg。
          if err != nil {
              panic(err)
          }
          if subAgg1.HasValue() {    //如果子统计聚合"sub_agg1"计算出了Col_Long字段的平均值，则HasValue()返回true。
              fmt.Println("\t\tsub_agg1: ", subAgg1.Value)    //打印本次分组中，子统计聚合计算的Col_Long字段的平均值。
          }
  
          //获取按字段值分组的子统计聚合结果。
          subGroup1, err := item.SubGroupBys.GroupByField("sub_group1")    //获取名称为"sub_group1"的子统计聚合结果，类型为GroupByField。
          if err != nil {
              panic(err)
          }
          fmt.Println("\t\tsub_group1")
          for _, subItem := range subGroup1.Items {    //遍历名称为"sub_group1"的子统计聚合结果。
              fmt.Println("\t\t\tkey: ", subItem.Key, ", rowCount: ", subItem.RowCount)    //打印"sub_group1"的子统计聚合结果分组，即分组中的行数。
              tablestore.Assert(subItem.SubAggregations.Empty(), "")
              tablestore.Assert(subItem.SubGroupBys.Empty(), "")
          }
      }
  
      //获取按范围分组的统计聚合结果。
      group2, err := groupByResults.GroupByRange("group2")    //获取名称为"group2"的统计聚合结果，类型为GroupByRange。
      if err != nil {
          panic(err)
      }
      fmt.Println("group2: ")
      for _, item := range group2.Items {    //遍历返回的所有分组。
          fmt.Println("\t[", item.From, ", ", item.To, "), rowCount: ", item.RowCount)    //打印本次分组的行数。
      }
  }