Agrégation - Tablestore - Centre de documentation Alibaba Cloud

Cette rubrique explique comment effectuer des opérations d'agrégation pour l'analyse des données. Les opérations d'agrégation permettent de calculer les valeurs minimales, maximales, la somme, la moyenne, le nombre total, le nombre distinct et les percentiles. Vous pouvez regrouper les résultats par valeur de champ, plage, emplacement géographique, filtres, histogrammes ou dates, et exécuter des requêtes imbriquées pour analyser les lignes de chaque groupe. Il est également possible de combiner plusieurs opérations d'agrégation pour des requêtes plus complexes.

Procédure

La figure suivante illustre la procédure complète d'agrégation.

fig_agg_pro

Le serveur interroge les données qui répondent aux conditions de la requête et effectue une agrégation sur ces données en fonction de la demande. Par conséquent, une requête nécessitant une agrégation est plus complexe à traiter qu'une requête n'en nécessitant pas.

Fonctionnalités

L'agrégation prend en charge plusieurs fonctionnalités similaires aux fonctions SQL, telles que la fonction MIN() pour obtenir la valeur minimale, la fonction MAX() pour obtenir la valeur maximale, la fonction SUM() pour obtenir la somme, la fonction AVG() pour obtenir la valeur moyenne, la fonction COUNT() pour obtenir le nombre de lignes, la fonction COUNT(DISTINCT) pour obtenir le nombre de lignes distinctes, la fonction ANY_VALUE() pour interroger les lignes obtenues à partir des résultats d'une opération d'agrégation dans chaque groupe, et la clause GROUP BY pour grouper les résultats de la requête. Vous pouvez également effectuer des opérations d'agrégation pour obtenir des statistiques de percentile, grouper les résultats par valeur de champ, plage, emplacement géographique, filtre, histogramme ou histogramme de date, grouper les résultats selon plusieurs champs et effectuer des requêtes imbriquées. Le tableau suivant décrit ces fonctionnalités.

