Tablestore:Agregação

Retorna o valor mínimo de um campo. Funciona de forma semelhante à função MIN do SQL.

• Parâmetros

  Parâmetro	Descrição
  name	Nome exclusivo da operação de agregação. Use este nome para consultar os resultados de uma operação específica.
  fieldName	Nome do campo usado na agregação. Suporta apenas os tipos LONG, DOUBLE e DATE.
  missing	Valor padrão do campo usado na agregação de uma linha quando o valor do campo está vazio. Se não especificar um valor para missing, a linha será ignorada. Se especificar um valor para missing, esse valor será usado como o valor do campo da linha.

• Exemplo

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

Retorna o valor máximo de um campo. Funciona de forma semelhante à função MAX do SQL.

• Parâmetros

  Parâmetro	Descrição
  name	Nome exclusivo da operação de agregação. Use este nome para consultar os resultados de uma operação específica.
  fieldName	Nome do campo usado na agregação. Suporta apenas os tipos LONG, DOUBLE e DATE.
  missing	Valor padrão do campo usado na agregação de uma linha quando o valor do campo está vazio. Se não especificar um valor para missing, a linha será ignorada. Se especificar um valor para missing, esse valor será usado como o valor do campo da linha.

• Exemplo

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

Retorna a soma de todos os valores de um campo numérico. Funciona de forma semelhante à função SUM do SQL.

• Parâmetros

  Parâmetro	Descrição
  name	Nome exclusivo da operação de agregação. Use este nome para consultar os resultados de uma operação específica.
  fieldName	Nome do campo usado na agregação. Suporta apenas os tipos de dados LONG e DOUBLE.
  missing	Valor padrão do campo usado na agregação de uma linha quando o valor do campo está vazio. Se não especificar um valor para missing, a linha será ignorada. Se especificar um valor para missing, esse valor será usado como o valor do campo da linha.

• Exemplo

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

Retorna a média de todos os valores de um campo numérico. Funciona de forma semelhante à função AVG do SQL.

• Parâmetros

  Parâmetro	Descrição
  name	Nome exclusivo da operação de agregação. Use este nome para consultar os resultados de uma operação específica.
  fieldName	Nome do campo usado na agregação. Suporta apenas os tipos LONG, DOUBLE e DATE.
  missing	Valor padrão do campo usado na agregação de uma linha quando o valor do campo está vazio. Se não especificar um valor para missing, a linha será ignorada. Se especificar um valor para missing, esse valor será usado como o valor do campo da linha.

• Exemplo

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

Retorna o número total de valores de um campo especificado ou o número total de linhas em um índice de pesquisa. Funciona de forma semelhante à função COUNT do SQL.

Nota

Use os seguintes métodos para consultar o número total de linhas em um índice de pesquisa ou o número total de linhas que atendem às condições de consulta:

• Use o recurso de contagem da agregação e especifique count(*) na solicitação.

• Use o recurso de consulta para obter o número de linhas que atendem às condições de consulta. Defina setGetTotalCount como true na consulta. Use MatchAllQuery para obter o número total de linhas em um índice de pesquisa.

Use o nome de uma coluna como valor da expressão de contagem para consultar o número de linhas que contêm essa coluna no índice de pesquisa. Esse método é ideal para cenários com colunas esparsas.

• Parâmetros

  Parâmetro	Descrição
  name	Nome exclusivo da operação de agregação. Use este nome para consultar os resultados de uma operação específica.
  fieldName	Nome do campo usado na agregação. Suporta apenas os tipos LONG, DOUBLE, BOOLEAN, KEYWORD, GEO_POINT e DATE.

• Exemplo

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

Retorna o número de valores distintos de um campo. Funciona de forma semelhante à função COUNT(DISTINCT) do SQL.

Nota

O número de valores distintos é um valor aproximado.

• Se o total de linhas antes da contagem distinta for menor que 10.000, o resultado ficará próximo do valor exato.

• Se o total de linhas for maior ou igual a 100 milhões, a taxa de erro será de aproximadamente 2%.

