Agregación - Tablestore - Centro de documentación de Alibaba Cloud

Las operaciones de agregación permiten obtener los valores mínimo, máximo, la suma y el promedio, así como el conteo total y el conteo de valores distintos de las filas. También es posible agrupar los resultados por valor de campo, rango, ubicación geográfica o filtro, además de ejecutar consultas anidadas. Para consultas complejas, se admiten varias operaciones de agregación simultáneas.

Procedimiento

A continuación se muestra el procedimiento completo de agregación.

fig_agg_pro

El servidor consulta los datos que cumplen con las condiciones de búsqueda y aplica la agregación correspondiente según la solicitud. Por lo tanto, una solicitud con agregación requiere un procesamiento más complejo que una sin ella.

Contexto

En la siguiente tabla se describen los métodos de agregación.

Método	Descripción
Valor mínimo	Devuelve el valor mínimo de un campo. Su funcionamiento es similar al de la función MIN de SQL.
Valor máximo	Devuelve el valor máximo de un campo. Funciona de manera equivalente a la función MAX de SQL.
Suma	Calcula la suma de todos los valores de un campo numérico. Este método equivale a la función SUM de SQL.
Valor promedio	Obtiene el promedio de todos los valores de un campo numérico. Se comporta de forma similar a la función AVG de SQL.
Conteo	Devuelve la cantidad total de valores de un campo específico o el número total de filas en un índice de búsqueda. Su uso es comparable al de la función COUNT de SQL.
Conteo de valores distintos	Indica cuántos valores distintos existen para un campo determinado. Corresponde a la función COUNT(DISTINCT) de SQL.
Estadísticas de percentiles	Un percentil indica la posición relativa de un valor dentro de un conjunto de datos. Por ejemplo, al recopilar estadísticas sobre el tiempo de respuesta de cada solicitud durante las tareas habituales de operación y mantenimiento del sistema, es necesario analizar la distribución mediante percentiles como p25, p50, p90 y p99.
Agrupación por valor de campo	Agrupa los resultados de la consulta según los valores de un campo. Los valores idénticos se colocan en el mismo grupo. El resultado incluye el valor de cada grupo y la cantidad de veces que aparece. Nota Si un grupo contiene una cantidad muy grande de valores, el cálculo puede diferir del número real.
Agrupación por rango	Clasifica los resultados de la consulta en grupos definidos por rangos de valores de un campo. Los valores que caen dentro de un mismo intervalo se agrupan y se devuelve la cantidad de elementos por rango.
Agrupación por ubicación geográfica	Organiza los resultados de la consulta según la distancia entre las ubicaciones geográficas y un punto central. Las distancias que pertenecen a un mismo intervalo forman un grupo, y se devuelve la cantidad de valores por rango.
Agrupación por filtro	Filtra los resultados de la consulta y los agrupa para obtener la cantidad de coincidencias de cada filtro. Los resultados se devuelven en el mismo orden en que se especificaron los filtros.
Consulta por histograma	Distribuye los resultados de la consulta en intervalos de datos predefinidos. Los valores de campo que caen en el mismo intervalo se agrupan. Se devuelve el rango de valores de cada grupo junto con su cantidad de elementos.
Consulta de filas obtenidas de una operación de agregación en cada grupo	Después de agrupar los resultados de la consulta, es posible consultar las filas de cada grupo. Esta función opera de manera similar a ANY_VALUE(field) en MySQL.

Requisitos previos

Se inicializó una instancia de OTSClient. Para obtener más información, consulte Initialize an OTSClient instance.
Se creó una tabla de datos y se escribieron datos en ella. Para obtener más información, consulte Create data tables y Write data.
Se creó un índice de búsqueda para la tabla de datos. Para obtener más información, consulte Create a search index.

Valor mínimo

Devuelve el valor mínimo de un campo. Su funcionamiento es similar al de la función MIN de SQL.

Parámetros

Parámetro	Descripción
name	Nombre único de la operación de agregación. Con este nombre se consultan los resultados de una operación específica.
fieldName	Nombre del campo sobre el cual se ejecuta la operación de agregación. Solo son compatibles los tipos LONG, DOUBLE y DATE.
missing	Valor predeterminado que se asigna al campo cuando está vacío en una fila durante la operación de agregación. Si no se especifica un valor para missing, la fila se ignora. Si se especifica un valor para missing, dicho valor se utiliza como el valor del campo en esa fila.

Ejemplo

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

