Agregação - Tablestore: Central de Documentação do Alibaba Cloud

Execute operações de agregação para obter valores mínimos, máximos, somas e médias, além da contagem total e distinta de linhas. Agrupe resultados por valor de campo, intervalo, localização geográfica ou filtro e realize consultas aninhadas. Combine múltiplas operações de agregação para atender a cenários de consulta complexos.

Procedimento

A figura a seguir ilustra o fluxo completo de uma operação de agregação.

fig_agg_pro

O servidor consulta os dados que atendem às condições especificadas e executa a agregação conforme a solicitação. Por isso, requisições com agregação demandam processamento mais complexo do que aquelas sem essa necessidade.

Informações básicas

A tabela a seguir descreve os métodos de agregação disponíveis.

Método	Descrição
Valor mínimo	Retorna o menor valor de um campo. Funciona de maneira semelhante à função MIN do SQL.
Valor máximo	Retorna o maior valor de um campo. Equivale à função MAX do SQL.
Soma	Calcula a soma de todos os valores de um campo numérico. Comportamento similar à função SUM do SQL.
Valor médio	Obtém a média de todos os valores de um campo numérico. Corresponde à função AVG do SQL.
Contagem	Indica a quantidade total de valores de um campo específico ou o número total de linhas em um índice de busca. Assemelha-se à função COUNT do SQL.
Contagem distinta	Fornece a quantidade de valores únicos para um campo. Opera de forma parecida com a função COUNT(DISTINCT) do SQL.
Estatísticas de percentil	Um valor de percentil indica a posição relativa de um dado dentro de um conjunto. Por exemplo, ao coletar estatísticas sobre o tempo de resposta de requisições durante a operação e manutenção (O&M) rotineira do sistema, analise a distribuição desses tempos usando percentis como p25, p50, p90 e p99.
Agrupamento por valor de campo	Agrupa os resultados da consulta com base nos valores dos campos. Valores idênticos ficam no mesmo grupo. O retorno inclui o valor de cada grupo e a respectiva contagem de ocorrências. Nota Se um grupo tiver uma quantidade muito grande de valores, o número calculado pode divergir do valor real.
Agrupamento por intervalo	Organiza os resultados da consulta conforme faixas de valores de um campo. Valores dentro de um intervalo específico são agrupados e o sistema retorna a contagem de itens em cada faixa.
Agrupamento por localização geográfica	Classifica os resultados da consulta segundo a distância entre as localizações geográficas e um ponto central. Itens cujas distâncias se enquadram em determinada faixa formam um grupo e a quantidade de valores por intervalo é retornada.
Agrupamento por filtro	Filtra os resultados da consulta e os agrupa para mostrar quantos itens correspondem a cada condição. A ordem de retorno segue a sequência de definição dos filtros.
Consulta por histograma	Segmenta os resultados da consulta em intervalos de dados predefinidos. Valores de campo na mesma faixa pertencem ao mesmo grupo. O resultado exibe o intervalo de valores e a contagem de itens de cada grupo.
Consulta das linhas obtidas dos resultados de agregação em cada grupo	Após agrupar os resultados, consulte as linhas pertencentes a cada grupo. Esse método equivale à função ANY_VALUE(campo) do MySQL.

Pré-requisitos

Inicialize uma instância OTSClient. Para mais detalhes, consulte Inicializar uma instância OTSClient.
Crie uma tabela de dados e grave informações nela. Consulte Criar tabelas de dados e Gravar dados para orientações.
Crie um índice de busca para a tabela de dados. Consulte Criar um índice de busca para instruções completas.

Valor mínimo

Retorna o menor valor de um campo. Funciona de maneira semelhante à função MIN do SQL.

Parâmetros

Parâmetro	Descrição
name	Nome exclusivo da operação de agregação. Use esse identificador para recuperar os resultados de uma agregação específica.
fieldName	Campo utilizado na operação de agregação. Apenas os tipos LONG, DOUBLE e DATE são aceitos.
missing	Valor padrão assumido pelo campo quando este estiver vazio em uma linha durante a agregação. Sem a definição de missing, a linha é desconsiderada. Ao definir missing, o sistema adota esse valor como o conteúdo do campo na linha.

