Agrégation - Tablestore - Centre de documentation Alibaba Cloud

Vous pouvez effectuer des opérations d'agrégation pour obtenir les valeurs minimale, maximale, la somme et la moyenne, ainsi que le nombre total et le nombre distinct de lignes. Il est également possible de grouper les résultats par valeur de champ, par plage, par emplacement géographique ou par filtre, et d'exécuter des requêtes imbriquées. Plusieurs opérations d'agrégation peuvent être combinées pour réaliser des requêtes complexes.

Procédure

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

fig_agg_pro

Le serveur interroge les données répondant aux conditions de requête et effectue l'agrégation selon 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.

Informations générales

Le tableau suivant décrit les méthodes d'agrégation.

Méthode	Description
Valeur minimale	Méthode d'agrégation permettant de renvoyer la valeur minimale d'un champ. Elle 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. Elle 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. Elle 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. Elle s'utilise de manière similaire à la fonction SQL AVG.
Comptage	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. Elle s'utilise de manière similaire à la fonction SQL COUNT.
Comptage distinct	Méthode d'agrégation permettant de renvoyer le nombre de valeurs distinctes pour un champ. Elle 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 au sein d'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 des temps de réponse à l'aide de percentiles tels que p25, p50, p90 et p99.
Groupement 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 rassemblées. 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é.
Groupement 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 situées dans une plage spécifique sont rassemblées. Le nombre de valeurs dans chaque plage est renvoyé.
Groupement 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 géographique. Les résultats de requête dont les distances se situent dans une plage spécifique sont rassemblés. Le nombre de valeurs dans chaque plage est renvoyé.
Groupement par filtre	Méthode d'agrégation permettant de filtrer les résultats de 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 regrouper les résultats de requête en fonction d'intervalles de données spécifiques. Les valeurs de champ situées dans la même plage sont rassemblées. La plage de valeurs de chaque groupe et le nombre de valeurs dans chaque groupe sont renvoyés.
Interrogation des lignes obtenues à partir des résultats d'une opération d'agrégation dans chaque groupe	Après avoir groupé les résultats de 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.

Prérequis

Une instance OTSClient est initialisée. Pour plus d'informations, consultez la rubrique Initialiser une instance OTSClient.
Une table de données est créée et des données y sont écrites. Pour plus d'informations, consultez les rubriques Créer des tables de données et Écrire des données.
Un index de recherche est créé pour la table de données. Pour plus d'informations, consultez la rubrique Créer un index de recherche.

Valeur minimale

Cette méthode d'agrégation renvoie la valeur minimale d'un champ. Elle fonctionne de manière similaire à la fonction SQL MIN.

Paramètres

Parameter	Description
name	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 vous basant sur 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 attribuée au champ lors de l'agrégation d'une ligne dont la valeur de champ est vide. Si aucune valeur n'est spécifiée pour le paramètre missing, la ligne est ignorée. Si une valeur est spécifiée pour le paramètre missing, cette valeur est utilisée comme valeur de champ pour la ligne.

Exemple

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

Valeur maximale

Cette méthode d'agrégation renvoie la valeur maximale d'un champ. Elle fonctionne de manière similaire à la fonction SQL MAX.

Paramètres

Parameter	Description
name	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 vous basant sur 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 attribuée au champ lors de l'agrégation d'une ligne dont la valeur de champ est vide. Si aucune valeur n'est spécifiée pour le paramètre missing, la ligne est ignorée. Si une valeur est spécifiée pour le paramètre missing, cette valeur est utilisée comme valeur de champ pour la ligne.

Exemple

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

Somme

Cette méthode d'agrégation renvoie la somme de toutes les valeurs d'un champ numérique. Elle fonctionne de manière similaire à la fonction SQL SUM.

Paramètres

Parameter	Description
name	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 vous basant sur ce nom.
fieldName	Nom du champ utilisé pour effectuer l'opération d'agrégation. Seuls les types de données LONG et DOUBLE sont pris en charge.
missing	Valeur par défaut attribuée au champ lors de l'agrégation d'une ligne dont la valeur de champ est vide. Si aucune valeur n'est spécifiée pour le paramètre missing, la ligne est ignorée. Si une valeur est spécifiée pour le paramètre missing, cette valeur est utilisée comme valeur de champ pour la ligne.

Exemple

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

Valeur moyenne

Cette méthode d'agrégation renvoie la moyenne de toutes les valeurs d'un champ numérique. Elle fonctionne de manière similaire à la fonction SQL AVG.

Paramètres

Parameter	Description
name	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 vous basant sur 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 attribuée au champ lors de l'agrégation d'une ligne dont la valeur de champ est vide. Si aucune valeur n'est spécifiée pour le paramètre missing, la ligne est ignorée. Si une valeur est spécifiée pour le paramètre missing, cette valeur est utilisée comme valeur de champ pour la ligne.

Exemple

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

Nombre

Cette méthode d'agrégation renvoie le nombre total de valeurs pour un champ donné ou le nombre total de lignes dans un index de recherche. Son fonctionnement est similaire à celui de la fonction SQL COUNT.