Devuelve el valor máximo de un campo. Funciona de manera equivalente a la función MAX de SQL.

Parámetros

Parámetro	Descripción
name	Nombre único de la operación de agregación. Con este nombre se consultan los resultados de una operación específica.
fieldName	Nombre del campo sobre el cual se ejecuta la operación de agregación. Solo son compatibles los tipos LONG, DOUBLE y DATE.
missing	Valor predeterminado que se asigna al campo cuando está vacío en una fila durante la operación de agregación. Si no se especifica un valor para missing, la fila se ignora. Si se especifica un valor para missing, dicho valor se utiliza como el valor del campo en esa fila.

Ejemplo

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);
    }
});

Suma

Calcula la suma de todos los valores de un campo numérico. Este método equivale a la función SUM de SQL.

Parámetros

Parámetro	Descripción
name	Nombre único de la operación de agregación. Con este nombre se consultan los resultados de una operación específica.
fieldName	Nombre del campo sobre el cual se ejecuta la operación de agregación. Solo son compatibles los tipos de datos LONG y DOUBLE.
missing	Valor predeterminado que se asigna al campo cuando está vacío en una fila durante la operación de agregación. Si no se especifica un valor para missing, la fila se ignora. Si se especifica un valor para missing, dicho valor se utiliza como el valor del campo en esa fila.

Ejemplo

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 promedio

Obtiene el promedio de todos los valores de un campo numérico. Se comporta de forma similar a la función AVG de SQL.

Parámetros

Parámetro	Descripción
name	Nombre único de la operación de agregación. Con este nombre se consultan los resultados de una operación específica.
fieldName	Nombre del campo sobre el cual se ejecuta la operación de agregación. Solo son compatibles los tipos LONG, DOUBLE y DATE.
missing	Valor predeterminado que se asigna al campo cuando está vacío en una fila durante la operación de agregación. Si no se especifica un valor para missing, la fila se ignora. Si se especifica un valor para missing, dicho valor se utiliza como el valor del campo en esa fila.

Ejemplo

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);
    }
});

Conteo

Devuelve la cantidad total de valores de un campo específico o el número total de filas en un índice de búsqueda. Su uso es comparable al de la función COUNT de SQL.

Nota

Para consultar el número total de filas de un índice de búsqueda o la cantidad de filas que cumplen con las condiciones de consulta, utilice uno de los siguientes métodos:

Use la función de conteo de la agregación y especifique count(*) en la solicitud.
Use la función de consulta para obtener la cantidad de filas que cumplen con las condiciones. Establezca setGetTotalCount en true dentro de la consulta. Para obtener el total de filas del índice de búsqueda, utilice MatchAllQuery.

También es posible usar el nombre de una columna como valor de la expresión de conteo para saber cuántas filas contienen dicha columna en el índice de búsqueda. Este enfoque resulta útil en escenarios con columnas dispersas.

Parámetros

Parámetro	Descripción
name	Nombre único de la operación de agregación. Con este nombre se consultan los resultados de una operación específica.
fieldName	Nombre del campo sobre el cual se ejecuta la operación de agregación. Solo son compatibles los tipos LONG, DOUBLE, BOOLEAN, KEYWORD, GEO_POINT y DATE.

Ejemplo

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);
    }
});

Conteo de valores distintos

Indica cuántos valores distintos existen para un campo determinado. Corresponde a la función COUNT(DISTINCT) de SQL.

Nota

La cantidad de valores distintos que se obtiene es aproximada.

Si el número total de filas antes de aplicar esta función es menor que 10 000, el resultado calculado se acerca al valor exacto.
Si el número total de filas antes de aplicar esta función es igual o mayor que 100 millones, el margen de error es de aproximadamente 2 %.

Parámetros

Parámetro	Descripción
name	Nombre único de la operación de agregación. Con este nombre se consultan los resultados de una operación específica.
fieldName	Nombre del campo sobre el cual se ejecuta la operación de agregación. Solo son compatibles los tipos LONG, DOUBLE, BOOLEAN, KEYWORD, GEO_POINT y DATE.
missing	Valor predeterminado que se asigna al campo cuando está vacío en una fila durante la operación de agregación. Si no se especifica un valor para missing, la fila se ignora. Si se especifica un valor para missing, dicho valor se utiliza como el valor del campo en esa fila.

Ejemplo

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);
    }
});

Estadísticas de percentiles

