本文主要为您介绍多元索引的统计接口。

类型

  • 最小值
    • 定义:返回一个字段中的最小值,类似于SQL中的min。如字段值不存在则不包括在计算中。可设置默认值。
    • 参数说明
      参数 说明
      Name 用户给本次统计聚合功能自定义的名字,用于区分不同的统计聚合操作。在使用结果时,需要根据该名字找到本次统计聚合的结果。
      FieldName 统计操作作用的字段,仅支持long、double类型。
      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).    //如果只关心统计聚合的结果,返回匹配到的结果数量设置为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"的Aggregation结果
          if err != nil {
              panic(err)
          }
          if agg1.HasValue() {        //名字为"min_agg_1"的Aggregation结果是否有Value值
              fmt.Println(agg1.Value)    //打印统计结果
          }
      }
  • 最大值
    • 定义:返回一个字段中的最大值,类似于SQL中的max。如字段值不存在则不包括在计算中。可设置默认值。
    • 参数说明
      参数 说明
      Name 用户给本次统计聚合功能自定义的名字,用于区分不同的统计聚合操作。在使用结果时,需要根据该名字找到本次统计聚合的结果。
      FieldName 统计操作作用的字段,仅支持long、double类型。
      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).    //如果只关心统计聚合的结果,返回匹配到的结果数量设置为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"的Aggregation结果
          if err != nil {
              panic(err)
          }
          if agg1.HasValue() {        //名字为"max_agg_1"的Aggregation结果是否有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).    //如果只关心统计聚合的结果,返回匹配到的结果数量设置为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"的Aggregation结果
          if err != nil {
              panic(err)
          }
          fmt.Println(agg1.Value)    //打印统计结果
      }
  • 平均值
    • 定义:返回数值字段的平均值,类似于SQL中的avg。如字段值不存在则不包括在计算中。可设置默认值。
    • 参数说明
      参数 说明
      Name 用户给本次统计聚合功能自定义的名字,用于区分不同的统计聚合操作。在使用结果时,需要根据该名字找到本次统计聚合的结果。
      FieldName 统计操作作用的字段,仅支持long、double类型。
      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).    //如果只关心统计聚合的结果,返回匹配到的结果数量设置为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"的Aggregation结果
          if err != nil {
              panic(err)
          }
          if agg1.HasValue() {        //名字为"agg1"的Aggregation结果 是否Value值
              fmt.Println(agg1.Value)    //打印统计结果
          }
      }
  • 文档个数
    • 定义:返回指定字段值的数目,类似于SQL中的count。如一行数据中没有该字段则不参与文档计数。
    • 参数说明
      参数 说明
      Name 用户给本次统计聚合功能自定义的名字,用于区分不同的统计聚合操作。在使用结果时,需要根据该名字找到本次统计聚合的结果。
      FieldName 统计操作作用的字段。文档个数的统计仅支持long、double、boolean、keyword、geo_point类型。
    • 示例
      
      /**
       * 商家库里有每一个商家的惩罚记录,求浙江省的商家中,有惩罚记录的一共有多少个商家?(假设没有惩罚记录的商家信息中不存在该字段)
       * 等效的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).    //如果只关心统计聚合的结果,返回匹配到的结果数量设置为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"的Aggregation结果
          if err != nil {
              panic(err)
          }
          fmt.Println(agg1.Value)    //打印统计结果
      }
    • 去重文档个数
      • 定义:返回指定字段的不同值的数目,类似于SQL中的count(distinct)。可设置字段的默认值(missing)。
      • 误差:去重文档个数的计算是大约值,在文档数较多时候会存在一定的误差。文档数到1亿时,误差为2%以内。
      • 参数说明
        参数 说明
        Name 用户给本次统计聚合功能自定义的名字,用于区分不同的统计聚合操作。在使用结果时,需要根据该名字找到本次统计聚合的结果。
        FieldName 统计操作作用的字段。仅支持long、double、boolean、keyword、geo_point类型。
        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).    //如果只关心统计聚合的结果,返回匹配到的结果数量设置为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"的Aggregation结果
            if err != nil {
                panic(err)
            }
            fmt.Println(agg1.Value)    //打印统计结果
        }

多个统计

每次请求支持多个统计一起分析。

示例

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    //获取所有统计结果

    //avg agg
    agg1, err := aggResults.Avg("agg1")        //获取名字为"agg1"的Aggregation结果,类型为Avg
    if err != nil {
        panic(err)
    }
    if agg1.HasValue() {                            //名字为"agg1"的Aggregation结果是否Value值
        fmt.Println("(avg) agg1: ", agg1.Value)    //打印Col_Long字段平均值
    } else {
        fmt.Println("(avg) agg1: no value")        //所有行都不存在Col_Long字段
    }

    //distinct count agg
    agg2, err := aggResults.DistinctCount("agg2")    //获取名字为"agg2"的Aggregation结果,类型为DistinctCount
    if err != nil {
        panic(err)
    }
    fmt.Println("(distinct) agg2: ", agg2.Value)        //打印Col_Long字段不同取值的个数

    //max agg
    agg3, err := aggResults.Max("agg3")        //获取名字为"agg3"的Aggregation结果,类型为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字段
    }

    //sum agg
    agg4, err := aggResults.Sum("agg4")        //获取名字为"agg4"的Aggregation结果,类型为Sum
    if err != nil {
        panic(err)
    }
    fmt.Println("(sum) agg4: ", agg4.Value)        //打印Col_Long字段的和

    //count agg
    agg5, err := aggResults.Count("agg5")        //获取名字为"agg5"的Aggregation结果,类型为Count
    if err != nil {
        panic(err)
    }
    fmt.Println("(count) agg6: ", agg5.Value)    //打印存在Col_Long字段的个数
}