Remarque

Vous pouvez utiliser les méthodes suivantes pour obtenir le nombre total de lignes dans un index de recherche ou le nombre de lignes correspondant aux conditions de requête :

Utilisez la fonctionnalité d'agrégation count et spécifiez count(*) dans la requête.
Recourez à la fonctionnalité de requête pour récupérer le nombre de lignes correspondant aux conditions définies. Définissez setGetTotalCount sur true dans la requête. Utilisez MatchAllQuery pour obtenir le nombre total de lignes dans un index de recherche.

Il est possible d'utiliser le nom d'une colonne comme valeur de l'expression count afin de compter les lignes contenant cette colonne dans un index de recherche. Cette approche convient particulièrement aux scénarios impliquant des colonnes clairsemées (sparse columns).

Paramètres

>Parameter	>Description
>name	>Nom unique de l'opération d'agrégation. Vous pouvez interroger les résultats d'une opération spécifique en vous basant sur ce nom.
>fieldName	>Nom du champ utilisé pour effectuer l'agrégation. Seuls les types LONG, DOUBLE, BOOLEAN, KEYWORD, GEO_POINT et DATE sont pris en charge.

Exemple

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

Comptage distinct

Cette méthode d'agrégation renvoie le nombre de valeurs distinctes pour un champ. Son fonctionnement est similaire à celui de la fonction SQL COUNT(DISTINCT).

Remarque

Le nombre de valeurs distinctes constitue une approximation.

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

Paramètres

Parameter	Description
name	Nom unique de l'opération d'agrégation. Vous pouvez interroger les résultats d'une opération spécifique en vous basant sur ce nom.
fieldName	Nom du champ utilisé pour effectuer l'agrégation. Seuls les types LONG, DOUBLE, BOOLEAN, KEYWORD, GEO_POINT et DATE sont pris en charge.
missing	Valeur par défaut attribuée au champ lors de l'agrégation d'une ligne lorsque la valeur du champ est vide. Si aucune valeur n'est spécifiée pour missing, la ligne est ignorée. Si une valeur est spécifiée pour missing, cette valeur est utilisée comme valeur de champ pour la ligne.

Exemple

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

Statistiques de percentile

Une valeur de percentile indique la position relative d'une valeur au sein d'un jeu 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, il est nécessaire d'analyser la distribution des temps de réponse à l'aide de percentiles tels que p25, p50, p90 et p99.

Paramètres

Parameter	Description
name	Nom unique de l'opération d'agrégation. Vous pouvez interroger les résultats d'une opération spécifique en vous basant sur ce nom.
fieldName	Nom du champ utilisé pour effectuer l'agrégation. Seuls les types LONG, DOUBLE et DATE sont pris en charge.
percentiles	Percentiles, tels que p50, p90 et p99. Vous pouvez spécifier un ou plusieurs percentiles.
missing	Valeur par défaut attribuée au champ lors de l'agrégation d'une ligne lorsque la valeur du champ est vide. Si aucune valeur n'est spécifiée pour missing, la ligne est ignorée. Si une valeur est spécifiée pour missing, cette valeur est utilisée comme valeur de champ pour la ligne.

Exemple

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

Groupement par valeur de champ

Cette méthode d'agrégation permet de regrouper les résultats de requête selon les valeurs d'un champ. Les valeurs identiques sont rassemblées au sein d'un même groupe. Pour chaque groupe, la valeur commune ainsi que le nombre d'occurrences correspondantes sont renvoyés.

Remarque

Si un groupe contient un très grand nombre de valeurs, le nombre calculé peut différer du nombre réel.

Paramètres

Parameter	Description
name	Nom unique de l'opération d'agrégation. Vous pouvez interroger les résultats d'une opération spécifique en vous basant sur ce nom.
fieldName	Nom du champ utilisé pour effectuer l'agrégation. Seuls les types LONG, DOUBLE, BOOLEAN, KEYWORD et DATE sont pris en charge.
sort	Règles de tri appliquées aux groupes. Par défaut, les groupes sont triés par nombre d'éléments décroissant. Si plusieurs règles de tri sont configurées, elles sont appliquées dans l'ordre de leur définition. Rèles de tri prises en charge : Tri alphabétique des valeurs. Tri anti-alphabétique des valeurs. Tri croissant selon le nombre de lignes. Tri décroissant selon le nombre de lignes. Tri croissant basé sur les valeurs issues des sous-agrégations. Tri décroissant basé sur les valeurs issues des sous-agrégations.
size	Nombre de groupes à renvoyer. Valeur par défaut : 10. Valeur maximale : 2000. Si le nombre de groupes dépasse 2 000, seuls les 2 000 premiers sont retournés.
subAggs and subGroupBys	Opération de sous-agrégation. Elle s'applique aux résultats du regroupement principal. Scénario Compter le nombre de produits par catégorie, tout en identifiant les prix maximum et minimum au sein de chaque catégorie. Méthode Regroupez les résultats de la requête par catégorie de produit pour obtenir le décompte par catégorie. Ensuite, exécutez deux sous-agrégations afin de déterminer les prix les plus élevés et les plus bas pour chaque catégorie. Exemple : Fruits : 5. Prix maximum : 2 USD. Prix minimum : 0,5 USD. Produits d'hygiène : 10. Prix maximum : 13 USD. Prix minimum : 0,1 USD. Appareils électroniques : 3. Prix maximum : 1 160 USD. Prix minimum : 310 USD. Autres produits : 15. Prix maximum : 130 USD. Prix minimum : 11 USD.