Un percentil indica la posición relativa de un valor dentro de un conjunto de datos. Por ejemplo, al recopilar estadísticas sobre el tiempo de respuesta de cada solicitud durante las tareas habituales de operación y mantenimiento del sistema, es necesario analizar la distribución mediante percentiles como p25, p50, p90 y p99.

Nota

Para mejorar la precisión de los resultados, se recomienda especificar percentiles extremos como p1 y p99. Al utilizar estos valores extremos en lugar de otros como p50, los resultados devueltos son más precisos.

Parámetros

Parámetro	Descripción
name	Nombre único de la operación de agregación. Con este nombre se consultan los resultados de una operación específica.
fieldName	Nombre del campo sobre el cual se ejecuta la operación de agregación. Solo son compatibles los tipos LONG, DOUBLE y DATE.
percentiles	Los percentiles que se desean calcular, como p50, p90 y p99. Es posible especificar uno o varios percentiles.
missing	Valor predeterminado que se asigna al campo cuando está vacío en una fila durante la operación de agregación. Si no se especifica un valor para missing, la fila se ignora. Si se especifica un valor para missing, dicho valor se utiliza como el valor del campo en esa fila.

Ejemplo

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);
    }
});

Agrupación por valor de campo

Método de agregación que agrupa los resultados de una consulta según los valores de un campo. Los valores idénticos se agrupan en conjunto. El sistema devuelve el valor de cada grupo y la cantidad de veces que aparece.

Nota

Si un grupo contiene demasiados valores, el número calculado podría diferir del real.

Parámetros

Parámetro	Descripción
name	Nombre único de la operación de agregación. Con este nombre puede consultar los resultados de una operación específica.
fieldName	Nombre del campo sobre el cual se ejecuta la agregación. Solo son compatibles los tipos LONG, DOUBLE, BOOLEAN, KEYWORD y DATE.
sort	Reglas para ordenar los grupos. De forma predeterminada, los grupos se ordenan por la cantidad de elementos en orden descendente. Si configura varias reglas, los grupos se ordenan según el orden en el que definió dichas reglas. Reglas de ordenamiento compatibles: Ordenar por valor en orden alfabético. Ordenar por valor en orden alfabético inverso. Ordenar por cantidad de filas en orden ascendente. Ordenar por cantidad de filas en orden descendente. Ordenar por los valores obtenidos de los resultados de subagregación en orden ascendente. Ordenar por los valores obtenidos de los resultados de subagregación en orden descendente.
size	Cantidad de grupos que desea devolver. Valor predeterminado: 10. Valor máximo: 2000. Si hay más de 2000 grupos, solo se devuelven los primeros 2000.
subAggs and subGroupBys	Operación de subagregación. Esta operación se ejecuta a partir de los resultados del agrupamiento. Escenario Consultar la cantidad de productos por categoría, junto con el precio máximo y mínimo de cada una. Método Agrupe los resultados de la consulta por categoría de producto para obtener la cantidad de artículos en cada una. Después, ejecute dos operaciones de subagregación para calcular el precio máximo y mínimo por categoría. Ejemplo: Frutas: 5. El precio máximo es USD 2 y el mínimo es USD 0.5. Artículos de tocador: 10. El precio máximo es USD 13 y el mínimo es USD 0.1. Dispositivos electrónicos: 3. El precio máximo es USD 1,160 y el mínimo es USD 310. Otros productos: 15. El precio máximo es USD 130 y el mínimo es USD 11.

Ejemplo

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);
    }
});

Agrupar por rango

Método de agregación que agrupa los resultados de una consulta según los rangos de valores de un campo. Los valores que caen dentro de un mismo rango forman un grupo. El sistema devuelve la cantidad de valores en cada rango.

Parámetros

Parámetro	Descripción
name	Nombre único de la operación de agregación. Con este nombre puede consultar los resultados de una operación específica.
fieldName	Nombre del campo sobre el cual se ejecuta la agregación. Solo son compatibles los tipos LONG y DOUBLE.
ranges[from, to)	Rangos de valores utilizados para el agrupamiento. El rango puede comenzar en Double.MIN_VALUE y terminar en Double.MAX_VALUE.
subAggs and subGroupBys	Operación de subagregación. Esta operación se ejecuta a partir de los resultados del agrupamiento. Por ejemplo, si agrupa los resultados por volumen de ventas y por provincia, puede identificar qué provincia concentra la mayor proporción de ventas dentro de un rango determinado. Para esta consulta, debe especificar un valor para GroupByField dentro de GroupByRange.

