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

Este tema explica cómo ejecutar operaciones de agregación para el análisis de datos. Estas operaciones calculan el valor mínimo, el valor máximo, la suma, el promedio, el conteo, el conteo de valores distintos y los percentiles. Los resultados se agrupan por valor de campo, rango, ubicación, filtros, histogramas o fechas. Además, es posible ejecutar consultas anidadas para analizar las filas de cada grupo. También se combinan varias operaciones de agregación para construir consultas más complejas.

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 ejecuta la agregación correspondiente según la solicitud. Por lo tanto, procesar una solicitud con agregación resulta más complejo que procesar una sin ella.

Funciones

La agregación admite varias funciones similares a las de SQL. Por ejemplo, la función MIN() obtiene el valor mínimo, mientras que MAX() devuelve el valor máximo. Con SUM() se calcula la suma y AVG() obtiene el promedio. La función COUNT() cuenta el número de filas y COUNT(DISTINCT) determina cuántas filas son distintas. Para consultar las filas obtenidas de una operación de agregación en cada grupo, utilice ANY_VALUE(). Finalmente, GROUP BY agrupa los resultados de la consulta. También es posible obtener estadísticas de percentiles, agrupar resultados por valor de campo, rango, ubicación geográfica, filtro, histograma o histograma de fechas, agrupar por varios campos y ejecutar consultas anidadas. En la siguiente tabla se describen estas funciones.

Función	Descripción
Valor mínimo	Método de agregación que devuelve el valor mínimo de un campo. Su funcionamiento es similar al de la función MIN de SQL.
Valor máximo	Método de agregación que devuelve el valor máximo de un campo. Su funcionamiento es similar al de la función MAX de SQL.
Suma	Método de agregación que devuelve la suma de todos los valores de un campo numérico. Su funcionamiento es similar al de la función SUM de SQL.
Valor promedio	Método de agregación que devuelve el promedio de todos los valores de un campo numérico. Su funcionamiento es similar al de la función AVG de SQL.
Conteo	Método de agregación que devuelve el número total de valores de un campo o el número total de filas de un índice de búsqueda. Su funcionamiento es similar al de la función COUNT de SQL.
Conteo de valores distintos	Método de agregación que devuelve la cantidad de valores distintos de un campo. Su funcionamiento es similar al de 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 el mantenimiento habitual del sistema, es necesario analizar la distribución de esos tiempos mediante percentiles como p25, p50, p90 y p99.
Agrupación por valor de campo	Método de agregación que agrupa los resultados de la consulta según los valores de un campo. Los valores idénticos se colocan en el mismo grupo. Se devuelve el valor de cada grupo junto con la cantidad de veces que aparece.
Anidamiento en GroupBy	GroupBy admite anidamiento. Esto permite ejecutar subagregaciones mediante GroupBy.
Agrupación por varios campos	Método de agregación que agrupa los resultados de la consulta según varios campos. Es posible utilizar tokens para paginar los resultados.
Agrupación por rango	Método de agregación que agrupa los resultados de la consulta según los rangos de valores de un campo. Los valores que caen dentro de un mismo rango se colocan en el mismo grupo. Se devuelve la cantidad de valores de cada rango.
Agrupación por ubicación geográfica	Método de agregación que agrupa los resultados de la consulta según la distancia entre las ubicaciones geográficas y un punto central. Los resultados cuya distancia cae dentro de un mismo rango se colocan en el mismo grupo. Se devuelve la cantidad de valores de cada rango.
Agrupación por filtro	Método de agregación que 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 el que se especificaron los filtros.
Consulta por histograma	Método de agregación que agrupa los resultados de la consulta según intervalos de datos específicos. Los valores de campo que caen en el mismo intervalo se colocan en el mismo grupo. Se devuelve el rango de valores y la cantidad de elementos de cada grupo.
Consulta por histograma de fechas	Método de agregación que agrupa los resultados de la consulta según intervalos de fechas específicos. Los valores de campo que caen en el mismo intervalo se colocan en el mismo grupo. Se devuelve el rango de valores y la cantidad de elementos de cada grupo.
Consulta de las 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. Este método funciona de manera similar a la función ANY_VALUE(field) de MySQL.
Agregaciones múltiples	Es posible ejecutar varias operaciones de agregación. Nota Si ejecuta varias operaciones de agregación complejas al mismo tiempo, el procesamiento puede tardar mucho tiempo.

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 search indexes.

