Effectuer le tri et la pagination à l'aide du SDK Tablestore pour Node.js - Tablestore

Lors de l'interrogation des données avec un index de recherche, appliquez un ordre de tri prédéfini ou spécifiez-en un au moment de la requête. Pour parcourir de grands ensembles de résultats, utilisez les paramètres limit/offset pour une pagination par décalage, ou des jetons pour une pagination par curseur.

Scénarios

Catégorie	Méthode	Fonctionnalité	Scénario
Tri	Prédéfinir une méthode de tri lors de la création d'un index de recherche	Pré-tri d'index (IndexSort)	Par défaut, les résultats sont renvoyés selon l'ordre défini par le paramètre IndexSort configuré lors de la création de l'index.
	Spécifier une méthode de tri lors de l'interrogation des données	Tri basé sur le score de pertinence des mots-clés selon l'algorithme BM25 (ScoreSort)	Triez les résultats par score de pertinence BM25. Idéal pour la recherche en texte intégral.
		Tri basé sur la valeur de la clé primaire (PrimaryKeySort)	Triez les résultats par valeur de clé primaire. Utile pour ordonner les résultats par identifiants de ligne uniques.
		Tri basé sur les valeurs d'une ou plusieurs colonnes (FieldSort)	Triez les résultats selon les valeurs d'une ou plusieurs colonnes, telles que le volume des ventes ou le nombre de pages vues. Couramment utilisé dans le e-commerce, les réseaux sociaux et la gestion des actifs multimédias.
		Tri par emplacement géographique (GeoDistanceSort)	Triez les résultats par distance par rapport à un point central. Fréquemment utilisé dans la cartographie et la logistique, par exemple pour classer les restaurants proches par distance.
Pagination	Spécifier une méthode de pagination lors de l'interrogation des données	Pagination basée sur les paramètres limit et offset	Accédez directement à n'importe quelle page lorsque l'ensemble de résultats contient moins de 100 000 lignes.
Pagination		Pagination basée sur des jetons	Parcourez les résultats séquentiellement à l'aide d'un curseur ; vous ne pouvez avancer que vers les pages suivantes. Les jetons restent valides pendant toute la durée de la requête, ce qui permet de mettre en cache un jeton précédent pour revenir à une page antérieure.

Pré-tri d'index

Par défaut, Tablestore trie les données d'un index de recherche selon un ordre prédéfini, appelé pré-tri d'index (IndexSort). Lors de l'interrogation des données, IndexSort détermine l'ordre par défaut des résultats renvoyés.

Lors de la création d'un index de recherche, personnalisez IndexSort. Si vous ne spécifiez pas ce paramètre, l'index utilise par défaut le tri par clé primaire.

Important

Le pré-tri d'index prend uniquement en charge PrimaryKeySort (tri par clé primaire) et FieldSort (tri par champ).
Vous ne pouvez pas utiliser le pré-tri d'index pour un index de recherche contenant des champs de type imbriqué.
Après la création d'un index de recherche, la fonctionnalité modification dynamique du schéma vous permet de modifier les paramètres IndexSort.

Spécifier une méthode de tri

Pour activer le tri, définissez le paramètre enableSortAndAgg sur true pour les champs concernés.

ScoreSort

Cette méthode classe les résultats de la requête par score de pertinence, calculé à l'aide de l'algorithme BM25. Elle convient aux scénarios basés sur la pertinence, tels que la recherche en texte intégral.

Important

Pour trier par score de pertinence, spécifiez explicitement ScoreSort. Sinon, Tablestore trie les résultats selon les paramètres IndexSort de l'index.
Lorsque vous utilisez ScoreSort, les champs de type FuzzyKeyword ne sont pas inclus dans le tri et le paramètre weight n'a aucun effet sur ces champs.

Utilisez ScoreSort pour classer les résultats par score de pertinence BM25, par ordre croissant ou décroissant.

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

PrimaryKeySort

Utilisez PrimaryKeySort pour ordonner les résultats par valeur de clé primaire.

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

FieldSort

Utilisez FieldSort pour trier les résultats selon les valeurs d'une ou plusieurs colonnes.

Tri par une seule colonne

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

Tri par plusieurs colonnes

Spécifiez plusieurs critères de tri pour trier d'abord par une colonne principale, puis départager les égalités à l'aide d'une colonne secondaire.

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

GeoDistanceSort

Utilisez GeoDistanceSort pour classer les résultats par distance par rapport à un point géographique 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.
            }
        }
    ]
}

Pour un exemple complet, consultez Search sur GitHub.

Spécifier une méthode de pagination

Configurer les paramètres limit et offset

Pagination basée sur le décalage

Utilisez la pagination par décalage lorsque le nombre total de lignes à récupérer est inférieur à 100 000. La somme des paramètres limit et offset doit être inférieure ou égale à 100 000, et la valeur maximale pour limit est de 100.

Remarque

Pour augmenter le seuil du paramètre limit, consultez la rubrique Comment augmenter la limite de l'API Search à 1 000 ?.

Utilisez les paramètres offset et limit pour accéder directement à n'importe quelle page. Cette méthode prend en charge des ensembles de résultats pouvant contenir jusqu'à 100 000 lignes.

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

Utiliser un jeton

La pagination par jetons renvoie les résultats page par page à l'aide d'un curseur (NextToken). Chaque réponse inclut un jeton pour la page suivante. Les jetons restent valides pendant toute la durée de la requête, ce qui permet de mettre en cache un jeton précédent pour naviguer vers une page antérieure.

Important

Pour persister ou transmettre NextToken à une interface frontend, encodez-le sous forme de chaîne Base64. Les jetons sont des données binaires (flux d'octets), et non des chaînes de caractères ; l'utilisation de string(NextToken) entraîne une perte de données. Effectuez la conversion à l'aide de Buffer :

Encodage : data.nextToken.toString("base64")
Décodage : Buffer.from(base64String, "base64")

Important

Un index de recherche contenant un champ de type imbriqué ne prend pas en charge le pré-tri d'index. Si vous devez paginer les résultats d'un tel index, spécifiez un ordre de tri dans la requête. Sinon, le serveur ne renvoie pas de nextToken, même si d'autres données sont disponibles.

Les exemples suivants illustrent la pagination par jetons en modes synchrone et asynchrone. Les deux utilisent le même objet params initial.

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