• Parâmetros

  Parâmetro	Descrição
  name	Nome exclusivo da operação de agregação. Use este nome para consultar os resultados de uma operação específica.
  fieldName	Nome do campo usado na agregação. Suporta apenas os tipos LONG, DOUBLE, BOOLEAN, KEYWORD, GEO_POINT e DATE.
  missing	Valor padrão do campo usado na agregação de uma linha quando o valor do campo está vazio. Se não especificar um valor para missing, a linha será ignorada. Se especificar um valor para missing, esse valor será usado como o valor do campo da linha.

• Exemplo

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

Um valor de percentil indica a posição relativa de um valor em um conjunto de dados. Por exemplo, ao coletar estatísticas sobre o tempo de resposta de cada solicitação durante a O&M de rotina do seu sistema, analise a distribuição do tempo de resposta usando percentis como p25, p50, p90 e p99.

• Parâmetros

  Parâmetro	Descrição
  name	Nome exclusivo da operação de agregação. Use este nome para consultar os resultados de uma operação específica.
  fieldName	Nome do campo usado na agregação. Suporta apenas os tipos LONG, DOUBLE e DATE.
  percentiles	Percentis, como p50, p90 e p99. É possível especificar um ou mais percentis.
  missing	Valor padrão do campo usado na agregação de uma linha quando o valor do campo está vazio. Se não especificar um valor para missing, a linha será ignorada. Se especificar um valor para missing, esse valor será usado como o valor do campo da linha.

• Exemplo

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

Agrupa os resultados da consulta com base nos valores do campo. Valores iguais são agrupados. Retorna o valor de cada grupo e a quantidade de valores idênticos em cada grupo.

Nota

O número calculado pode diferir do número real se a quantidade de valores em um grupo for muito grande.

• Parâmetros

  Parâmetro	Descrição
  name	Nome exclusivo da operação de agregação. Use este nome para consultar os resultados de uma operação específica.
  fieldName	Nome do campo usado na agregação. Suporta apenas os tipos LONG, DOUBLE, BOOLEAN, KEYWORD e DATE.
  sort	Regras de classificação para grupos. Por padrão, os grupos são classificados pela quantidade de itens em ordem decrescente. Se houver várias regras, a classificação segue a ordem de configuração. Regras suportadas: Classificar por valor em ordem alfabética. Classificar por valor em ordem alfabética inversa. Classificar por contagem de linhas em ordem crescente. Classificar por contagem de linhas em ordem decrescente. Classificar pelos valores obtidos dos resultados da subagregação em ordem crescente. Classificar pelos valores obtidos dos resultados da subagregação em ordem decrescente.
  size	Número de grupos a retornar. Valor padrão: 10. Valor máximo: 2000. Se o número de grupos exceder 2.000, apenas os primeiros 2.000 serão retornados.
  subAggs e subGroupBys	Operação de subagregação. Execute a subagregação com base nos resultados do agrupamento. Cenário Consulte a quantidade de products em cada categoria, bem como os preços máximo e mínimo de product em cada categoria. Método Agrupe os resultados da consulta por categoria de product para obter a quantidade de products em cada categoria. Em seguida, execute duas subagregações para obter os preços máximo e mínimo de product em cada categoria. Exemplo: Frutas: 5. O preço máximo é USD 2. O preço mínimo é USD 0.5. Artigos de higiene: 10. O preço máximo é USD 13. O preço mínimo é USD 0.1. Dispositivos eletrônicos: 3. O preço máximo é USD 1.160. O preço mínimo é USD 310. Outros products: 15. O preço máximo é USD 130. O preço mínimo é USD 11.

• Exemplo

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

Agrupa os resultados da consulta com base nos intervalos de valores de um campo. Valores dentro de um intervalo específico são agrupados. Retorna a quantidade de valores em cada intervalo.

• Parâmetros

  Parâmetro	Descrição
  name	Nome exclusivo da operação de agregação. Use este nome para consultar os resultados de uma operação específica.
  fieldName	Nome do campo usado na agregação. Suporta apenas os tipos LONG e DOUBLE.
  ranges[from, to)	Intervalos de valores usados para agrupamento. O intervalo de valores pode começar em Double.MIN_VALUE e terminar em Double.MAX_VALUE.
  subAggs e subGroupBys	Operação de subagregação. Execute a subagregação com base nos resultados do agrupamento. Por exemplo, após agrupar os resultados por volume de vendas e por província, obtenha a província com a maior proporção de volume de vendas em um intervalo especificado. Especifique um valor para GroupByField em GroupByRange para executar essa consulta.