Ejemplo

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);
    }
});

Agrupar por ubicación geográfica

Método de agregación que agrupa los resultados de una consulta según la distancia entre las ubicaciones geográficas y un punto central. Los resultados cuya distancia cae dentro de un mismo rango forman un grupo. El sistema devuelve la cantidad de valores en cada rango.

Parámetros

Parámetro	Descripción
name	Nombre único de la operación de agregación. Con este nombre puede consultar los resultados de una operación específica.
fieldName	Nombre del campo utilizado en la operación de agregación. Solo es compatible el tipo GEOPOINT.
origin(lat, lon)	Longitud y latitud del punto central. lat indica la latitud del punto central. lon indica la longitud del punto central.
ranges[from, to)	Rangos de distancia utilizados para el agrupamiento. Unidad: metros. El rango puede comenzar en Double.MIN_VALUE y terminar en Double.MAX_VALUE.
subAggs and subGroupBys	Operación de subagregación. Esta operación se ejecuta a partir de los resultados del agrupamiento.

Ejemplo

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);
    }
});

Agrupar por filtro

Método de agregación que filtra los resultados de una consulta y los agrupa para obtener la cantidad de coincidencias de cada filtro. Los resultados se devuelven en el mismo orden en el que se definieron los filtros.

Parámetros

Parámetro	Descripción
name	Nombre único de la operación de agregación. Con este nombre puede consultar los resultados de una operación específica.
filters	Filtros aplicables a la consulta. Los resultados se devuelven en el mismo orden en el que se definieron los filtros.
subAggs and subGroupBys	Operación de subagregación. Esta operación se ejecuta a partir de los resultados del agrupamiento.

Ejemplo

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

Método de agregación que agrupa los resultados de una consulta según intervalos de datos específicos. Los valores de un campo que caen en el mismo intervalo forman un grupo. El sistema devuelve el rango de valores de cada grupo y la cantidad de elementos que contiene.

Parámetros

Parámetro	Descripción
name	Nombre único de la operación de agregación. Con este nombre puede consultar los resultados de una operación específica.
fieldName	Nombre del campo sobre el cual se ejecuta la agregación. Solo son compatibles los tipos LONG y DOUBLE.
interval	Intervalo de datos utilizado para generar los resultados de la agregación.
fieldRange[min,max]	Rango que se utiliza junto con el parámetro interval para limitar la cantidad de grupos. `El valor calculado con la fórmula no puede superar los 2000.`
minDocCount	Cantidad mínima de filas. Si un grupo tiene menos filas que este mínimo, no se devuelven sus resultados de agregación.
missing	Valor predeterminado que se asigna al campo cuando está vacío en una fila, para poder ejecutar la agregación. Si no especifica un valor para missing, la fila se ignora. Si especifica un valor para missing, dicho valor se toma como el valor del campo en esa fila.

Ejemplo

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);
    }
});

Consultar las filas obtenidas de los resultados de una agregación en cada grupo

Después de agrupar los resultados de una consulta, puede consultar las filas de cada grupo. Este método funciona de manera similar a la función ANY_VALUE(field) de MySQL.

Nota

Cuando consulta las filas obtenidas de los resultados de una agregación en cada grupo, los resultados devueltos solo contienen información de la clave primaria si el índice de búsqueda incluye campos de tipo Nested, Geopoint o Array. Para recuperar el campo necesario, debe consultar directamente la tabla de datos.

Parámetros

Parámetro	Descripción
name	Nombre único de la operación de agregación. Con este nombre puede consultar los resultados de una operación específica.
limit	Cantidad máxima de filas que se pueden devolver por grupo. De forma predeterminada, solo se devuelve una fila de datos.
sort	Método utilizado para ordenar los datos dentro de los grupos.
columnsToGet	Campos que desea devolver. Solo son compatibles los campos presentes en los índices de búsqueda. No son compatibles los campos ARRAY, DATE, GEOPOINT ni NESTED. El valor de este parámetro coincide con el de columnsToGet en SearchRequest. Basta con especificar columnsToGet en SearchRequest.

Ejemplo

Un formulario de inscripción a actividades escolares contiene campos donde se captura información como el nombre del alumno, la clase, el tutor y el representante del grupo. Puede agrupar a los alumnos por clase para revisar las estadísticas de inscripción y los datos de cada grupo. La instrucción SQL equivalente es 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);
    }
});