Perform sorting and paging by using Tablestore SDK for Node.js - Tablestore: Central de Documentação do Alibaba Cloud

Ao consultar dados com um índice de busca, aplique uma ordem de classificação predefinida ou especifique uma no momento da consulta. Para navegar por grandes conjuntos de resultados, use limit/offset para paginação baseada em deslocamento ou tokens para paginação baseada em cursor.

Cenários

Categoria	Método	Recurso	Cenário
Ordenação	Predefinir um método de ordenação ao criar um índice de busca	Pré-ordenação de índice (IndexSort)	Por padrão, os resultados retornam na ordem definida pelo parâmetro IndexSort durante a criação do índice.
	Especificar um método de ordenação ao consultar dados	Ordenação baseada na pontuação de relevância de palavras-chave BM25 (ScoreSort)	Classifica os resultados pela pontuação de relevância BM25. Ideal para buscas de texto completo.
		Ordenação baseada no valor da chave primária (PrimaryKeySort)	Organiza os resultados pelo valor da chave primária. Útil para ordenar por identificadores únicos de linha.
		Ordenação baseada nos valores de uma ou mais colunas (FieldSort)	Ordena os resultados por valores de colunas, como volume de vendas ou visualizações de página. Comum em e-commerce, redes sociais e gestão de ativos de mídia.
		Ordenação por localização geográfica (GeoDistanceSort)	Classifica os resultados pela distância de um ponto central. Frequentemente usado em mapas e logística — por exemplo, para ordenar restaurantes próximos por distância.
Paginação	Especificar um método de paginação ao consultar dados	Paginação baseada nos parâmetros limit e offset	Salta para qualquer página quando o conjunto de resultados contém menos de 100.000 linhas.
Paginação	Especificar um método de paginação ao consultar dados	Paginação baseada em tokens	Percorre os resultados sequencialmente usando um cursor; a navegação ocorre apenas para frente. Os tokens permanecem válidos durante a consulta, permitindo armazenar em cache um token anterior para retornar a uma página prévia.

Pré-ordenação de índice

Por padrão, o Tablestore organiza os dados em um índice de busca com base em uma ordem predefinida, chamada de pré-ordenação de índice (IndexSort). Durante a consulta de dados, o IndexSort determina a ordem padrão dos resultados retornados.

Ao criar um índice de busca, personalize o IndexSort. Caso essa configuração não seja especificada, o índice adota a ordenação por chave primária como padrão.

Importante

A pré-ordenação de índice suporta apenas PrimaryKeySort (ordenação por chave primária) e FieldSort (ordenação por campo).
Não use a pré-ordenação de índice em um índice de busca que contenha campos do tipo aninhado (nested).
Após a criação do índice de busca, o recurso de modificação dinâmica de esquema permite alterar as configurações de IndexSort.

Especificar um método de ordenação

A ordenação exige que enableSortAndAgg esteja definido como true nos campos pelos quais você deseja ordenar.

ScoreSort

Classifica os resultados da consulta pela pontuação de relevância, calculada pelo algoritmo BM25. Este método é adequado para cenários baseados em relevância, como buscas de texto completo.

Importante

Para ordenar por pontuação de relevância, especifique explicitamente ScoreSort. Caso contrário, o Tablestore organizará os resultados conforme as configurações de IndexSort do índice.
Ao usar ScoreSort, campos do tipo FuzzyKeyword não são incluídos na ordenação, e o parâmetro weight não tem efeito sobre esses campos.

Use o ScoreSort para classificar os resultados pela pontuação de relevância BM25, em ordem crescente ou decrescente.

sort: {
    sorters: [
        {
            scoreSort: {
                order: TableStore.SortOrder.SORT_ORDER_ASC
            }
        }
    ]
}

PrimaryKeySort

Use o PrimaryKeySort para ordenar os resultados pelo valor da chave primária.

sort: {
    sorters: [
        {
            primaryKeySort: {
                order: TableStore.SortOrder.SORT_ORDER_DESC // Sort in descending order.
                //order: TableStore.SortOrder.SORT_ORDER_ASC // Sort in ascending order.
            }
        }
    ]
}

FieldSort

Use o FieldSort para organizar os resultados com base nos valores de uma ou mais colunas.

Ordenar por uma única coluna

sort: {
    sorters: [
        {
            fieldSort: {
                fieldName: "Col_Keyword",
                order: TableStore.SortOrder.SORT_ORDER_DESC
            }
        }
    ]
}

Ordenar por múltiplas colunas

Especifique vários ordenadores para classificar primeiramente por uma coluna principal e, em seguida, desempatar usando uma coluna secundária.