Exemplo

let searchQuery = {
    offset: 0,
    limit: 0,
    query: {
        queryType: TableStore.QueryType.MATCH_ALL_QUERY,
    },
    getTotalCount: false,
    aggs: {
        aggs: [
            {
                name: "min_test",
                type: TableStore.AggregationType.AGG_MIN,
                body: {
                    fieldName: "col_long",
                    missing: 333,
                },
            },
        ],
    },
};
let params = {
    tableName: tableName,
    indexName: indexName,
    searchQuery: searchQuery,
    columnToGet: { // Specify the columns that you want to return. You can set it to RETURN_SPECIFIED to return specified columns, RETURN_ALL to return all columns, RETURN_ALL_FROM_INDEX to return all columns in the search index, or RETURN_NONE to return only the primary key columns. 
        returnType: TableStore.ColumnReturnType.RETURN_ALL_FROM_INDEX
    },
    timeoutMs: 30000,
}
client.search(params, function (err, data) {
    if (err) {
        console.log('search error:', err.toString());
    } else {
        console.log('search success:', data);
    }
});

Valor máximo

Retorna o maior valor de um campo. Equivale à função MAX do SQL.

Parâmetros

Parâmetro	Descrição
name	Nome exclusivo da operação de agregação. Use esse identificador para recuperar os resultados de uma agregação específica.
fieldName	Campo utilizado na operação de agregação. Apenas os tipos LONG, DOUBLE e DATE são aceitos.
missing	Valor padrão assumido pelo campo quando este estiver vazio em uma linha durante a agregação. Sem a definição de missing, a linha é desconsiderada. Ao definir missing, o sistema adota esse valor como o conteúdo do campo na linha.

Exemplo

let searchQuery = {
    offset: 0,
    limit: 0,
    query: {
        queryType: TableStore.QueryType.MATCH_ALL_QUERY,
    },
    getTotalCount: false,
    aggs: {
        aggs: [
            {
                name: "max_test",
                type: TableStore.AggregationType.AGG_MAX,
                body: {
                    fieldName: "col_long",
                    missing: 333,
                },
            },
        ],
    },
};
let params = {
    tableName: tableName,
    indexName: indexName,
    searchQuery: searchQuery,
    columnToGet: { // Specify the columns that you want to return. You can set it to RETURN_SPECIFIED to return specified columns, RETURN_ALL to return all columns, RETURN_ALL_FROM_INDEX to return all columns in the search index, or RETURN_NONE to return only the primary key columns. 
        returnType: TableStore.ColumnReturnType.RETURN_ALL_FROM_INDEX
    },
    timeoutMs: 30000,
}
client.search(params, function (err, data) {
    if (err) {
        console.log('search error:', err.toString());
    } else {
        console.log('search success:', data);
    }
});

Soma

Calcula a soma de todos os valores de um campo numérico. Comportamento similar à função SUM do SQL.

Parâmetros

Parâmetro	Descrição
name	Nome exclusivo da operação de agregação. Use esse identificador para recuperar os resultados de uma agregação específica.
fieldName	Campo utilizado na operação de agregação. Apenas os tipos de dados LONG e DOUBLE são aceitos.
missing	Valor padrão assumido pelo campo quando este estiver vazio em uma linha durante a agregação. Sem a definição de missing, a linha é desconsiderada. Ao definir missing, o sistema adota esse valor como o conteúdo do campo na linha.

Exemplo

let searchQuery = {
    offset: 0,
    limit: 0,
    query: {
        queryType: TableStore.QueryType.MATCH_ALL_QUERY,
    },
    getTotalCount: false,
    aggs: {
        aggs: [
            {
                name: "sum_test",
                type: TableStore.AggregationType.AGG_SUM,
                body: {
                        fieldName: "col_long",
                        missing: 444,
                },
            },
        ],
    },
};
let params = {
    tableName: tableName,
    indexName: indexName,
    searchQuery: searchQuery,
    columnToGet: { // Specify the columns that you want to return. You can set it to RETURN_SPECIFIED to return specified columns, RETURN_ALL to return all columns, RETURN_ALL_FROM_INDEX to return all columns in the search index, or RETURN_NONE to return only the primary key columns. 
        returnType: TableStore.ColumnReturnType.RETURN_ALL_FROM_INDEX
    },
    timeoutMs: 30000,
}
client.search(params, function (err, data) {
    if (err) {
        console.log('search error:', err.toString());
    } else {
        console.log('search success:', data);
    }
});

