Tablestore:Sorting and paging

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

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

PrimaryKeySort

Ordena os resultados pela chave primária.

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 ordenar os resultados por um ou mais valores de coluna.

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

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

GeoDistanceSort

Ordena os resultados pela distância de um ponto geográfico.

Use o GeoDistanceSort para ordenar 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.

Configure os parâmetros limit e offset

Caso não defina os parâmetros limit e offset, o valor padrão de limit será 10 e o de offset será 0.

Use offset e limit para acessar diretamente qualquer página. Esse 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));
});

Use um token

A paginação baseada em token é recomendada para paginação profunda por não ter limite de profundidade.

Se uma resposta não contiver todos os dados correspondentes, o servidor retorna um nextToken.

Por padrão, a paginação baseada em token permite apenas avançar pelos resultados. No entanto, como o token permanece válido durante todo o processo de consulta, armazene um token anterior em cache para paginar para trás.

A paginação baseada em token retorna os resultados página por página usando um cursor (NextToken). Cada resposta inclui um token para a próxima página. Os tokens são válidos durante a consulta; portanto, armazene um token anterior em cache para navegar de volta a uma página anterior.

Ao paginar com um token, a ordem de classificação é a mesma da solicitação anterior, seja com o IndexSort padrão ou uma ordenação personalizada. Portanto, não defina um parâmetro Sort ao usar um token. Também não defina um offset, pois a leitura dos dados ocorre apenas de forma sequencial.

Os exemplos a seguir mostram a paginação baseada em token 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));
        });
    }
});