Tablestore:Aggregation

MinAggregation, MaxAggregation, AvgAggregation y SumAggregation

CountAggregation y DistinctCountAggregation

CountAggregation cuenta las filas donde el campo especificado no es nulo, por lo que resulta adecuado para columnas dispersas. Para contar todas las filas que coinciden con una consulta, llame a SetGetTotalCount(true) y lea SearchResponse.TotalCount. Si necesita contar todas las filas de un índice de búsqueda, utilice MatchAllQuery como condición de consulta.

PercentilesAggregation

PercentilesAggregation es compatible con Tablestore SDK for Go 1.7.0 y versiones posteriores.

TopRowsAggregation

Utilice TopRowsAggregation como subagregación de un grupo. Esta función es compatible con Tablestore SDK for Go 1.7.0 y versiones posteriores.

SearchRequest.ColumnsToGet controla qué columnas de atributos se devuelven. Para devolver columnas de atributos directamente desde el índice de búsqueda, almacene los campos correspondientes cuando cree el índice. Si no especifica las columnas de retorno, solo se devuelven las columnas de clave primaria.

GroupByField

Clasificación de grupos

Se admiten los siguientes tipos de clasificación de grupos:

• GroupKeyGroupBySort: Ordena las claves de grupo en orden léxico ascendente o descendente.

• RowCountGroupBySort: Ordena por el conteo de filas del grupo en orden ascendente o descendente. El orden descendente por conteo de filas es el predeterminado.

• SubAggGroupBySort: Ordena según el resultado de la subagregación especificada en orden ascendente o descendente.

GroupByRange

GroupByGeoDistance

GroupByFilter

GroupByHistogram

GroupByDateHistogram

GroupByDateHistogram es compatible con Tablestore SDK for Go 1.7.10 y versiones posteriores.

GroupByGeoGrid

GroupByGeoGrid es compatible con Tablestore SDK for Go 1.7.12 y versiones posteriores.

GroupByComposite

GroupByComposite es compatible con Tablestore SDK for Go 1.7.15 y versiones posteriores.

groupBy := search.NewGroupByField("category_group", "category").
    Size(10).
    SubAggregation(search.NewMaxAggregation("max_price", "price")).
    SubGroupBy(search.NewGroupByField("status_group", "status").Size(10))

searchQuery := search.NewSearchQuery().
    SetQuery(&search.MatchAllQuery{}).
    SetLimit(0).
    GroupBy(groupBy)
response, err := client.Search(&tablestore.SearchRequest{
    TableName:   "example_table",
    IndexName:   "example_index",
    SearchQuery: searchQuery,
})
if err != nil {
    log.Fatal(err)
}

result, err := response.GroupByResults.GroupByField("category_group")
if err != nil {
    log.Fatal(err)
}
for _, item := range result.Items {
    maxPrice, err := item.SubAggregations.Max("max_price")
    if err != nil {
        log.Fatal(err)
    }
    statuses, err := item.SubGroupBys.GroupByField("status_group")
    if err != nil {
        log.Fatal(err)
    }
    fmt.Println(item.Key, maxPrice.Value, statuses.Items)
}

composite := search.NewGroupByComposite("category_status_group").
    SourceGroupBys(
        search.NewGroupByField("category", "category"),
        search.NewGroupByField("status", "status"),
    ).
    SetSize(100)

var nextToken *string
for {
    if nextToken != nil {
        composite.SetNextToken(nextToken)
    }
    searchQuery := search.NewSearchQuery().
        SetQuery(&search.MatchAllQuery{}).
        SetLimit(0).
        GroupBy(composite)
    response, err := client.Search(&tablestore.SearchRequest{
        TableName:   "example_table",
        IndexName:   "example_index",
        SearchQuery: searchQuery,
    })
    if err != nil {
        log.Fatal(err)
    }

    result, err := response.GroupByResults.GroupByComposite(
        "category_status_group",
    )
    if err != nil {
        log.Fatal(err)
    }
    for _, item := range result.Items {
        fmt.Println(item.Keys, item.RowCount)
    }

    nextToken = result.NextToken
    if nextToken == nil || *nextToken == "" {
        break
    }
}

priceRanges := search.NewGroupByRange("price_ranges", "price").
    Range(0, 200).
    Range(200, 500)
distanceRanges := search.NewGroupByGeoDistance(
    "distance_ranges",
    "location",
    search.GeoPoint{Lat: 30.2741, Lon: 120.1551},
).
    Range(0, 100000).
    Range(100000, 1500000)