Valor médio

Obtém a média de todos os valores de um campo numérico. Corresponde à função AVG do SQL.

Parâmetros

Parâmetro	Descrição
name	Nome exclusivo da operação de agregação. Use esse identificador para recuperar os resultados de uma agregação específica.
fieldName	Campo utilizado na operação de agregação. Apenas os tipos LONG, DOUBLE e DATE são aceitos.
missing	Valor padrão assumido pelo campo quando este estiver vazio em uma linha durante a agregação. Sem a definição de missing, a linha é desconsiderada. Ao definir missing, o sistema adota esse valor como o conteúdo do campo na linha.

Exemplo

let searchQuery = {
    offset: 0,
    limit: 0,
    query: {
        queryType: TableStore.QueryType.MATCH_ALL_QUERY,
    },
    getTotalCount: false,
    aggs: {
        aggs: [
            {
                name: "avg_test",
                type: TableStore.AggregationType.AGG_AVG,
                body: {
                        fieldName: "col_long",
                        missing: 111,
                },
            },
        ],
    },
};
let params = {
    tableName: tableName,
    indexName: indexName,
    searchQuery: searchQuery,
    columnToGet: { // Specify the columns that you want to return. You can set it to RETURN_SPECIFIED to return specified columns, RETURN_ALL to return all columns, RETURN_ALL_FROM_INDEX to return all columns in the search index, or RETURN_NONE to return only the primary key columns. 
        returnType: TableStore.ColumnReturnType.RETURN_ALL_FROM_INDEX
    },
    timeoutMs: 30000,
}
client.search(params, function (err, data) {
    if (err) {
        console.log('search error:', err.toString());
    } else {
        console.log('search success:', data);
    }
});

Contagem

Indica a quantidade total de valores de um campo específico ou o número total de linhas em um índice de busca. Assemelha-se à função COUNT do SQL.

Nota

Utilize uma das abordagens a seguir para obter o total de linhas em um índice de busca ou daquelas que satisfazem aos critérios da consulta:

Use o recurso de contagem da agregação e especifique count(*) na requisição.
Use o mecanismo de consulta para contar as linhas correspondentes. Defina setGetTotalCount como true na consulta. Para o total geral do índice de busca, use MatchAllQuery.

Para saber quantas linhas contêm determinada coluna no índice de busca, informe o nome dessa coluna como valor da expressão de contagem. Essa abordagem é ideal para cenários com colunas esparsas.

Parâmetros

Parâmetro	Descrição
name	Nome exclusivo da operação de agregação. Use esse identificador para recuperar os resultados de uma agregação específica.
fieldName	Campo utilizado na operação de agregação. Os tipos aceitos incluem LONG, DOUBLE, BOOLEAN, KEYWORD, GEO_POINT e DATE.

Exemplo

let searchQuery = {
    offset: 0,
    limit: 0,
    query: {
        queryType: TableStore.QueryType.MATCH_ALL_QUERY,
    },
    getTotalCount: false,
    aggs: {
        aggs: [
            {
                name: "count_test",
                type: TableStore.AggregationType.AGG_COUNT,
                body: {
                        fieldName: "col_long",
                },
            },
        ],
    },
};
let params = {
    tableName: tableName,
    indexName: indexName,
    searchQuery: searchQuery,
    columnToGet: { // Specify the columns that you want to return. You can set it to RETURN_SPECIFIED to return specified columns, RETURN_ALL to return all columns, RETURN_ALL_FROM_INDEX to return all columns in the search index, or RETURN_NONE to return only the primary key columns. 
        returnType: TableStore.ColumnReturnType.RETURN_ALL_FROM_INDEX
    },
    timeoutMs: 30000,
}
client.search(params, function (err, data) {
    if (err) {
        console.log('search error:', err.toString());
    } else {
        console.log('search success:', data);
    }
});

Contagem distinta