• Exemplo

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

Agrupa os resultados da consulta com base nas distâncias de localizações geográficas até um ponto central. Resultados com distâncias dentro de um intervalo específico são agrupados. Retorna a quantidade de valores em cada intervalo.

• Parâmetros

  Parâmetro	Descrição
  name	Nome exclusivo da operação de agregação. Use este nome para consultar os resultados de uma operação específica.
  fieldName	Nome do campo usado na agregação. Suporta apenas o tipo GEOPOINT.
  origin(lat, lon)	Longitude e latitude do ponto central. lat especifica a latitude e lon especifica a longitude.
  ranges[from, to)	Intervalos de distância usados para agrupamento. Unidade: metros. O intervalo de valores pode começar em Double.MIN_VALUE e terminar em Double.MAX_VALUE.
  subAggs e subGroupBys	Operação de subagregação. Execute a subagregação com base nos resultados do agrupamento.

• Exemplo

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

Filtra os resultados da consulta e os agrupa para obter a quantidade de resultados que correspondem a cada filtro. Os resultados são retornados na ordem em que os filtros são especificados.

• Parâmetros

  Parâmetro	Descrição
  name	Nome exclusivo da operação de agregação. Use este nome para consultar os resultados de uma operação específica.
  filters	Filtros que podem ser usados para a consulta. Os resultados são retornados na ordem em que os filtros são especificados.
  subAggs e subGroupBys	Operação de subagregação. Execute a subagregação com base nos resultados do agrupamento.

• Exemplo

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

Agrupa os resultados da consulta com base em intervalos de dados específicos. Valores dentro do mesmo intervalo são agrupados. Retorna o intervalo de valores de cada grupo e a quantidade de valores em cada grupo.

• Parâmetros

  Parâmetro	Descrição
  name	Nome exclusivo da operação de agregação. Use este nome para consultar os resultados de uma operação específica.
  fieldName	Nome do campo usado na agregação. Suporta apenas os tipos LONG e DOUBLE.
  interval	Intervalo de dados usado para obter resultados de agregação.
  fieldRange[min,max]	Intervalo usado junto com o parâmetro interval para limitar a quantidade de grupos. O valor calculado usando a fórmula não pode exceder 2.000.
  minDocCount	Número mínimo de linhas. Se a quantidade de linhas em um grupo for menor que esse mínimo, os resultados de agregação do grupo não serão retornados.
  missing	Valor padrão do campo usado na agregação de uma linha quando o valor do campo está vazio. Se não especificar um valor para missing, a linha será ignorada. Se especificar um valor para missing, esse valor será usado como o valor do campo da linha.

• Exemplo

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

Consulta as linhas de cada grupo após o agrupamento dos resultados. Funciona de forma semelhante à função ANY_VALUE(field) no MySQL.

• Parâmetros

  Parâmetro	Descrição
  name	Nome exclusivo da operação de agregação. Use este nome para consultar os resultados de uma operação específica.
  limit	Número máximo de linhas a retornar para cada grupo. Por padrão, apenas uma linha de dados é retornada.
  sort	Método de classificação usado para classificar dados em grupos.
  columnsToGet	Campos a retornar. Suporta apenas campos em índices de pesquisa. Campos ARRAY, DATE, GEOPOINT e NESTED não são suportados. O valor deste parâmetro é igual ao valor de columnsToGet em SearchRequest. Especifique apenas columnsToGet em SearchRequest.

• Exemplo

  Um formulário de inscrição para atividades de uma escola contém campos que armazenam informações como nomes de alunos, turmas, professores titulares e representantes de turma. Agrupar os alunos por turma permite visualizar as estatísticas de inscrição e as propriedades de cada turma. A instrução SQL equivalente é 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);
      }
  });