Exemple

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

Groupement par plage

Cette méthode d'agrégation permet de regrouper les résultats de requête selon des plages de valeurs définies pour un champ. Les valeurs comprises dans une même plage sont consolidées. Le nombre de valeurs appartenant à chaque intervalle est ensuite renvoyé.

Paramètres

>Parameter	>Description
>name	>Nom unique de l'opération d'agrégation. Utilisez ce nom pour interroger les résultats d'une agrégation spécifique.
>fieldName	>Nom du champ servant de base à l'agrégation. Seuls les types LONG et DOUBLE sont pris en charge.
>ranges[from, to)	>Plages de valeurs utilisées pour le regroupement. >L'intervalle peut commencer à Double.MIN_VALUE et se terminer à Double.MAX_VALUE.
>subAggs and subGroupBys	>Opération de sous-agrégation. Elle s'effectue sur la base des résultats du regroupement. >Par exemple, après avoir regroupé les résultats par volume de ventes et par province, vous pouvez identifier la province représentant la part la plus importante des ventes dans une plage donnée. Pour ce faire, vous devez spécifier une valeur GroupByField dans GroupByRange.

Exemple

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

Groupement par emplacement géographique

Cette méthode d'agrégation permet de regrouper les résultats de requête en fonction de la distance entre des points géographiques et un centre donné. Les résultats dont la distance tombe dans un intervalle spécifique sont consolidés. Le nombre de valeurs contenues dans chaque plage est renvoyé.

Paramètres

>Paramètre	>Description
>name	>Nom unique de l'opération d'agrégation. Vous pouvez interroger les résultats d'une opération d'agrégation spécifique à partir de ce nom.
>fieldName	>Nom du champ utilisé pour l'opération d'agrégation. Seul le type GEOPOINT est pris en charge.
>origin(lat, lon)	>Longitude et latitude du point central. >lat spécifie la latitude du point central. lon spécifie la longitude du point central.
>ranges[from, to)	>Plages de distance utilisées pour le regroupement. Unité : mètres. >La plage de valeurs peut commencer à Double.MIN_VALUE et se terminer à Double.MAX_VALUE.
>subAggs et subGroupBys	>Sous-opération d'agrégation. Vous pouvez exécuter la sous-opération d'agrégation sur la base des résultats de regroupement.

Exemple

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

Regroupement par filtre

Méthode d'agrégation permettant de filtrer les résultats de 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.

Paramètres

>Paramètre	>Description
>name	>Nom unique de l'opération d'agrégation. Vous pouvez interroger les résultats d'une opération d'agrégation spécifique à partir de ce nom.
>filters	>Filtres pouvant être utilisés pour la requête. Les résultats sont renvoyés dans l'ordre de spécification des filtres.
>subAggs et subGroupBys	>Sous-opération d'agrégation. Vous pouvez exécuter la sous-opération d'agrégation sur la base des résultats de regroupement.

Exemple

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

Requête par histogramme

Méthode d'agrégation permettant de regrouper les résultats de requête selon des 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.

Paramètres

Paramètre	Description
name	Nom unique de l'opération d'agrégation. Vous pouvez interroger les résultats d'une opération d'agrégation spécifique à partir 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.
interval	Intervalle de données utilisé pour obtenir les résultats d'agrégation.
fieldRange[min,max]	Plage utilisée conjointement avec le paramètre interval pour limiter le nombre de groupes. `La valeur calculée à l'aide de la formule ne peut pas dépasser 2 000.`
minDocCount	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	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 aucune 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

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

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

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 un champ Nested, Geopoint ou Array. Pour obtenir le champ requis, vous devez interroger la table de données.

Paramètres

>Parameter	>Description
>name	>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	>Nombre maximal de lignes pouvant être renvoyées pour chaque groupe. Par défaut, une seule ligne de données est renvoyée.
>sort	>Méthode de tri utilisée pour trier les données au sein des groupes.
>columnsToGet	>Champs que vous souhaitez renvoyer. Seuls les champs présents dans les 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 du paramètre columnsToGet dans SearchRequest. Il vous suffit de spécifier columnsToGet dans SearchRequest.

Exemple

Un formulaire de candidature à une activité scolaire contient des champs permettant de spécifier des informations telles que les noms des élèves, des classes, des professeurs principaux et des délégués de classe. Vous pouvez regrouper les élèves par classe pour consulter les statistiques de candidature ainsi que les informations de propriété de chaque classe. L'instruction SQL équivalente est 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);
    }
});