Valor mínimo

Método de agregación que 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
AggName	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 con el que se ejecuta la operación de agregación. Solo son compatibles los tipos LONG, DOUBLE y DATE.
Missing	Valor predeterminado del campo con el que se ejecuta la operación de agregación en una fila cuando el valor del campo está vacío. Si no especifica un valor para Missing, la fila se ignora. Si especifica un valor para Missing, dicho valor se utiliza como el valor del campo en esa fila.

Ejemplo

/// <summary>
/// Minimum value. 
/// </summary>
/// <param name="otsClient"></param>
public static void MinAggregation(OTSClient otsClient)
{
    MinAggregation minAggregation = new MinAggregation();
    minAggregation.AggName = "Min_Agg";
    minAggregation.FieldName = "pk1";

    RangeQuery rangeQuery = new RangeQuery();
    rangeQuery.FieldName = "pk1";
    rangeQuery.From = new ColumnValue(0);
    rangeQuery.To = new ColumnValue(100);

    SearchQuery seachQuery = new SearchQuery
    {
        Limit = 0,
        Query = rangeQuery,
        AggregationList = new List<IAggregation>
        {
            minAggregation
        }
    };

    SearchRequest searchRequest = new SearchRequest(TableName, IndexName, seachQuery);

    SearchResponse searchResponse = otsClient.Search(searchRequest);

    Console.WriteLine(JsonConvert.SerializeObject(searchResponse.AggregationResults.GetAsMinAggregationResult("Min_Agg")));
}

Valor máximo

Método de agregación que devuelve el valor máximo de un campo. Su funcionamiento es similar al de la función MAX de SQL.

Parámetros

Parámetro	Descripción
AggName	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 con el que se ejecuta la operación de agregación. Solo son compatibles los tipos LONG, DOUBLE y DATE.
Missing	Valor predeterminado del campo con el que se ejecuta la operación de agregación en una fila cuando el valor del campo está vacío. Si no especifica un valor para Missing, la fila se ignora. Si especifica un valor para Missing, dicho valor se utiliza como el valor del campo en esa fila.

Ejemplo

/// <summary>
/// Maximum value. 
/// </summary>
/// <param name="otsClient"></param>
public static void MaxAggregation(OTSClient otsClient)
{
    MaxAggregation maxAggregation = new MaxAggregation();
    maxAggregation.AggName = "Max_Agg";
    maxAggregation.FieldName = "pk1";

    RangeQuery rangeQuery = new RangeQuery();
    rangeQuery.FieldName = "pk1";
    rangeQuery.From = new ColumnValue(0);
    rangeQuery.To = new ColumnValue(100);

    SearchQuery seachQuery = new SearchQuery
    {
        Limit = 0,
        Query = rangeQuery,
        AggregationList = new List<IAggregation>
        {
            maxAggregation
        }
    };

    SearchRequest searchRequest = new SearchRequest(TableName, IndexName, seachQuery);

    SearchResponse searchResponse = otsClient.Search(searchRequest);

    Console.WriteLine(JsonConvert.SerializeObject(searchResponse.AggregationResults.GetAsMaxAggregationResult("Max_Agg")));
}

Suma

Método de agregación que devuelve la suma de todos los valores de un campo numérico. Su funcionamiento es similar al de la función SUM de SQL.

Parámetros

Parámetro	Descripción
AggName	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 con el que se ejecuta la operación de agregación. Solo son compatibles los tipos LONG y DOUBLE.
Missing	Valor predeterminado del campo con el que se ejecuta la operación de agregación en una fila cuando el valor del campo está vacío. Si no especifica un valor para Missing, la fila se ignora. Si especifica un valor para Missing, dicho valor se utiliza como el valor del campo en esa fila.