sort: {
    sorters: [
        {
            fieldSort: {
                fieldName: "Col_Keyword",
                order: TableStore.SortOrder.SORT_ORDER_DESC
            }
        },
        {
            fieldSort: {
                fieldName: "Col_Long",
                order: TableStore.SortOrder.SORT_ORDER_DESC
            }
        }
    ]
}

GeoDistanceSort

Use o GeoDistanceSort para classificar os resultados pela distância de um ponto geográfico central.

sort: {
    sorters: [
        {
            geoDistanceSort: {
                fieldName: "Col_Geo_Point",
                points: ["0,0"],// Specify the coordinate pair of the central point.
                order: TableStore.SortOrder.SORT_ORDER_ASC // Return results in ascending order of distance.
            }
        }
    ]
}

Para um exemplo completo, consulte Search no GitHub.

Especificar um método de paginação

Configurar os parâmetros limit e offset

Paginação baseada em deslocamento

Use a paginação baseada em deslocamento (offset) quando o número total de linhas a recuperar for inferior a 100.000. A soma de limit e offset deve ser menor ou igual a 100.000, e o valor máximo para limit é 100.

Nota

Para aumentar o limiar de limit, consulte Como aumento o limite da Search API para 1.000?.

Use offset e limit para saltar diretamente para qualquer página. Este método suporta conjuntos de resultados de até 100.000 linhas.

/**
 * Set offset to 90 and limit to 10 to retrieve rows 90–99.
 */
client.search({
    tableName: TABLE_NAME,
    indexName: INDEX_NAME,
    searchQuery: {
        offset: 90,
        limit: 10,
        query: {
            queryType: TableStore.QueryType.MATCH_ALL_QUERY
        },
        getTotalCount: true // Return the total number of matching rows. Default: false.
    },
    columnToGet: {
        // RETURN_ALL: return all columns.
        // RETURN_SPECIFIED: return specified columns.
        // RETURN_NONE: return primary key columns only.
        returnType: TableStore.ColumnReturnType.RETURN_ALL
    }
}, function (err, data) {
    if (err) {
        console.log('error:', err);
        return;
    }
    console.log('success:', JSON.stringify(data, null, 2));
});

Usar um token

A paginação baseada em tokens retorna resultados página a página usando um cursor (NextToken). Cada resposta inclui um token para a próxima página. Como os tokens permanecem válidos durante toda a consulta, armazene em cache um token anterior para navegar de volta a uma página específica.

Importante

Para persistir ou passar o NextToken para uma página frontend, codifique-o como uma string Base64. Os tokens são dados binários (fluxo de bytes), não strings — o uso de string(NextToken) causa perda de dados. Faça a conversão usando Buffer:

Codificação: data.nextToken.toString("base64")
Decodificação: Buffer.from(base64String, "base64")

Importante

Um índice de busca contendo um campo do tipo aninhado (nested) não suporta pré-ordenação de índice. Se for necessário paginar resultados desse índice, especifique uma ordem de classificação na consulta. Caso contrário, o servidor não retornará um nextToken, mesmo que haja mais dados disponíveis.

Os exemplos a seguir demonstram a paginação baseada em tokens nos modos síncrono e assíncrono. Ambos usam o mesmo objeto params inicial.

var params = {
    tableName: TABLE_NAME,
    indexName: INDEX_NAME,
    searchQuery: {
        offset: 0,
        limit: 10,
        token: null, // Set to nextToken from the previous response to fetch the next page.
        query: {
            queryType: TableStore.QueryType.MATCH_ALL_QUERY
        },
        getTotalCount: true
    },
    columnToGet: {
        returnType: TableStore.ColumnReturnType.RETURN_SPECIFIED,
        returnNames: ["pic_tag", "pic_description", "time_stemp", "pos"]
    }
};

/**
 * Synchronous mode: await each page before fetching the next.
 */
(async () => {
  try {
    var data = await client.search(params);
    console.log('success:', JSON.stringify(data, null, 2));

    while (data.nextToken && data.nextToken.length) {
      // Encode the binary token as Base64 for storage or transfer,
      // then decode it back to binary before passing it as the next token.
      var nextToken = data.nextToken.toString("base64");
      var token = Buffer.from(nextToken, "base64");

      params.searchQuery.token = token;
      data = await client.search(params);
      console.log('token success:', JSON.stringify(data, null, 2));
    }
  } catch (error) {
      console.log(error);
  }
})()

/**
 * Asynchronous mode: use callbacks to fetch the next page.
 */
client.search(params, function (err, data) {
    console.log('success:', JSON.stringify(data, null, 2));

    if (data.nextToken && data.nextToken.length) {
        // Encode and decode the token the same way as in synchronous mode.
        var nextToken = data.nextToken.toString("base64");
        var token = Buffer.from(nextToken, "base64");

        params.searchQuery.token = token;
        client.search(params, function (err, data) {
            console.log('token success:', JSON.stringify(data, null, 2));
        });
    }
});