Fonctionnalité	Description
Valeur minimale	Méthode d'agrégation permettant de renvoyer la valeur minimale d'un champ. Cette méthode s'utilise de manière similaire à la fonction SQL MIN.
Valeur maximale	Méthode d'agrégation permettant de renvoyer la valeur maximale d'un champ. Cette méthode s'utilise de manière similaire à la fonction SQL MAX.
Somme	Méthode d'agrégation permettant de renvoyer la somme de toutes les valeurs d'un champ numérique. Cette méthode s'utilise de manière similaire à la fonction SQL SUM.
Valeur moyenne	Méthode d'agrégation permettant de renvoyer la moyenne de toutes les valeurs d'un champ numérique. Cette méthode s'utilise de manière similaire à la fonction SQL AVG.
Nombre total	Méthode d'agrégation permettant de renvoyer le nombre total de valeurs pour un champ ou le nombre total de lignes dans un index de recherche. Cette méthode s'utilise de manière similaire à la fonction SQL COUNT.
Nombre distinct	Méthode d'agrégation permettant de renvoyer le nombre de valeurs distinctes pour un champ. Cette méthode s'utilise de manière similaire à la fonction SQL COUNT(DISTINCT).
Statistiques de percentile	Une valeur de percentile indique la position relative d'une valeur dans un ensemble de données. Par exemple, lors de la collecte de statistiques sur le temps de réponse de chaque requête pendant les opérations de maintenance courantes de votre système, vous devez analyser la distribution du temps de réponse à l'aide de percentiles tels que p25, p50, p90 et p99.
Grouper par valeur de champ	Méthode d'agrégation permettant de grouper les résultats de la requête en fonction des valeurs de champ. Les valeurs identiques sont regroupées. La valeur identique pour chaque groupe et le nombre de valeurs identiques dans chaque groupe sont renvoyés.
Imbrication dans GroupBy	GroupBy prend en charge l'imbrication. Vous pouvez effectuer des sous-opérations d'agrégation à l'aide de GroupBy.
Grouper par plusieurs champs	Méthode d'agrégation permettant de grouper les résultats de la requête en fonction de plusieurs champs. Vous pouvez utiliser des jetons pour effectuer la pagination.
Grouper par plage	Méthode d'agrégation permettant de grouper les résultats de la requête en fonction des plages de valeurs d'un champ. Les valeurs de champ situées dans une plage spécifique sont regroupées. Le nombre de valeurs dans chaque plage est renvoyé.
Grouper par emplacement géographique	Méthode d'agrégation permettant de grouper les résultats de la requête en fonction des distances entre les emplacements géographiques et un point central. Les résultats de la requête dont les distances se situent dans une plage spécifique sont regroupés. Le nombre de valeurs dans chaque plage est renvoyé.
Grouper par filtre	Méthode d'agrégation permettant de filtrer les résultats de la requête et de les regrouper afin d'obtenir le nombre de résultats correspondant à chaque filtre. Les résultats sont renvoyés dans l'ordre de spécification des filtres.
Requête par histogramme	Méthode d'agrégation permettant de grouper les résultats de la requête en fonction d'intervalles de données spécifiques. Les valeurs de champ situées dans la même plage sont regroupées. La plage de valeurs de chaque groupe et le nombre de valeurs dans chaque groupe sont renvoyés.
Requête par histogramme de date	Méthode d'agrégation permettant de grouper les résultats de la requête en fonction d'intervalles de date spécifiques. Les valeurs de champ situées dans la même plage sont regroupées. La plage de valeurs de chaque groupe et le nombre de valeurs dans chaque groupe sont renvoyés.
Interroger les lignes obtenues à partir des résultats d'une opération d'agrégation dans chaque groupe	Après avoir groupé les résultats de la requête, vous pouvez interroger les lignes de chaque groupe. Cette méthode s'utilise de manière similaire à la fonction ANY_VALUE(champ) dans MySQL.
Agrégations multiples	Vous pouvez effectuer plusieurs opérations d'agrégation. Remarque Si vous effectuez simultanément plusieurs opérations d'agrégation complexes, le traitement peut prendre beaucoup de temps.

Prérequis

Une instance OTSClient est initialisée. Pour plus d'informations, consultez Initialiser une instance OTSClient.
Un tableau de données est créé et des données y sont écrites. Pour plus d'informations, consultez Créer des tableaux de données et Écrire des données.
Un index de recherche est créé pour le tableau de données. Pour plus d'informations, consultez Créer des index de recherche.

Valeur minimale

Méthode d'agrégation permettant de renvoyer la valeur minimale d'un champ. Cette méthode s'utilise de manière similaire à la fonction SQL MIN.

Paramètres

Paramètre	Description
AggName	Nom unique de l'opération d'agrégation. Vous pouvez interroger les résultats d'une opération d'agrégation spécifique en fonction de ce nom.
FieldName	Nom du champ utilisé pour effectuer l'opération d'agrégation. Seuls les types LONG, DOUBLE et DATE sont pris en charge.
Missing	Valeur par défaut du champ utilisé pour effectuer l'opération d'agrégation sur une ligne lorsque la valeur du champ est vide. Si vous ne spécifiez pas de valeur pour Missing, la ligne est ignorée. Si vous spécifiez une valeur pour Missing, la valeur de ce paramètre est utilisée comme valeur de champ de la ligne.

Exemple

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

Valeur maximale

Méthode d'agrégation permettant de renvoyer la valeur maximale d'un champ. Cette méthode s'utilise de manière similaire à la fonction SQL MAX.

Paramètres

Paramètre	Description
AggName	Nom unique de l'opération d'agrégation. Vous pouvez interroger les résultats d'une opération d'agrégation spécifique en fonction de ce nom.
FieldName	Nom du champ utilisé pour effectuer l'opération d'agrégation. Seuls les types LONG, DOUBLE et DATE sont pris en charge.
Missing	Valeur par défaut du champ utilisé pour effectuer l'opération d'agrégation sur une ligne lorsque la valeur du champ est vide. Si vous ne spécifiez pas de valeur pour Missing, la ligne est ignorée. Si vous spécifiez une valeur pour Missing, la valeur de ce paramètre est utilisée comme valeur de champ de la ligne.