Ejemplo

/// <summary>
/// Sum. 
/// </summary>
/// <param name="otsClient"></param>
public static void SumAggregation(OTSClient otsClient)
{
    SumAggregation sumAggregation = new SumAggregation();
    sumAggregation.AggName = "Sum_Agg";
    sumAggregation.FieldName = "pk1";

    RangeQuery rangeQuery = new RangeQuery();
    rangeQuery.FieldName = "pk1";
    rangeQuery.From = new ColumnValue(0);
    rangeQuery.To = new ColumnValue(100);

    SearchQuery seachQuery = new SearchQuery
    {
        Limit = 0,
        Query = rangeQuery,
        AggregationList = new List<IAggregation>
        {
            sumAggregation
        }
    };

    SearchRequest searchRequest = new SearchRequest(TableName, IndexName, seachQuery);

    SearchResponse searchResponse = otsClient.Search(searchRequest);

    Console.WriteLine(JsonConvert.SerializeObject(searchResponse.AggregationResults.GetAsSumAggregationResult("Sum_Agg")));
}

Valor promedio

Método de agregación que devuelve el promedio de todos los valores de un campo numérico. Su funcionamiento es similar al de la función AVG de SQL.

Parámetros

Parámetro	Descripción
AggName	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 con el que se ejecuta la operación de agregación. Solo son compatibles los tipos LONG, DOUBLE y DATE.
Missing	Valor predeterminado del campo con el que se ejecuta la operación de agregación en una fila cuando el valor del campo está vacío. Si no especifica un valor para Missing, la fila se ignora. Si especifica un valor para Missing, dicho valor se utiliza como el valor del campo en esa fila.

Ejemplo

/// <summary>
/// Average value. 
/// </summary>
/// <param name="otsClient"></param>
public static void AvgAggregation(OTSClient otsClient)
{
    AvgAggregation avgAggregation = new AvgAggregation();
    avgAggregation.AggName = "Avg_Agg";
    avgAggregation.FieldName = "pk1";

    RangeQuery rangeQuery = new RangeQuery();
    rangeQuery.FieldName = "pk1";
    rangeQuery.From = new ColumnValue(0);
    rangeQuery.To = new ColumnValue(100);

    SearchQuery seachQuery = new SearchQuery
    {
        Limit = 0,
        Query = rangeQuery,
        AggregationList = new List<IAggregation>
        {
            avgAggregation
        }
    };

    SearchRequest searchRequest = new SearchRequest(TableName, IndexName, seachQuery);

    SearchResponse searchResponse = otsClient.Search(searchRequest);

    Console.WriteLine(JsonConvert.SerializeObject(searchResponse.AggregationResults.GetAsAvgAggregationResult("Avg_Agg")));
}

Conteo

Método de agregación que devuelve el número total de valores de un campo específico o el número total de filas de un índice de búsqueda. Su funcionamiento es similar al de la función COUNT de SQL.

Nota

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

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

También es posible usar el nombre de una columna como valor de la expresión count para consultar cuántas filas contienen dicha columna en un índice de búsqueda. Este método es adecuado para escenarios con columnas dispersas.

Parámetros

Parámetro	Descripción
AggName	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 con el que se ejecuta la operación de agregación. Solo son compatibles los tipos LONG, DOUBLE, BOOLEAN, KEYWORD, GEO_POINT y DATE.

Ejemplo

/// <summary>
/// Count. 
/// </summary>
/// <param name="otsClient"></param>
public static void CountAggregation(OTSClient otsClient)
{
    CountAggregation countAggregation = new CountAggregation();
    countAggregation.AggName = "Count_Agg";
    countAggregation.FieldName = "pk1";

    RangeQuery rangeQuery = new RangeQuery();
    rangeQuery.FieldName = "pk1";
    rangeQuery.From = new ColumnValue(0);
    rangeQuery.To = new ColumnValue(100);

    SearchQuery seachQuery = new SearchQuery
    {
        Limit = 0,
        Query = rangeQuery,
        AggregationList = new List<IAggregation>
        {
            countAggregation
        }
    };

    SearchRequest searchRequest = new SearchRequest(TableName, IndexName, seachQuery);

    SearchResponse searchResponse = otsClient.Search(searchRequest);

    Console.WriteLine(JsonConvert.SerializeObject(searchResponse.AggregationResults.GetAsCountAggregationResult("Count_Agg")));
}