Fornece a quantidade de valores únicos para um campo. Opera de forma parecida com a função COUNT(DISTINCT) do SQL.

Nota

O resultado da contagem distinta é uma aproximação.

Quando o total de linhas antes da aplicação da contagem distinta for inferior a 10.000, o cálculo fica próximo do valor exato.
Se o volume de linhas atingir ou ultrapassar 100 milhões, a margem de erro será de aproximadamente 2%.

Parâmetros

Parâmetro	Descrição
name	Nome exclusivo da operação de agregação. Use esse identificador para recuperar os resultados de uma agregação específica.
fieldName	Campo utilizado na operação de agregação. Os tipos aceitos incluem LONG, DOUBLE, BOOLEAN, KEYWORD, GEO_POINT e DATE.
missing	Valor padrão assumido pelo campo quando este estiver vazio em uma linha durante a agregação. Sem a definição de missing, a linha é desconsiderada. Ao definir missing, o sistema adota esse valor como o conteúdo do campo na linha.

Exemplo

let searchQuery = {
    offset: 0,
    limit: 0,
    query: {
        queryType: TableStore.QueryType.MATCH_ALL_QUERY,
    },
    getTotalCount: false,
    aggs: {
        aggs: [
            {
                name: "AGG_DISTINCT_COUNT_test",
                type: TableStore.AggregationType.AGG_DISTINCT_COUNT,
                body: {
                        fieldName: "col_long",
                        missing: 666,
                },
            },
        ],
    },
};
let params = {
    tableName: tableName,
    indexName: indexName,
    searchQuery: searchQuery,
    columnToGet: { // Specify the columns that you want to return. You can set it to RETURN_SPECIFIED to return specified columns, RETURN_ALL to return all columns, RETURN_ALL_FROM_INDEX to return all columns in the search index, or RETURN_NONE to return only the primary key columns. 
        returnType: TableStore.ColumnReturnType.RETURN_ALL_FROM_INDEX
    },
    timeoutMs: 30000,
}
client.search(params, function (err, data) {
    if (err) {
        console.log('search error:', err.toString());
    } else {
        console.log('search success:', data);
    }
});

Estatísticas de percentil

Um valor de percentil indica a posição relativa de um dado dentro de um conjunto. Por exemplo, ao coletar estatísticas sobre o tempo de resposta de requisições durante a operação e manutenção (O&M) rotineira do sistema, analise a distribuição desses tempos usando percentis como p25, p50, p90 e p99.

Parâmetros

Parâmetro	Descrição
name	Nome exclusivo da operação de agregação. Use esse identificador para recuperar os resultados de uma agregação específica.
fieldName	Campo utilizado na operação de agregação. Apenas os tipos LONG, DOUBLE e DATE são aceitos.
percentiles	Define os percentis desejados, como p50, p90 e p99. É possível informar um ou mais valores.
missing	Valor padrão assumido pelo campo quando este estiver vazio em uma linha durante a agregação. Sem a definição de missing, a linha é desconsiderada. Ao definir missing, o sistema adota esse valor como o conteúdo do campo na linha.

Exemplo

let searchQuery = {
    offset: 0,
    limit: 0,
    query: {
        queryType: TableStore.QueryType.MATCH_ALL_QUERY,
    },
    getTotalCount: false,
    aggs: {
        aggs: [
            {
                name: "AGG_PERCENTILES_test",
                type: TableStore.AggregationType.AGG_PERCENTILES,
                body: {
                        fieldName: "col_long",
                        percentiles: [20, 50, 90, 100],
                        missing: 888,
                },
            },
        ],
    },
};
let params = {
    tableName: tableName,
    indexName: indexName,
    searchQuery: searchQuery,
    columnToGet: { // Specify the columns that you want to return. You can set it to RETURN_SPECIFIED to return specified columns, RETURN_ALL to return all columns, RETURN_ALL_FROM_INDEX to return all columns in the search index, or RETURN_NONE to return only the primary key columns. 
        returnType: TableStore.ColumnReturnType.RETURN_ALL_FROM_INDEX
    },
    timeoutMs: 30000,
}
client.search(params, function (err, data) {
    if (err) {
        console.log('search error:', err.toString());
    } else {
        console.log('search success:', data);
    }
});

