Tablestore:Agrégation

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

• 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 en utilisant 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 l'opération d'agrégation sur 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: "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);
      }
  });

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

• 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 en utilisant 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 l'opération d'agrégation sur 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: "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);
      }
  });

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

• 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 en utilisant 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 du champ utilisé pour l'opération d'agrégation sur 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: "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);
      }
  });

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

• 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 en utilisant 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 l'opération d'agrégation sur 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: "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);
      }
  });

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 fonctionne 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 répondant aux conditions de 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 répondant aux conditions de 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 cette colonne dans un index de recherche. Cette méthode convient aux scénarios impliquant des colonnes clairsemées.

• 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 en utilisant 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

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

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

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

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

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 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 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.
  percentiles	Percentiles tels que p50, p90 et p99. Vous pouvez spécifier un ou plusieurs percentiles.
  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

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

Méthode d'agrégation permettant de regrouper les résultats de requête en fonction des valeurs d'un champ. Les valeurs identiques sont regroupées ensemble. La valeur commune à chaque groupe ainsi que le nombre de valeurs identiques dans ce 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
  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, BOOLEAN, KEYWORD et DATE sont pris en charge.
  sort	Règles de tri des groupes. Par défaut, les groupes sont triés selon le nombre d'éléments qu'ils contiennent, par ordre décroissant. Si vous configurez plusieurs règles de tri, les groupes sont triés selon l'ordre de configuration des règles. Règles de tri prises en charge : Tri par valeur dans l'ordre alphabétique. Tri par valeur dans l'ordre alphabétique inverse. Tri par nombre de lignes dans l'ordre croissant. Tri par nombre de lignes dans l'ordre décroissant. Tri par les valeurs obtenues à partir des résultats de sous-agrégation dans l'ordre croissant. Tri par les valeurs obtenues à partir des résultats de sous-agrégation dans l'ordre décroissant.
  size	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.
  subAggs and subGroupBys	Opération de sous-agrégation. Vous pouvez effectuer une sous-agrégation en vous basant sur les résultats du groupement. 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éthode Groupez 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 : 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

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

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 regroupées ensemble. Le nombre de valeurs dans chaque plage est renvoyé.

• 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 et DOUBLE sont pris en charge.
  ranges[from, to)	Plages de valeurs utilisées pour le groupement. La plage de valeurs peut commencer à Double.MIN_VALUE et se terminer à Double.MAX_VALUE.
  subAggs and subGroupBys	Opération de sous-agrégation. Vous pouvez effectuer une sous-agrégation en vous basant sur les résultats du groupement. Par exemple, après avoir groupé les résultats de la requête par volume de ventes et par province, vous pouvez obtenir la province qui présente la plus grande proportion de 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

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

Méthode d'agrégation permettant de regrouper les résultats de requête en fonction des distances entre des emplacements géographiques et 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
  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 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 groupement. Unité : mètres. La plage de valeurs peut commencer à Double.MIN_VALUE et se terminer à Double.MAX_VALUE.
  subAggs and subGroupBys	Opération de sous-agrégation. Vous pouvez effectuer une sous-agrégation en vous basant sur les résultats du groupement.

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

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

  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.
  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 and subGroupBys	Opération de sous-agrégation. Vous pouvez effectuer une sous-agrégation en vous basant sur les résultats du groupement.

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

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 regroupées ensemble. La plage de valeurs de chaque groupe ainsi que le nombre de valeurs dans chaque groupe sont renvoyés.

• 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 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. The value that is calculated by using the formula cannot exceed 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 pour le 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

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

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(field) dans MySQL.

• 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.
  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 dans les 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 de columnsToGet dans SearchRequest. Il vous suffit de spécifier columnsToGet dans SearchRequest.

• Exemple

  Un formulaire de demande d'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 grouper les élèves par classe pour afficher les statistiques de candidature et 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);
      }
  });