Exemple

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

Somme

Méthode d'agrégation permettant de renvoyer la somme de toutes les valeurs d'un champ numérique. Cette méthode s'utilise de manière similaire à la fonction SQL SUM.

Paramètres

Paramètre	Description
AggName	Nom unique de l'opération d'agrégation. Vous pouvez interroger les résultats d'une opération d'agrégation spécifique en fonction de ce nom.
FieldName	Nom du champ utilisé pour effectuer l'opération d'agrégation. Seuls les types LONG et DOUBLE sont pris en charge.
Missing	Valeur par défaut du champ utilisé pour effectuer l'opération d'agrégation sur une ligne lorsque la valeur du champ est vide. Si vous ne spécifiez pas de valeur pour Missing, la ligne est ignorée. Si vous spécifiez une valeur pour Missing, la valeur de ce paramètre est utilisée comme valeur de champ de la ligne.

Exemple

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

Valeur moyenne

Méthode d'agrégation permettant de renvoyer la moyenne de toutes les valeurs d'un champ numérique. Cette méthode s'utilise de manière similaire à la fonction SQL AVG.

Paramètres

Paramètre	Description
AggName	Nom unique de l'opération d'agrégation. Vous pouvez interroger les résultats d'une opération d'agrégation spécifique en fonction de ce nom.
FieldName	Nom du champ utilisé pour effectuer l'opération d'agrégation. Seuls les types LONG, DOUBLE et DATE sont pris en charge.
Missing	Valeur par défaut du champ utilisé pour effectuer l'opération d'agrégation sur une ligne lorsque la valeur du champ est vide. Si vous ne spécifiez pas de valeur pour Missing, la ligne est ignorée. Si vous spécifiez une valeur pour Missing, la valeur de ce paramètre est utilisée comme valeur de champ de la ligne.

Exemple

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

Nombre total

Méthode d'agrégation permettant de renvoyer le nombre total de valeurs pour un champ spécifié ou le nombre total de lignes dans un index de recherche. Cette méthode s'utilise de manière similaire à la fonction SQL COUNT.

Remarque

Vous pouvez utiliser les méthodes suivantes pour interroger le nombre total de lignes dans un index de recherche ou le nombre total de lignes qui répondent aux conditions de la requête :

Utilisez la fonctionnalité de comptage de l'agrégation et spécifiez count(*) dans la requête.
Utilisez la fonctionnalité de requête pour obtenir le nombre de lignes qui répondent aux conditions de la requête. Définissez setGetTotalCount sur true dans la requête. Utilisez MatchAllQuery pour obtenir le nombre total de lignes dans un index de recherche.

Vous pouvez utiliser le nom d'une colonne comme valeur de l'expression count pour interroger le nombre de lignes contenant la colonne dans un index de recherche. Cette méthode convient aux scénarios impliquant des colonnes clairsemées.

Paramètres

Paramètre

Description

AggName

Nom unique de l'opération d'agrégation. Vous pouvez interroger les résultats d'une opération d'agrégation spécifique en fonction de ce nom.

FieldName

Nom du champ utilisé pour effectuer l'opération d'agrégation. Seuls les types LONG, DOUBLE, BOOLEAN, KEYWORD, GEO_POINT et DATE sont pris en charge.

Exemple

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

Nombre distinct

Méthode d'agrégation permettant de renvoyer le nombre de valeurs distinctes pour un champ. Cette méthode s'utilise de manière similaire à la fonction SQL COUNT(DISTINCT).

Remarque

Le nombre de valeurs distinctes est une valeur approximative.

Si le nombre total de lignes avant l'utilisation de la fonctionnalité de comptage distinct est inférieur à 10 000, le résultat calculé est proche de la valeur exacte.
Si le nombre total de lignes avant l'utilisation de la fonctionnalité de comptage distinct est supérieur ou égal à 100 millions, le taux d'erreur est d'environ 2 %.