categoryFilters := search.NewGroupByFilter("category_filters").
    Query(&search.TermQuery{FieldName: "category", Term: "book-go"}).
    Query(&search.TermQuery{FieldName: "category", Term: "game"})

searchQuery := search.NewSearchQuery().
    SetQuery(&search.MatchAllQuery{}).
    SetLimit(0).
    GroupBy(priceRanges, distanceRanges, categoryFilters)
response, err := client.Search(&tablestore.SearchRequest{
    TableName:   "example_table",
    IndexName:   "example_index",
    SearchQuery: searchQuery,
})
if err != nil {
    log.Fatal(err)
}

priceResult, err := response.GroupByResults.GroupByRange("price_ranges")
if err != nil {
    log.Fatal(err)
}
distanceResult, err := response.GroupByResults.GroupByGeoDistance(
    "distance_ranges",
)
if err != nil {
    log.Fatal(err)
}
filterResult, err := response.GroupByResults.GroupByFilter("category_filters")
if err != nil {
    log.Fatal(err)
}
fmt.Println(priceResult.Items)
fmt.Println(distanceResult.Items)
fmt.Println(filterResult.Items)

groupKeyAscending := []search.GroupBySorter{
    &search.GroupKeyGroupBySort{Order: search.SortOrder_ASC.Enum()},
}
priceHistogram := search.NewGroupByHistogram("price_histogram", "price").
    SetInterval(int64(200)).
    SetFiledRange(int64(0), int64(600)).
    SetMinDocCount(1).
    SetGroupBySorters(groupKeyAscending)
dateHistogram := search.NewGroupByDateHistogram(
    "date_histogram",
    "event_time",
).
    SetInterval(model.DateTimeValue{
        Value: proto.Int32(1),
        Unit:  model.DateTimeUnit_MONTH.Enum(),
    }).
    SetFiledRange("2026-01-01T00:00:00", "2026-05-01T00:00:00").
    SetTimeZone("+08:00").
    SetMinDocCount(1).
    SetGroupBySorters(groupKeyAscending)

searchQuery := search.NewSearchQuery().
    SetQuery(&search.MatchAllQuery{}).
    SetLimit(0).
    GroupBy(priceHistogram, dateHistogram)
response, err := client.Search(&tablestore.SearchRequest{
    TableName:   "example_table",
    IndexName:   "example_index",
    SearchQuery: searchQuery,
})
if err != nil {
    log.Fatal(err)
}

priceResult, err := response.GroupByResults.GroupByHistogram("price_histogram")
if err != nil {
    log.Fatal(err)
}
dateResult, err := response.GroupByResults.GroupByDateHistogram("date_histogram")
if err != nil {
    log.Fatal(err)
}
fmt.Println(priceResult.Items)
fmt.Println(dateResult.Items)

searchQuery := search.NewSearchQuery().
    SetQuery(&search.MatchAllQuery{}).
    SetLimit(0).
    GroupBy(
        search.NewGroupByGeoGrid("geo_grid", "location").
            SetPrecision(model.GHP_39KM_19KM_4).
            SetSize(100),
    )
response, err := client.Search(&tablestore.SearchRequest{
    TableName:   "example_table",
    IndexName:   "example_index",
    SearchQuery: searchQuery,
})
if err != nil {
    log.Fatal(err)
}

result, err := response.GroupByResults.GroupByGeoGrid("geo_grid")
if err != nil {
    log.Fatal(err)
}
fmt.Println(result.Items)

topRows := search.NewTopRowsAggregation("top_price").
    SetLimit(1).
    SetSort(&search.Sort{Sorters: []search.Sorter{
        &search.FieldSort{
            FieldName: "price",
            Order:     search.SortOrder_DESC.Enum(),
        },
    }})
groupBy := search.NewGroupByField("category_group", "category").
    Size(10).
    SubAggregation(topRows)
searchQuery := search.NewSearchQuery().
    SetQuery(&search.MatchAllQuery{}).
    SetLimit(0).
    GroupBy(groupBy)

response, err := client.Search(&tablestore.SearchRequest{
    TableName:   "example_table",
    IndexName:   "example_index",
    SearchQuery: searchQuery,
    ColumnsToGet: &tablestore.ColumnsToGet{
        Columns: []string{"category", "price"},
    },
})
if err != nil {
    log.Fatal(err)
}

groups, err := response.GroupByResults.GroupByField("category_group")
if err != nil {
    log.Fatal(err)
}
for _, item := range groups.Items {
    rows, err := item.SubAggregations.TopRows("top_price")
    if err != nil {
        log.Fatal(err)
    }
    fmt.Println(item.Key, rows.Value)
}