पेजिनेशन बड़े डेटासेट के साथ काम करते समय किसी भी डेटाबेस ऑपरेशन का एक महत्वपूर्ण हिस्सा है। यह आपको डेटा को प्रबंधनीय टुकड़ों में विभाजित करने की अनुमति देता है, जिससे ब्राउज़ करना, संसाधित करना और प्रदर्शित करना आसान हो जाता है। MongoDB दो सामान्य पृष्ठांकन विधियाँ प्रदान करता है: ऑफ़सेट-आधारित और कर्सर-आधारित। हालाँकि दोनों विधियाँ एक ही उद्देश्य को पूरा करती हैं, वे प्रदर्शन और प्रयोज्यता में काफी भिन्न हैं, खासकर जैसे-जैसे डेटासेट बढ़ता है।

आइए दो दृष्टिकोणों पर गौर करें और देखें कि क्यों कर्सर-आधारित पेजिनेशन अक्सर ऑफसेट-आधारित पेजिनेशन से बेहतर प्रदर्शन करता है।

1. ऑफ़सेट-आधारित पेजिनेशन

ऑफ़सेट-आधारित पृष्ठांकन सीधा है। यह किसी दिए गए ऑफसेट से शुरू होकर विशिष्ट संख्या में रिकॉर्ड पुनर्प्राप्त करता है। उदाहरण के लिए, पहला पृष्ठ 0-9 रिकॉर्ड पुनर्प्राप्त कर सकता है, दूसरा पृष्ठ 10-19 रिकॉर्ड पुनर्प्राप्त कर सकता है, इत्यादि।

हालाँकि, इस विधि में एक महत्वपूर्ण खामी है: जैसे-जैसे आप उच्च पृष्ठों पर जाते हैं, क्वेरी धीमी हो जाती है। ऐसा इसलिए है क्योंकि डेटाबेस को पिछले पृष्ठों के रिकॉर्ड को छोड़ना पड़ता है, जिसमें उन्हें स्कैन करना शामिल है।

यहां ऑफसेट-आधारित पेजिनेशन के लिए कोड है:

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. कर्सर-आधारित पेजिनेशन

कर्सर-आधारित पेजिनेशन, जिसे कीसेट पेजिनेशन के रूप में भी जाना जाता है, रिकॉर्ड के माध्यम से पेजिनेट करने के लिए एक अद्वितीय पहचानकर्ता (उदाहरण के लिए, एक आईडी या टाइमस्टैम्प) पर निर्भर करता है। एक निश्चित संख्या में रिकॉर्ड को छोड़ने के बजाय, यह अगले सेट को लाने के लिए संदर्भ बिंदु के रूप में अंतिम पुनर्प्राप्त रिकॉर्ड का उपयोग करता है।

यह दृष्टिकोण अधिक कुशल है क्योंकि यह वर्तमान पृष्ठ से पहले रिकॉर्ड को स्कैन करने की आवश्यकता से बचाता है। परिणामस्वरूप, क्वेरी का समय सुसंगत रहता है, भले ही आप डेटासेट में कितनी भी गहराई तक जाएँ।

यहां कर्सर-आधारित पृष्ठांकन के लिए कोड है:

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

इस उदाहरण में, lastDocumentId पिछले पृष्ठ के अंतिम दस्तावेज़ की आईडी है। अगले पृष्ठ के लिए क्वेरी करते समय, डेटाबेस इस मान से अधिक आईडी वाले दस्तावेज़ लाता है, जिससे रिकॉर्ड के अगले सेट में निर्बाध संक्रमण सुनिश्चित होता है।

3. प्रदर्शन तुलना

आइए देखें कि ये दोनों विधियां बड़े डेटासेट के साथ कैसा प्रदर्शन करती हैं।

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

प्रदर्शन परीक्षण में, आप देखेंगे कि ऑफ़सेट-आधारित पृष्ठांकन में लंबा लगता है क्योंकि पृष्ठ संख्या बढ़ती है, जबकि कर्सर -आधारित पेजिनेशन सुसंगत रहता है, जो इसे बड़े डेटासेट के लिए बेहतर विकल्प बनाता है। यह उदाहरण अनुक्रमणिका की शक्ति को भी प्रदर्शित करता है। अनुक्रमणिका को हटाने का प्रयास करें और फिर परिणाम भी देखें!

अनुक्रमण क्यों महत्वपूर्ण है

किसी इंडेक्स के बिना, MongoDB को एक संग्रह स्कैन करने की आवश्यकता होगी, जिसका अर्थ है कि उसे प्रासंगिक डेटा ढूंढने के लिए संग्रह में प्रत्येक दस्तावेज़ को देखना होगा। यह अप्रभावी है, खासकर जब आपका डेटासेट बढ़ता है। इंडेक्स MongoDB को आपकी क्वेरी शर्तों से मेल खाने वाले दस्तावेज़ों को कुशलतापूर्वक ढूंढने की अनुमति देते हैं, जिससे क्वेरी प्रदर्शन में काफी तेजी आती है।

कर्सर-आधारित पेजिनेशन के संदर्भ में, सूचकांक यह सुनिश्चित करता है कि दस्तावेज़ों का अगला सेट (डॉक्यूमेंट आईडी के आधार पर) प्राप्त करना त्वरित है और प्रदर्शन में गिरावट नहीं होती है क्योंकि संग्रह में अधिक दस्तावेज़ जोड़े जाते हैं।

निष्कर्ष

हालांकि ऑफसेट-आधारित पेजिनेशन को लागू करना आसान है, लेकिन रिकॉर्ड के माध्यम से स्कैन करने की आवश्यकता के कारण यह बड़े डेटासेट के साथ अक्षम हो सकता है। दूसरी ओर, कर्सर-आधारित पेजिनेशन, डेटासेट आकार की परवाह किए बिना प्रदर्शन को सुसंगत रखते हुए, अधिक स्केलेबल समाधान प्रदान करता है। यदि आप MongoDB में बड़े संग्रह के साथ काम कर रहे हैं, तो बेहतर और तेज़ अनुभव के लिए कर्सर-आधारित पेजिनेशन पर विचार करना उचित है।

यहां आपके लिए स्थानीय रूप से चलाने के लिए संपूर्ण Index.js है:

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