Paramètres

Paramètre	Description
AggName	Nom unique de l'opération d'agrégation. Vous pouvez interroger les résultats d'une opération d'agrégation spécifique en fonction de ce nom.
FieldName	Nom du champ utilisé pour effectuer l'opération d'agrégation. Seuls les types LONG, DOUBLE, BOOLEAN, KEYWORD, GEO_POINT et DATE sont pris en charge.
Missing	Valeur par défaut du champ utilisé pour effectuer l'opération d'agrégation sur une ligne lorsque la valeur du champ est vide. Si vous ne spécifiez pas de valeur pour Missing, la ligne est ignorée. Si vous spécifiez une valeur pour Missing, la valeur de ce paramètre est utilisée comme valeur de champ de la ligne.

Exemple

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

Statistiques de percentile

Une valeur de percentile indique la position relative d'une valeur au sein d'un ensemble de données. Par exemple, lorsque vous collectez des statistiques sur le temps de réponse de chaque requête lors des opérations de maintenance courantes de votre système, vous devez analyser la distribution des temps de réponse à l'aide de percentiles tels que p25, p50, p90 et p99.

Remarque

Les percentiles sont calculés de manière approximative. Les percentiles situés aux extrémités sont généralement plus précis. Par exemple, P1 et P99 sont généralement plus précis que P50.

Paramètres

Parameter	Description
AggName	Le nom unique de l'opération d'agrégation. Vous pouvez interroger les résultats d'une opération d'agrégation spécifique en fonction de ce nom.
FieldName	Le nom du champ utilisé pour effectuer l'opération d'agrégation. Seuls les types LONG, DOUBLE et DATE sont pris en charge.
Percentiles	Les percentiles, tels que p50, p90 et p99. Vous pouvez spécifier un ou plusieurs percentiles.
Missing	La valeur par défaut du champ utilisé pour effectuer l'opération d'agrégation sur une ligne lorsque la valeur du champ est vide. Si vous ne spécifiez pas de valeur pour Missing, la ligne est ignorée. Si vous spécifiez une valeur pour Missing, la valeur de ce paramètre est utilisée comme valeur de champ de la ligne.

Exemple

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

Regroupement par valeur de champ

Méthode d'agrégation permettant de regrouper les résultats de requête en fonction des valeurs de champ. Les valeurs identiques sont regroupées ensemble. La valeur identique de chaque groupe et le nombre de valeurs identiques dans chaque groupe sont renvoyés.

Remarque

Le nombre calculé peut différer du nombre réel si le nombre de valeurs dans un groupe est très élevé.

Paramètres

Parameter	Description
GroupByName	Le nom unique de l'opération d'agrégation. Vous pouvez interroger les résultats d'une opération d'agrégation spécifique en fonction de ce nom.
FieldName	Le nom du champ utilisé pour effectuer l'opération d'agrégation. Seuls les types LONG, DOUBLE, BOOLEAN, KEYWORD et DATE sont pris en charge.
Size	Le nombre de groupes que vous souhaitez renvoyer. Valeur par défaut : 10. Valeur maximale : 2000. Si le nombre de groupes dépasse 2 000, seuls les 2 000 premiers groupes sont renvoyés.
GroupBySorters	Les règles de tri pour les groupes. Par défaut, les groupes sont triés en fonction du nombre d'éléments dans les groupes, par ordre décroissant. Si vous configurez plusieurs règles de tri, les groupes sont triés selon l'ordre dans lequel les règles sont configurées. Paramètres pris en charge : Tri par valeur par ordre alphabétique. Tri par valeur par ordre alphabétique inverse. Tri par nombre de lignes par ordre croissant. Tri par nombre de lignes par ordre décroissant. Tri par les valeurs obtenues à partir des résultats de sous-agrégation par ordre croissant. Tri par les valeurs obtenues à partir des résultats de sous-agrégation par ordre décroissant.
SubAggregation et SubGroupBy	L'opération de sous-agrégation. Vous pouvez effectuer l'opération de sous-agrégation en fonction des résultats de regroupement. Scénario Interrogez le nombre de produits dans chaque catégorie, ainsi que les prix maximum et minimum des produits dans chaque catégorie. Méthodes Regroupez les résultats de la requête par catégorie de produit pour obtenir le nombre de produits dans chaque catégorie. Ensuite, effectuez deux opérations de sous-agrégation pour obtenir les prix maximum et minimum des produits dans chaque catégorie. Exemple de résultat Fruits : 5. Le prix maximum est de 2 USD. Le prix minimum est de 0,5 USD. Articles de toilette : 10. Le prix maximum est de 13 USD. Le prix minimum est de 0,1 USD. Appareils électroniques : 3. Le prix maximum est de 1 160 USD. Le prix minimum est de 310 USD. Autres produits : 15. Le prix maximum est de 130 USD. Le prix minimum est de 11 USD.