Conteo de valores distintos

Método de agregación que devuelve la cantidad de valores distintos de un campo. Su funcionamiento es similar al de la función COUNT(DISTINCT) de SQL.

Nota

La cantidad de valores distintos es un número aproximado.

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

Parámetros

Parámetro	Descripción
AggName	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 con el que se ejecuta la operación de agregación. Solo son compatibles los tipos LONG, DOUBLE, BOOLEAN, KEYWORD, GEO_POINT y DATE.
Missing	Valor predeterminado del campo con el que se ejecuta la operación de agregación en una fila cuando el valor del campo está vacío. Si no especifica un valor para Missing, la fila se ignora. Si especifica un valor para Missing, dicho valor se utiliza como el valor del campo en esa fila.

Ejemplo

/// <summary>
/// Distinct count. 
/// </summary>
/// <param name="otsClient"></param>
public static void DistinctCountAggregation(OTSClient otsClient)
{
    DistinctCountAggregation distinctCountAggregation = new DistinctCountAggregation();
    distinctCountAggregation.AggName = "DistinctCount_Agg";
    distinctCountAggregation.FieldName = "pk1";

    TermsQuery termsQuery = new TermsQuery();
    termsQuery.FieldName = "pk0";
    termsQuery.Terms = new List<ColumnValue>
    {
        new ColumnValue("Sample"),
        new ColumnValue("SearchIndex")
    };

    SearchQuery seachQuery = new SearchQuery
    {
        Limit = 0,
        Query = termsQuery,
        AggregationList = new List<IAggregation>
        {
            distinctCountAggregation
        }
    };

    SearchRequest searchRequest = new SearchRequest(TableName, IndexName, seachQuery);

    SearchResponse searchResponse = otsClient.Search(searchRequest);

    Console.WriteLine(JsonConvert.SerializeObject(searchResponse.AggregationResults.GetAsDistinctCountAggregationResult("DistinctCount_Agg")));
}

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 el mantenimiento habitual del sistema, es necesario analizar la distribución de esos tiempos mediante percentiles como p25, p50, p90 y p99.

Nota

Los percentiles se calculan de forma aproximada. Los valores cercanos a los extremos suelen ser más precisos. Por ejemplo, P1 y P99 generalmente presentan mayor precisión que P50.

Parámetros

Parámetro	Descripción
AggName	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 con el que se ejecuta la operación de agregación. Solo son compatibles los tipos LONG, DOUBLE y DATE.
Percentiles	Los percentiles, como p50, p90 y p99. Es posible especificar uno o varios percentiles.
Missing	Valor predeterminado del campo con el que se ejecuta la operación de agregación en una fila cuando el valor del campo está vacío. Si no especifica un valor para Missing, la fila se ignora. Si especifica un valor para Missing, dicho valor se utiliza como el valor del campo en esa fila.

Ejemplo

/// <summary>
/// Percentile statistics. 
/// </summary>
/// <param name="otsClient"></param>
public static void PercentilesAggregation(OTSClient otsClient)
{
    PercentilesAggregation percentilesAggregation = new PercentilesAggregation();
    percentilesAggregation.AggName = "Percentiles_Agg";
    percentilesAggregation.FieldName = "pk1";
    percentilesAggregation.Missing = new ColumnValue(10);
    percentilesAggregation.Percentiles = new List<double> { 10.0, 30.0, 60.0, 90.0, 100.0 };

    MatchAllQuery matchAllQuery = new MatchAllQuery();

    SearchQuery searchQuery = new SearchQuery();
    searchQuery.AggregationList = new List<IAggregation> { percentilesAggregation };
    searchQuery.Query = matchAllQuery;
    searchQuery.Limit = 0;

    SearchRequest searchRequest = new SearchRequest(TableName, IndexName, searchQuery);

    SearchResponse searchResponse = otsClient.Search(searchRequest);

    Console.WriteLine(JsonConvert.SerializeObject(searchResponse));
}

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 entre sí. La operación devuelve el valor de cada grupo y la cantidad de veces que aparece dicho valor.