Agrupamento por valor de campo

Agrupa os resultados da consulta com base nos valores dos campos. Valores idênticos ficam no mesmo grupo. O retorno inclui o valor de cada grupo e a respectiva contagem de ocorrências.

Nota

Se um grupo tiver uma quantidade muito grande de valores, o número calculado pode divergir do valor real.

Parâmetros

Parâmetro	Descrição
name	Nome exclusivo da operação de agregação. Use esse identificador para recuperar os resultados de uma agregação específica.
fieldName	Campo utilizado na operação de agregação. Apenas os tipos LONG, DOUBLE, BOOLEAN, KEYWORD e DATE são aceitos.
sort	Regras de ordenação dos grupos. Por padrão, a classificação segue a contagem de itens em ordem decrescente. Caso configure várias regras, o sistema respeitará a sequência definida. Opções aceitas: Ordenar por valor em ordem alfabética. Ordenar por valor em ordem alfabética inversa. Ordenar por contagem de linhas em ordem crescente. Ordenar por contagem de linhas em ordem decrescente. Ordenar pelos valores obtidos nos resultados de subagregação em ordem crescente. Ordenar pelos valores obtidos nos resultados de subagregação em ordem decrescente.
size	Quantidade de grupos a serem retornados. Valor padrão: 10. Limite máximo: 2.000. Se houver mais de 2.000 grupos, apenas os primeiros 2.000 serão exibidos.
subAggs e subGroupBys	Operação de subagregação executada sobre os resultados do agrupamento principal. Cenário Descobrir a quantidade de produtos por categoria, bem como os preços máximo e mínimo em cada uma delas. Abordagem Agrupe os resultados pela categoria do produto para obter as contagens. Em seguida, aplique duas subagregações para extrair os preços máximo e mínimo de cada categoria. Exemplo: Frutas: 5. Preço máximo de USD 2. Preço mínimo de USD 0,5. Artigos de higiene: 10. Preço máximo de USD 13. Preço mínimo de USD 0,1. Dispositivos eletrônicos: 3. Preço máximo de USD 1.160. Preço mínimo de USD 310. Outros produtos: 15. Preço máximo de USD 130. Preço mínimo de USD 11.

Exemplo

let searchQuery = {
    offset: 0,
    limit: 0,
    query: {
        queryType: TableStore.QueryType.MATCH_ALL_QUERY,
    },
    getTotalCount: false,
    groupBys: {
        groupBys: [
            {
                name: "group_by_GROUP_BY_FIELD",
                type: TableStore.GroupByType.GROUP_BY_FIELD,
                body: {
                    fieldName: "city",
                    size: 111,
                    sort: {
                        sorters: [
                            {
                                groupKeySort: {
                                    order: TableStore.SortOrder.SORT_ORDER_ASC,
                                },
                            },
                            {
                                rowCountSort: {
                                    order: TableStore.SortOrder.SORT_ORDER_DESC,
                                },
                            },
                        ],
                    },
                    subGroupBys: { // Nested subGroupBys. 
                        groupBys: [
                            {
                                name: "group_by_GROUP_BY_RANGE",
                                type: TableStore.GroupByType.GROUP_BY_RANGE,
                                body: {
                                    fieldName: "age",
                                    ranges: [
                                        {
                                            from: 4,
                                            to: 5,
                                        },
                                        {
                                            from: 6,
                                            to: 7,
                                        },
                                    ],
                                    subAggs: { // Nested sub-aggregations. 
                                        aggs: [
                                            {
                                                name: "AGG_COUNT_test",
                                                type: TableStore.AggregationType.AGG_COUNT,
                                                body: {
                                                    fieldName: "*",
                                                    missing: 8,
                                                },
                                            },
                                        ],
                                    },
                                },
                            },
                        ],
                    },
                },
            },
        ],
    },
};

let params = {
    tableName: tableName,
    indexName: indexName,
    searchQuery: searchQuery,
    columnToGet: { // Specify the columns that you want to return. You can set it to RETURN_SPECIFIED to return specified columns, RETURN_ALL to return all columns, RETURN_ALL_FROM_INDEX to return all columns in the search index, or RETURN_NONE to return only the primary key columns. 
        returnType: TableStore.ColumnReturnType.RETURN_ALL_FROM_INDEX
    },
    timeoutMs: 30000,
}
client.search(params, function (err, data) {
    if (err) {
        console.log('search error:', err.toString());
    } else {
        console.log('search success:', data);
    }
});

