Melancarkan MongoDB: Mengapa Penomboran Berasaskan Kursor Mengungguli Penomboran Berasaskan Offset Setiap Kali!

Penomboran ialah bahagian penting dalam mana-mana operasi pangkalan data apabila berurusan dengan set data yang besar. Ia membolehkan anda membahagikan data kepada bahagian yang boleh diurus, menjadikannya lebih mudah untuk menyemak imbas, memproses dan memaparkan. MongoDB menyediakan dua kaedah penomboran biasa: berasaskan offset dan berasaskan kursor. Walaupun kedua-dua kaedah mempunyai tujuan yang sama, ia berbeza dengan ketara dalam prestasi dan kebolehgunaan, terutamanya apabila set data berkembang.

Mari kita menyelami dua pendekatan dan lihat sebab penomboran berasaskan kursor sering mengatasi prestasi penomboran berasaskan offset.

1. Penomboran Berasaskan Offset

Penomboran berasaskan offset adalah mudah. Ia mendapatkan semula bilangan rekod tertentu bermula daripada offset yang diberikan. Sebagai contoh, halaman pertama mungkin mendapatkan semula rekod 0-9, halaman kedua mendapatkan semula rekod 10-19 dan seterusnya.

Walau bagaimanapun, kaedah ini mempunyai kelemahan yang ketara: apabila anda beralih ke halaman yang lebih tinggi, pertanyaan menjadi lebih perlahan. Ini kerana pangkalan data perlu melangkau rekod dari halaman sebelumnya, yang melibatkan pengimbasan melaluinya.

Berikut ialah kod untuk penomboran berasaskan offset:

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. Penomboran Berasaskan Kursor

Penomboran berasaskan kursor, juga dikenali sebagai penomboran set kekunci, bergantung pada pengecam unik (cth., ID atau cap masa) untuk menomborkan melalui rekod. Daripada melangkau bilangan rekod tertentu, ia menggunakan rekod yang diambil terakhir sebagai titik rujukan untuk mengambil set seterusnya.

Pendekatan ini lebih cekap kerana ia mengelakkan keperluan untuk mengimbas rekod sebelum halaman semasa. Akibatnya, masa pertanyaan kekal konsisten, tidak kira sejauh mana ke dalam set data yang anda gunakan.

Berikut ialah kod untuk penomboran berasaskan kursor:

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

Dalam contoh ini, lastDocumentId ialah ID dokumen terakhir dari halaman sebelumnya. Apabila membuat pertanyaan untuk halaman seterusnya, pangkalan data mengambil dokumen dengan ID yang lebih besar daripada nilai ini, memastikan peralihan yang lancar ke set rekod seterusnya.

3. Perbandingan Prestasi

Mari kita lihat prestasi kedua-dua kaedah ini dengan set data yang besar.

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

Dalam ujian prestasi, anda akan mendapati bahawa penomboran berasaskan offset mengambil masa lebih lama apabila nombor halaman meningkat, manakala kursor -based penomboran kekal konsisten, menjadikannya pilihan yang lebih baik untuk set data besar. Contoh ini juga menunjukkan kuasa pengindeksan juga. Cuba alih keluar indeks & kemudian lihat hasilnya juga!

Mengapa Pengindeksan Penting

Tanpa indeks, MongoDB perlu melakukan imbasan koleksi, yang bermaksud ia perlu melihat setiap dokumen dalam koleksi untuk mencari data yang berkaitan. Ini tidak cekap, terutamanya apabila set data anda berkembang. Indeks membolehkan MongoDB mencari dokumen yang sepadan dengan keadaan pertanyaan anda dengan cekap, mempercepatkan prestasi pertanyaan dengan ketara.

Dalam konteks penomboran berasaskan kursor, indeks memastikan bahawa pengambilan set dokumen seterusnya (berdasarkan documentId) adalah pantas dan tidak merendahkan prestasi apabila lebih banyak dokumen ditambahkan pada koleksi.

Kesimpulan

Walaupun penomboran berasaskan offset mudah dilaksanakan, ia boleh menjadi tidak cekap dengan set data yang besar kerana keperluan untuk mengimbas melalui rekod. Penomboran berasaskan kursor, sebaliknya, menyediakan penyelesaian yang lebih berskala, memastikan prestasi konsisten tanpa mengira saiz set data. Jika anda bekerja dengan koleksi besar dalam MongoDB, adalah wajar mempertimbangkan penomboran berasaskan kursor untuk pengalaman yang lebih lancar dan pantas.

Berikut ialah index.js lengkap untuk anda jalankan secara setempat:

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 < 2000000; i++) {
      bulkOps.push({
        insertOne: {
          documentId: i,
          name: `Record-${i}`,
          value: Math.random() * 1000,
        },
      });

      // Execute every 10000 operations and reinitialize
      if (bulkOps.length === 10000) {
        await collection.bulkWrite(bulkOps);
        bulkOps = [];
      }
    }

    if (bulkOps.length > 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();

Atas ialah kandungan terperinci Melancarkan MongoDB: Mengapa Penomboran Berasaskan Kursor Mengungguli Penomboran Berasaskan Offset Setiap Kali!. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!