Nota

Si un grupo contiene una cantidad muy grande de valores, el número calculado puede diferir del real.

Parámetros

Parámetro	Descripción
GroupByName	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 operación de agregación. Solo son compatibles los tipos LONG, DOUBLE, BOOLEAN, KEYWORD y DATE.
Size	Cantidad de grupos que desea devolver. Valor predeterminado: 10. Valor máximo: 2000. Si la cantidad de grupos supera los 2000, solo se devuelven los primeros 2000.
GroupBySorters	Reglas de ordenamiento de 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. Parámetros 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.
SubAggregation y SubGroupBy	Operación de subagregación. Puede ejecutar esta operación a partir de los resultados de agrupación. Escenario Consultar la cantidad de productos por categoría, así como el precio máximo y mínimo de los productos en cada una. Métodos Agrupe los resultados de la consulta por categoría de producto para obtener la cantidad de productos en cada una. Después, ejecute dos operaciones de subagregación para calcular el precio máximo y mínimo por categoría. Resultado de ejemplo Frutas: 5. El precio máximo es de USD 2 y el mínimo, de USD 0.5. Artículos de tocador: 10. El precio máximo es de USD 13 y el mínimo, de USD 0.1. Dispositivos electrónicos: 3. El precio máximo es de USD 1,160 y el mínimo, de USD 310. Otros productos: 15. El precio máximo es de USD 130 y el mínimo, de USD 11.

Ejemplo

/// <summary>
/// Group by field value. 
/// </summary>
/// <param name="otsClient"></param>
public static void GroupByField(OTSClient otsClient)
{
    GroupByField groupByField = new GroupByField
    {
        GroupByName = "GroupBy_Field",
        FieldName = "pk0",
        GroupBySorters = new List<GroupBySorter>{
            new GroupBySorter()
            {
                RowCountSort = new RowCountSort{ Order = SortOrder.DESC }
            },
            new GroupBySorter()
            {
                GroupKeySort = new GroupKeySort{ Order = SortOrder.DESC }
            }
        }
    };

    MatchAllQuery matchAllQuery = new MatchAllQuery();

    SearchQuery searchQuery = new SearchQuery();
    searchQuery.GroupByList = new List<IGroupBy> { groupByField };
    searchQuery.Query = matchAllQuery;
    searchQuery.Limit = 0;

    SearchRequest searchRequest = new SearchRequest(TableName, IndexName, searchQuery);

    SearchResponse searchResponse = otsClient.Search(searchRequest);

    Console.WriteLine(JsonConvert.SerializeObject(searchResponse));
}

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 se agrupan entre sí. La operación devuelve la cantidad de valores en cada rango.

Parámetros

Parámetro	Descripción
GroupByName	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 operación de agregación. Solo son compatibles los tipos LONG y DOUBLE.
Range[double_from, double_to)	Rangos de valores para la agrupación. El rango puede comenzar en double.MinValue y terminar en double.MaxValue.
SubAggregation y SubGroupBy	Operación de subagregación. Puede ejecutar esta operación a partir de los resultados de agrupación. Por ejemplo, después de agrupar los resultados por volumen de ventas y por provincia, puede identificar la provincia con mayor proporción de ventas en un rango determinado. Para esta consulta, especifique un valor para GroupByField dentro de GroupByRange.

Ejemplo