Agrupamento por intervalo

Organiza os resultados da consulta conforme faixas de valores de um campo. Valores dentro de um intervalo específico são agrupados e o sistema retorna a contagem de itens em cada faixa.

Parâmetros

Parâmetro	Descrição
name	Nome exclusivo da operação de agregação. Use esse identificador para recuperar os resultados de uma agregação específica.
fieldName	Campo utilizado na operação de agregação. Apenas os tipos LONG e DOUBLE são aceitos.
ranges[from, to)	Faixas de valores usadas no agrupamento. O intervalo pode variar de Double.MIN_VALUE até Double.MAX_VALUE.
subAggs e subGroupBys	Operação de subagregação executada sobre os resultados do agrupamento principal. Por exemplo, após agrupar resultados por volume de vendas e por província, identifique qual província concentra a maior fatia de vendas em determinada faixa. Para isso, especifique um valor para GroupByField dentro de GroupByRange.

Exemplo

let searchQuery = {
    offset: 0,
    limit: 0,
    query: {
        queryType: TableStore.QueryType.MATCH_ALL_QUERY,
    },
    getTotalCount: false,
    groupBys: {
        groupBys: [
            { 
                name: "group_by_GROUP_BY_RANGE",
                type: TableStore.GroupByType.GROUP_BY_RANGE,
                body: {
                    fieldName: "col_long",
                    ranges: [
                        {
                            from: 1,
                            to: 5,
                        },
                        {
                            from: 3,
                            to: 20,
                        },
                    ],
                },
            },
        ],
    },
};

let params = {
    tableName: tableName,
    indexName: indexName,
    searchQuery: searchQuery,
    columnToGet: { // Specify the columns that you want to return. You can set it to RETURN_SPECIFIED to return specified columns, RETURN_ALL to return all columns, RETURN_ALL_FROM_INDEX to return all columns in the search index, or RETURN_NONE to return only the primary key columns. 
        returnType: TableStore.ColumnReturnType.RETURN_ALL_FROM_INDEX
    },
    timeoutMs: 30000,
}
client.search(params, function (err, data) {
    if (err) {
        console.log('search error:', err.toString());
    } else {
        console.log('search success:', data);
    }
});

Agrupamento por localização geográfica

Classifica os resultados da consulta segundo a distância entre as localizações geográficas e um ponto central. Itens cujas distâncias se enquadram em determinada faixa formam um grupo e a quantidade de valores por intervalo é retornada.

Parâmetros

Parâmetro	Descrição
name	Nome exclusivo da operação de agregação. Use esse identificador para recuperar os resultados de uma agregação específica.
fieldName	Campo utilizado na operação de agregação. Apenas o tipo GEOPOINT é aceito.
origin(lat, lon)	Coordenadas do ponto central. lat representa a latitude e lon representa a longitude desse ponto.
ranges[from, to)	Faixas de distância utilizadas no agrupamento. Unidade: metros. O intervalo pode variar de Double.MIN_VALUE até Double.MAX_VALUE.
subAggs e subGroupBys	Operação de subagregação executada sobre os resultados do agrupamento principal.

Exemplo

let searchQuery = {
    offset: 0,
    limit: 0,
    query: {
        queryType: TableStore.QueryType.MATCH_ALL_QUERY,
    },
    getTotalCount: false,
    groupBys: {
        groupBys: [
            { 
                name: "group_by_GROUP_BY_GEO_DISTANCE",
                type: TableStore.GroupByType.GROUP_BY_GEO_DISTANCE,
                body: {
                    fieldName: "col_geo",
                    origin: {
                        lat: 50,
                        lon: 60,
                    },
                    ranges: [
                        {
                            from: 1,
                            to: 2,
                        },
                        {
                            from: 3,
                        },
                    ],
                },
            },
        ],
    },
};