Exemple

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

Regroupement par plage

Méthode d'agrégation permettant de regrouper les résultats de requête en fonction des plages de valeurs d'un champ. Les valeurs de champ comprises dans une plage spécifique sont regroupées ensemble. Le nombre de valeurs dans chaque plage est renvoyé.

Paramètres

Parameter

Description

GroupByName

Le nom unique de l'opération d'agrégation. Vous pouvez interroger les résultats d'une opération d'agrégation spécifique en fonction de ce nom.

FieldName

Le nom du champ utilisé pour effectuer l'opération d'agrégation. Seuls les types LONG et DOUBLE sont pris en charge.

Range[double_from, double_to)

Les plages de valeurs pour le regroupement.

La plage de valeurs peut commencer à double.MinValue et se terminer à double.MaxValue.

SubAggregation et SubGroupBy

L'opération de sous-agrégation. Vous pouvez effectuer l'opération de sous-agrégation en fonction des résultats de regroupement.

Par exemple, après avoir regroupé les résultats de la requête par volume de ventes et par province, vous pouvez obtenir la province qui représente la plus grande proportion du volume de ventes dans une plage spécifiée. Vous devez spécifier une valeur pour GroupByField dans GroupByRange pour effectuer cette requête.

Exemple

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

Regroupement par emplacement géographique

Méthode d'agrégation permettant de regrouper les résultats de requête en fonction des distances par rapport à un point central. Les résultats de requête dont les distances se situent dans une plage spécifique sont regroupés ensemble. Le nombre de valeurs dans chaque plage est renvoyé.

Paramètres

Parameter

Description

GroupByName

Le nom unique de l'opération d'agrégation. Vous pouvez interroger les résultats d'une opération d'agrégation spécifique en fonction de ce nom.

FieldName

Le nom du champ utilisé pour l'opération d'agrégation. Seul le type GEOPOINT est pris en charge.

Origin(double latitude, double longitude)

La longitude et la latitude du point central.

latitude spécifie la latitude du point central. longitude spécifie la longitude du point central.

Range[double_from, double_to)

Les plages de distance utilisées pour le regroupement. Unité : mètres.

La plage de valeurs peut commencer à double.MinValue et se terminer à double.MaxValue.

SubAggregation et SubGroupBy

L'opération de sous-agrégation. Vous pouvez effectuer l'opération de sous-agrégation en fonction des résultats de regroupement.

Exemple

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

Regroupement par filtre

Méthode d'agrégation permettant de filtrer les résultats de la requête et de les regrouper afin d'obtenir le nombre de résultats correspondant à chaque filtre. Les résultats sont renvoyés dans l'ordre dans lequel les filtres sont spécifiés.

Paramètres

Parameter

Description

GroupByName

Le nom unique de l'opération d'agrégation. Vous pouvez interroger les résultats d'une opération d'agrégation spécifique en fonction de ce nom.

Filters

Les filtres pouvant être utilisés pour la requête. Les résultats sont renvoyés dans l'ordre dans lequel les filtres sont spécifiés.

SubAggregation et SubGroupBy

L'opération de sous-agrégation. Vous pouvez effectuer l'opération de sous-agrégation en fonction des résultats de regroupement.