/// <summary>
/// Query by range. 
/// </summary>
/// <param name="otsClient"></param>
public static void GroupByRange(OTSClient otsClient)
{
    GroupByRange groupByRange = new GroupByRange();
    groupByRange.GroupByName = "GroupBy_Range";
    groupByRange.FieldName = "pk1";
    groupByRange.Ranges = new List<Range>
    {
        new Range(double.MinValue, 5.0),
        new Range(5.0, 50.0),
        new Range(50.0, 100.0),
        new Range(100.0, double.MaxValue)
    };

    MatchAllQuery matchAllQuery = new MatchAllQuery();

    SearchQuery searchQuery = new SearchQuery();
    searchQuery.GroupByList = new List<IGroupBy> { groupByRange };
    searchQuery.Query = matchAllQuery;
    searchQuery.Limit = 0;

    SearchRequest searchRequest = new SearchRequest(TableName, IndexName, searchQuery);

    SearchResponse searchResponse = otsClient.Search(searchRequest);

    Console.WriteLine(JsonConvert.SerializeObject(searchResponse));
}

Agrupar por ubicación geográfica

Método de agregación que agrupa los resultados de una consulta según la distancia desde distintas ubicaciones geográficas hasta un punto central. Los resultados cuyas distancias caen dentro de un mismo rango se agrupan entre sí. La operación devuelve la cantidad de valores en cada rango.

Parámetros

Parámetro	Descripción
GroupByName	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 que se utiliza en la operación de agregación. Solo es compatible el tipo GEOPOINT.
Origin(double latitude, double longitude)	Longitud y latitud del punto central. latitude indica la latitud del punto central. longitude indica la longitud del punto central.
Range[double_from, double_to)	Rangos de distancia para la agrupación, expresados en metros. El rango puede comenzar en double.MinValue y terminar en double.MaxValue.
SubAggregation y SubGroupBy	Operación de subagregación. Puede ejecutar esta operación a partir de los resultados de agrupación.

Ejemplo

/// <summary>
/// Group by geographical location. 
/// </summary>
/// <param name="otsClient"></param>
public static void GroupByGeoDistance(OTSClient otsClient)
{
    GroupByGeoDistance groupByGeoDistance = new GroupByGeoDistance
    {
        GroupByName = "GroupBy_GeoDistance",
        FieldName = "geo_col",
        Origin = new GeoPoint(0, 0),
        Ranges = new List<Range>
        {
            new Range(double.MinValue , 1000.0),
            new Range(1000.0, 5000.0),
            new Range(5000.0, double.MaxValue)
        }
    };

    MatchAllQuery matchAllQuery = new MatchAllQuery();

    SearchQuery searchQuery = new SearchQuery();
    searchQuery.GroupByList = new List<IGroupBy> { groupByGeoDistance };
    searchQuery.Query = matchAllQuery;
    searchQuery.Limit = 0;

    SearchRequest searchRequest = new SearchRequest(TableName, IndexName, searchQuery);

    SearchResponse searchResponse = otsClient.Search(searchRequest);

    Console.WriteLine(JsonConvert.SerializeObject(searchResponse));
}

Agrupar por filtro

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

Parámetros

Parámetro	Descripción
GroupByName	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.
SubAggregation y SubGroupBy	Operación de subagregación. Puede ejecutar esta operación a partir de los resultados de agrupación.

Ejemplo

/// <summary>
/// Group by filter. 
/// </summary>
/// <param name="otsClient"></param>
public static void GroupByFilter(OTSClient otsClient)
{
    GroupByFilter groupByFilter = new GroupByFilter
    {
        GroupByName = "GroupBy_Filter",
        Filters = new List<IQuery>
        {
            new RangeQuery
            {
                FieldName = "pk1",
                From = new ColumnValue(0.0),
                To = new ColumnValue(5.0)
            },
        }
    };

    TermsQuery termsQuery = new TermsQuery();
    termsQuery.FieldName = "pk0";
    termsQuery.Terms = new List<ColumnValue>
    {
        new ColumnValue("Tablestore SearchIndex"),
        new ColumnValue("SearchIndex")
    };

    SearchQuery searchQuery = new SearchQuery();
    searchQuery.GroupByList = new List<IGroupBy> { groupByFilter };
    searchQuery.Query = termsQuery;
    searchQuery.Limit = 0;

    SearchRequest searchRequest = new SearchRequest(TableName, IndexName, searchQuery);

    SearchResponse searchResponse = otsClient.Search(searchRequest);

    Console.WriteLine(JsonConvert.SerializeObject(searchResponse));
}