let params = {
    tableName: tableName,
    indexName: indexName,
    searchQuery: searchQuery,
    columnToGet: { // Specify the columns that you want to return. You can set it to RETURN_SPECIFIED to return specified columns, RETURN_ALL to return all columns, RETURN_ALL_FROM_INDEX to return all columns in the search index, or RETURN_NONE to return only the primary key columns. 
        returnType: TableStore.ColumnReturnType.RETURN_ALL_FROM_INDEX
    },
    timeoutMs: 30000,
}
client.search(params, function (err, data) {
    if (err) {
        console.log('search error:', err.toString());
    } else {
        console.log('search success:', data);
    }
});

Agrupamento por filtro

Filtra os resultados da consulta e os agrupa para mostrar quantos itens correspondem a cada condição. A ordem de retorno segue a sequência de definição dos filtros.

Parâmetros

Parâmetro	Descrição
name	Nome exclusivo da operação de agregação. Use esse identificador para recuperar os resultados de uma agregação específica.
filters	Filtros aplicados à consulta. Os resultados seguem a ordem de definição dos filtros.
subAggs e subGroupBys	Operação de subagregação executada sobre os resultados do agrupamento principal.

Exemplo

let searchQuery = {
    offset: 0,
    limit: 0,
    query: {
        queryType: TableStore.QueryType.MATCH_ALL_QUERY,
    },
    getTotalCount: false,
    groupBys: {
        groupBys: [
            { 
                name: "group_by_GROUP_BY_FILTER",
                type: TableStore.GroupByType.GROUP_BY_FILTER,
                body: {
                    filters: [
                        {
                            queryType: TableStore.QueryType.MATCH_ALL_QUERY,
                        },
                        {
                            queryType: TableStore.QueryType.WILDCARD_QUERY,
                            query: {
                                fieldName: "col_keyword",
                                value: "1*"
                            },
                        },
                    ],
                },
            },
        ],
    },
};

let params = {
    tableName: tableName,
    indexName: indexName,
    searchQuery: searchQuery,
    columnToGet: { // Specify the columns that you want to return. You can set it to RETURN_SPECIFIED to return specified columns, RETURN_ALL to return all columns, RETURN_ALL_FROM_INDEX to return all columns in the search index, or RETURN_NONE to return only the primary key columns. 
        returnType: TableStore.ColumnReturnType.RETURN_ALL_FROM_INDEX
    },
    timeoutMs: 30000,
}
client.search(params, function (err, data) {
    if (err) {
        console.log('search error:', err.toString());
    } else {
        console.log('search success:', data);
    }
});

Consulta por histograma

Segmenta os resultados da consulta em intervalos de dados predefinidos. Valores de campo na mesma faixa pertencem ao mesmo grupo. O resultado exibe o intervalo de valores e a contagem de itens de cada grupo.

Parâmetros

Parâmetro	Descrição
name	Nome exclusivo da operação de agregação. Use esse identificador para recuperar os resultados de uma agregação específica.
fieldName	Campo utilizado na operação de agregação. Apenas os tipos LONG e DOUBLE são aceitos.
interval	Intervalo de dados aplicado para gerar os resultados da agregação.
fieldRange[min,max]	Faixa usada em conjunto com o parâmetro interval para limitar a quantidade de grupos. `O valor resultante da fórmula não pode ultrapassar 2.000.`
minDocCount	Número mínimo de linhas exigido. Grupos com menos linhas que esse limiar não terão seus resultados de agregação retornados.
missing	Valor padrão assumido pelo campo quando este estiver vazio em uma linha durante a agregação. Sem a definição de missing, a linha é desconsiderada. Ao definir missing, o sistema adota esse valor como o conteúdo do campo na linha.

Exemplo

let searchQuery = {
    offset: 0,
    limit: 0,
    query: {
        queryType: TableStore.QueryType.MATCH_ALL_QUERY,
    },
    getTotalCount: false,
    groupBys: {
        groupBys: [
             { 
                name: "group_by_GROUP_BY_HISTOGRAM",
                type: TableStore.GroupByType.GROUP_BY_HISTOGRAM,
                body: {
                    fieldName: "col_long",
                    interval: Long.fromNumber(3),
                    missing: Long.fromNumber(123),
                    minDocCount: 5,
                    fieldRange: {
                        min: Long.fromNumber(1),
                        max: Long.fromNumber(999),
                    },
                    sort: {
                        sorters: [
                            {
                                groupKeySort: {
                                    order: TableStore.SortOrder.SORT_ORDER_ASC,
                                },
                            },
                            {
                                rowCountSort: {
                                    order: TableStore.SortOrder.SORT_ORDER_ASC,
                                },
                            },
                        ],
                    },
                },
            },
        ],
    },
};