Exemple

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

Requête par histogramme

Méthode d'agrégation permettant de regrouper les résultats de requête en fonction d'intervalles de données spécifiques. Les valeurs de champ comprises dans la même plage sont regroupées ensemble. La plage de valeurs de chaque groupe et le nombre de valeurs dans chaque groupe sont renvoyés.

Paramètres

Parameter	Description
GroupByName	Le nom unique de l'opération d'agrégation. Vous pouvez interroger les résultats d'une opération d'agrégation spécifique en fonction de ce nom.
FieldName	Le nom du champ utilisé pour effectuer l'opération d'agrégation. Seuls les types LONG et DOUBLE sont pris en charge.
Interval	L'intervalle de données utilisé pour obtenir les résultats d'agrégation.
FieldRange[min,max]	La plage utilisée conjointement avec le paramètre interval pour limiter le nombre de groupes. La valeur calculée à l'aide de la formule `(FieldRange.max-FieldRange.min)/interval` ne peut pas dépasser 2 000.
MinDocCount	Le nombre minimal de lignes. Si le nombre de lignes dans un groupe est inférieur au nombre minimal de lignes, les résultats d'agrégation pour ce groupe ne sont pas renvoyés.
Missing	La valeur par défaut du champ utilisé pour effectuer l'opération d'agrégation sur une ligne lorsque la valeur du champ est vide. Si vous ne spécifiez pas de valeur pour Missing, la ligne est ignorée. Si vous spécifiez une valeur pour Missing, la valeur de ce paramètre est utilisée comme valeur de champ de la ligne.

Exemple

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

Interroger les lignes obtenues à partir des résultats d'une opération d'agrégation dans chaque groupe

Après avoir regroupé les résultats de la requête, vous pouvez interroger les lignes dans chaque groupe. Cette méthode peut être utilisée de manière similaire à la fonction ANY_VALUE(champ) dans MySQL.

Remarque

Lorsque vous interrogez les lignes obtenues à partir des résultats d'une opération d'agrégation dans chaque groupe, les résultats renvoyés ne contiennent que les informations de clé primaire si l'index de recherche contient le champ Nested, Geopoint ou Array. Pour obtenir le champ requis, vous devez interroger la table de données.

Paramètres

Parameter

Description

AggName

Le nom unique de l'opération d'agrégation. Vous pouvez interroger les résultats d'une opération d'agrégation spécifique en fonction de ce nom.

Limit

Le nombre maximal de lignes pouvant être renvoyées pour chaque groupe. Par défaut, une seule ligne de données est renvoyée.

Sort

La méthode de tri utilisée pour trier les données dans les groupes.

ColumnsToGet

Les champs que vous souhaitez renvoyer. Seuls les champs des index de recherche sont pris en charge. Les champs ARRAY, DATE, GEOPOINT et NESTED ne sont pas pris en charge.

La valeur de ce paramètre est identique à celle de columnsToGet dans SearchRequest. Vous devez uniquement spécifier columnsToGet dans SearchRequest.

Exemple

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

Imbrication

Vous pouvez utiliser l'imbrication pour effectuer des opérations de sous-agrégation dans un groupe. Par exemple, vous pouvez effectuer des opérations d'agrégation imbriquées jusqu'à deux niveaux.

GroupBy + SubGroupBy : Les éléments sont regroupés par province et par ville pour obtenir les données de chaque ville dans chaque province.
GroupBy + SubAggregation : Les éléments sont regroupés par province et la valeur maximale d'une métrique est calculée pour obtenir la valeur maximale d'une métrique pour chaque province.

Remarque

Pour équilibrer les performances et la complexité, seul un nombre spécifique de couches d'imbrication est autorisé. Pour plus d'informations, consultez Limites de l'index de recherche.

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

Agrégations multiples

Vous pouvez effectuer plusieurs opérations d'agrégation.

Remarque

Si vous effectuez plusieurs opérations d'agrégation complexes simultanément, cela peut prendre beaucoup de temps.

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