Consultar por histograma

Método de agregación que agrupa los resultados de una consulta según intervalos de datos específicos. Los valores de campo que caen dentro del mismo intervalo se agrupan entre sí. La operación devuelve el rango de valores de cada grupo y la cantidad de valores que contiene.

Parámetros

Parámetro	Descripción
GroupByName	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 operación de agregación. Solo son compatibles los tipos LONG y DOUBLE.
Interval	Intervalo de datos que se utiliza para obtener los resultados de agregación.
FieldRange[min,max]	Rango que se combina con el parámetro de intervalo para limitar la cantidad de grupos. El valor calculado con la fórmula `(FieldRange.max-FieldRange.min)/interval` no debe 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 operación de agregación. Si no especifica un valor para Missing, la fila se ignora. Si especifica un valor para Missing, ese valor se utiliza como valor del campo en la fila.

Ejemplo

/// <summary>
/// Query by histogram. 
/// </summary>
/// <param name="otsClient"></param>
public static void HistogramAggregation(OTSClient otsClient)
{
    GroupByHistogram groupByHistogram = new GroupByHistogram();
    groupByHistogram.GroupByName = "GroupBy_Histogram";
    groupByHistogram.FieldName = "pk1";
    groupByHistogram.Interval = new ColumnValue(5);
    groupByHistogram.Missing = new ColumnValue(100);
    groupByHistogram.FieldRange = new FieldRange(new ColumnValue(0), new ColumnValue(1000));

    MatchAllQuery matchAllQuery = new MatchAllQuery(); ;

    SearchQuery searchQuery = new SearchQuery();
    searchQuery.Query = matchAllQuery;
    searchQuery.Limit = 0;
    searchQuery.GroupByList = new List<IGroupBy>
    {
        groupByHistogram
    };

    SearchRequest searchRequest = new SearchRequest(TableName, IndexName, searchQuery);

    SearchResponse searchResponse = otsClient.Search(searchRequest);

    foreach (GroupByHistogramResultItem item in searchResponse.GroupByResults.GetAsGroupByHistogramResult("GroupBy_Histogram").GroupByHistogramResultItems)
    {
        Console.WriteLine(JsonConvert.SerializeObject(item));
    }
}

Consultar las filas obtenidas de los resultados de una operación de 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 operación de 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 obtener el campo requerido, consulte directamente la tabla de datos.

Parámetros

Parámetro	Descripción
AggName	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 que se utiliza para ordenar los datos dentro de los grupos.
ColumnsToGet	Campos que desea devolver. Solo se admiten campos presentes en índices de búsqueda. No son compatibles los campos ARRAY, DATE, GEOPOINT ni NESTED. Este parámetro equivale a columnsToGet en SearchRequest. Basta con especificar columnsToGet en SearchRequest.

Ejemplo

/// <summary>
/// Query the rows that are obtained from the results of an aggregation operation in each group. 
/// </summary>
/// <param name="otsClient"></param>
public static void TopRowsAggregation(OTSClient otsClient)
{
    GroupByField groupByField = new GroupByField();
    groupByField.GroupByName = "GroupBy_Field";
    groupByField.FieldName = "pk0";
    groupByField.SubAggregations = new List<IAggregation>
    {
        new TopRowsAggregation
        {
            AggName = "TopRows_Agg",
            Sort = new Sort(new List<ISorter> { new FieldSort("pk1", SortOrder.DESC) }),
            Limit = 2
        }
    };

    MatchAllQuery matchAllQuery = new MatchAllQuery(); ;

    SearchQuery searchQuery = new SearchQuery();
    searchQuery.Query = matchAllQuery;
    searchQuery.Limit = 0;
    searchQuery.GroupByList = new List<IGroupBy>
    {
        groupByField
    };

    SearchRequest searchRequest = new SearchRequest(TableName, IndexName, searchQuery);

    SearchResponse searchResponse = otsClient.Search(searchRequest);

    foreach (GroupByFieldResultItem item in searchResponse.GroupByResults.GetAsGroupByFieldResult("GroupBy_Field").GroupByFieldResultItems)
    {
        foreach (Row row in item.SubAggregationResults.GetAsTopRowsAggregationResult("TopRows_Agg").Rows)
        {
            Console.WriteLine(JsonConvert.SerializeObject(row));
        }
    }
}