let params = {
    tableName: tableName,
    indexName: indexName,
    searchQuery: searchQuery,
    columnToGet: { // Specify the columns that you want to return. You can set it to RETURN_SPECIFIED to return specified columns, RETURN_ALL to return all columns, RETURN_ALL_FROM_INDEX to return all columns in the search index, or RETURN_NONE to return only the primary key columns. 
        returnType: TableStore.ColumnReturnType.RETURN_ALL_FROM_INDEX
    },
    timeoutMs: 30000,
}
client.search(params, function (err, data) {
    if (err) {
        console.log('search error:', err.toString());
    } else {
        console.log('search success:', data);
    }
});

Consulta das linhas obtidas dos resultados de agregação em cada grupo

Após agrupar os resultados, consulte as linhas pertencentes a cada grupo. Esse método equivale à função ANY_VALUE(campo) do MySQL.

Nota

Ao consultar as linhas provenientes dos resultados de agregação por grupo, se o índice de busca contiver campos do tipo Nested, Geopoint ou Array, o retorno trará apenas as informações da chave primária. Para acessar o campo desejado, consulte a tabela de dados.

Parâmetros

Parâmetro	Descrição
name	Nome exclusivo da operação de agregação. Use esse identificador para recuperar os resultados de uma agregação específica.
limit	Quantidade máxima de linhas retornadas por grupo. O padrão é retornar apenas uma linha de dados.
sort	Critério de ordenação aplicado aos dados dentro dos grupos.
columnsToGet	Campos a serem incluídos no retorno. Apenas campos presentes em índices de busca são aceitos. Tipos ARRAY, DATE, GEOPOINT e NESTED não são aceitos. Este parâmetro corresponde ao columnsToGet do SearchRequest. Basta defini-lo diretamente no SearchRequest.

Exemplo

Imagine um formulário de inscrição para atividades escolares com campos para nome do aluno, turma, professor titular e representante de classe. Agrupe os alunos por turma para visualizar estatísticas de inscrição e propriedades de cada turma. A instrução SQL equivalente seria select className, ANY_VALUE(teacher), ANY_VALUE(monitor), COUNT(*) as number from table GROUP BY className.

let searchQuery = {
    offset: 0,
    limit: 0,
    query: {
        queryType: TableStore.QueryType.MATCH_ALL_QUERY,
    },
    getTotalCount: true,
    groupBys: {
        groupBys: [
            {
                name: "group_by_name_xxx",
                type: TableStore.GroupByType.GROUP_BY_FIELD,
                body: {
                    fieldName: "className",
                    size: 200,
                    subAggs: {
                        aggs: [
                            {
                                name: "top_row_name_xxx",
                                type: TableStore.AggregationType.AGG_TOP_ROWS,
                                body: {
                                    limit: 1,
                                    sort: {
                                        sorters: [
                                            {
                                                fieldSort: {
                                                    fieldName: "teacher",
                                                    order: TableStore.SortOrder.SORT_ORDER_DESC,
                                                },
                                            },
                                        ],
                                    },
                                },
                            },
                        ],
                    },
                },
            },
        ],
    },
};

let params = {
    tableName: tableName,
    indexName: indexName,
    searchQuery: searchQuery,
    columnToGet: { // Specify the columns that you want to return. You can set it to RETURN_SPECIFIED to return specified columns, RETURN_ALL to return all columns, RETURN_ALL_FROM_INDEX to return all columns in the search index, or RETURN_NONE to return only the primary key columns. 
        returnType: TableStore.ColumnReturnType.RETURN_ALL_FROM_INDEX
    },
    timeoutMs: 30000,
}
client.search(params, function (err, data) {
    if (err) {
        console.log('search error:', err.toString());
    } else {
        console.log('search success:', data);
    }
});