La

La pagination est un élément essentiel de toute opération de base de données lorsqu'il s'agit de grands ensembles de données. Il vous permet de diviser les données en morceaux gérables, ce qui facilite la navigation, le traitement et l'affichage. MongoDB propose deux méthodes de pagination courantes : basée sur le décalage et basée sur le curseur. Bien que les deux méthodes servent le même objectif, elles diffèrent considérablement en termes de performances et de convivialité, en particulier à mesure que l'ensemble de données s'agrandit.

Plongeons dans les deux approches et voyons pourquoi la pagination basée sur le curseur surpasse souvent la pagination basée sur le décalage.

1. Pagination basée sur le décalage

La pagination basée sur le décalage est simple. Il récupère un nombre spécifique d'enregistrements à partir d'un décalage donné. Par exemple, la première page peut récupérer les enregistrements 0 à 9, la deuxième page, les enregistrements 10 à 19, et ainsi de suite.

Cependant, cette méthode présente un inconvénient important : à mesure que vous accédez à des pages supérieures, la requête devient plus lente. En effet, la base de données doit ignorer les enregistrements des pages précédentes, ce qui implique de les parcourir.

Voici le code pour la pagination basée sur le décalage :

async function offset_based_pagination(params) {
  const { page = 5, limit = 100 } = params;
  const skip = (page - 1) * limit;
  const results = await collection.find({}).skip(skip).limit(limit).toArray();
  console.log(`Offset-based pagination (Page ${page}):`, results.length, "page", page, "skip", skip, "limit", limit);
}

2. Pagination basée sur le curseur

La pagination basée sur le curseur, également connue sous le nom de pagination par jeu de clés, repose sur un identifiant unique (par exemple, un identifiant ou un horodatage) pour paginer dans les enregistrements. Au lieu de sauter un certain nombre d'enregistrements, il utilise le dernier enregistrement récupéré comme point de référence pour récupérer l'ensemble suivant.

Cette approche est plus efficace car elle évite d'avoir à analyser les enregistrements avant la page actuelle. Par conséquent, le temps de requête reste cohérent, quelle que soit la profondeur à laquelle vous pénétrez dans l'ensemble de données.

Voici le code pour la pagination basée sur le curseur :

async function cursor_based_pagination(params) {
  const { lastDocumentId, limit = 100 } = params;
  const query = lastDocumentId ? { documentId: { $gt: lastDocumentId } } : {};
  const results = await collection
    .find(query)
    .sort({ documentId: 1 })
    .limit(limit)
    .toArray();
  console.log("Cursor-based pagination:", results.length);
}

Dans cet exemple, lastDocumentId est l'ID du dernier document de la page précédente. Lors de l'interrogation de la page suivante, la base de données récupère les documents dont l'ID est supérieur à cette valeur, garantissant ainsi une transition transparente vers l'ensemble d'enregistrements suivant.

3. Comparaison des performances

Voyons comment ces deux méthodes fonctionnent avec un grand ensemble de données.

async function testMongoDB() {
    console.time("MongoDB Insert Time:");
    await insertMongoDBRecords();
    console.timeEnd("MongoDB Insert Time:");

  // Create an index on the documentId field
  await collection.createIndex({ documentId: 1 });
  console.log("Index created on documentId field");

  console.time("Offset-based pagination Time:");
  await offset_based_pagination({ page: 2, limit: 250000 });
  console.timeEnd("Offset-based pagination Time:");

  console.time("Cursor-based pagination Time:");
  await cursor_based_pagination({ lastDocumentId: 170000, limit: 250000 });
  console.timeEnd("Cursor-based pagination Time:");

  await client.close();
}

Dans le test de performances, vous remarquerez que la pagination basée sur le décalage prend plus de temps à mesure que le numéro de page augmente, alors que le curseur La pagination basée sur reste cohérente, ce qui en fait le meilleur choix pour les grands ensembles de données. Cet exemple démontre également la puissance de l’indexation. Essayez de supprimer l'index, puis voyez également le résultat !

Pourquoi l'indexation est importante

Sans index, MongoDB devrait effectuer une analyse de collection, ce qui signifie qu'il doit examiner chaque document de la collection pour trouver les données pertinentes. Ceci est inefficace, surtout lorsque votre ensemble de données augmente. Les index permettent à MongoDB de trouver efficacement les documents qui correspondent aux conditions de votre requête, accélérant ainsi considérablement les performances des requêtes.

Dans le contexte de la pagination basée sur le curseur, l'index garantit que la récupération de l'ensemble de documents suivant (en fonction de l'ID document) est rapide et ne se dégrade pas en termes de performances à mesure que d'autres documents sont ajoutés à la collection.

Conclusion

Bien que la pagination basée sur l'offset soit facile à mettre en œuvre, elle peut devenir inefficace avec de grands ensembles de données en raison de la nécessité de parcourir les enregistrements. La pagination basée sur le curseur, en revanche, fournit une solution plus évolutive, garantissant des performances cohérentes quelle que soit la taille de l'ensemble de données. Si vous travaillez avec de grandes collections dans MongoDB, cela vaut la peine d'envisager une pagination basée sur le curseur pour une expérience plus fluide et plus rapide.

Voici index.js complet à exécuter localement :

const { MongoClient } = require("mongodb");
const uri = "mongodb://localhost:27017";
const client = new MongoClient(uri);
client.connect();
const db = client.db("testdb");
const collection = db.collection("testCollection");

async function insertMongoDBRecords() {
  try {
    let bulkOps = [];

    for (let i = 0; i  0) {
      await collection.bulkWrite(bulkOps);
      console.log("? Inserted records till now -> ", bulkOps.length);
    }

    console.log("MongoDB Insertion Completed");
  } catch (err) {
    console.error("Error in inserting records", err);
  }
}

async function offset_based_pagination(params) {
  const { page = 5, limit = 100 } = params;
  const skip = (page - 1) * limit;
  const results = await collection.find({}).skip(skip).limit(limit).toArray();
  console.log(`Offset-based pagination (Page ${page}):`, results.length, "page", page, "skip", skip, "limit", limit);
}

async function cursor_based_pagination(params) {
  const { lastDocumentId, limit = 100 } = params;
  const query = lastDocumentId ? { documentId: { $gt: lastDocumentId } } : {};
  const results = await collection
    .find(query)
    .sort({ documentId: 1 })
    .limit(limit)
    .toArray();
  console.log("Cursor-based pagination:", results.length);
}

async function testMongoDB() {
  console.time("MongoDB Insert Time:");
  await insertMongoDBRecords();
  console.timeEnd("MongoDB Insert Time:");

  // Create an index on the documentId field
  await collection.createIndex({ documentId: 1 });
  console.log("Index created on documentId field");

  console.time("Offset-based pagination Time:");
  await offset_based_pagination({ page: 2, limit: 250000 });
  console.timeEnd("Offset-based pagination Time:");

  console.time("Cursor-based pagination Time:");
  await cursor_based_pagination({ lastDocumentId: 170000, limit: 250000 });
  console.timeEnd("Cursor-based pagination Time:");

  await client.close();
}

testMongoDB();