Anidamiento

El anidamiento permite ejecutar operaciones de subagregación dentro de un grupo. Por ejemplo, puede anidar operaciones de agregación hasta en dos niveles.

GroupBy + SubGroupBy: los elementos se agrupan por provincia y luego por ciudad para obtener los datos de cada ciudad dentro de cada provincia.
GroupBy + SubAggregation: los elementos se agrupan por provincia y se calcula el valor máximo de una métrica para obtener dicho valor por provincia.

Nota

Para equilibrar el rendimiento y la complejidad, solo se permite un número específico de niveles de anidamiento. Para más información, consulte Search index limits.

/// <summary>
/// Nesting. 
/// </summary>
/// <param name="otsClient"></param>
public static void SubGroupBy(OTSClient otsClient)
{
    GroupByField groupByField = new GroupByField();
    groupByField.GroupByName = "Field_GroupBy";
    groupByField.FieldName = "pk0";
    groupByField.SubGroupBys = new List<IGroupBy>
    {
        new GroupByRange
        {
            GroupByName = "Range_GroupBy",
            FieldName = "pk1",
            Ranges = new List<Range>
            {
                new Range(double.MinValue, 5),
                new Range(5,100),
                new Range(100, double.MaxValue)
            }

        }
    };

    MatchAllQuery matchAllQuery = new MatchAllQuery();

    SearchQuery searchQuery = new SearchQuery();
    searchQuery.GroupByList = new List<IGroupBy>
    {
        groupByField
    };
    searchQuery.GetTotalCount = true;
    searchQuery.Limit = 0;
    searchQuery.Query = matchAllQuery;

    SearchRequest searchRequest = new SearchRequest(TableName, IndexName, searchQuery);

    SearchResponse searchResponse = otsClient.Search(searchRequest);

    foreach (GroupByFieldResultItem item in searchResponse.GroupByResults.GetAsGroupByFieldResult("Field_GroupBy").GroupByFieldResultItems)
    {
        Console.WriteLine(JsonConvert.SerializeObject(item.SubGroupByResults.GetAsGroupByRangeResult("Range_GroupBy")));
    }
}

Varias agregaciones

Puede ejecutar varias operaciones de agregación.

Nota

Si ejecuta varias operaciones de agregación complejas al mismo tiempo, el proceso puede tardar bastante tiempo.

/// <summary>
/// Multiple aggregations. 
/// </summary>
/// <param name="otsClient"></param>
public static void MultipleAggregation(OTSClient otsClient)
{
    MaxAggregation maxAggregation = new MaxAggregation();
    maxAggregation.AggName = "Max_Agg";
    maxAggregation.FieldName = "pk1";

    MinAggregation minAggregation = new MinAggregation();
    minAggregation.AggName = "Min_Agg";
    minAggregation.FieldName = "pk1";

    SumAggregation sumAggregation = new SumAggregation();
    sumAggregation.AggName = "Sum_Agg";
    sumAggregation.FieldName = "pk1";

    SearchQuery searchQuery = new SearchQuery();
    searchQuery.Limit = 0;
    searchQuery.Query = new MatchAllQuery();
    searchQuery.AggregationList = new List<IAggregation>
    {
        maxAggregation,
        minAggregation,
        sumAggregation
    };

    SearchRequest searchRequest = new SearchRequest(TableName, IndexName, searchQuery);

    SearchResponse searchResponse = otsClient.Search(searchRequest);

    Console.WriteLine(JsonConvert.SerializeObject(searchResponse));
}