PricingLoginStart free
MongoDB Academy · पाठ

चेंज इवेंट दस्तावेज़ की संरचना

शिक्षार्थी चेंज इवेंट के फ़ील्ड—operationType, fullDocument, updateDescription, ns, documentKey—का निरीक्षण करेंगे और प्रत्येक ऑपरेशन प्रकार को संभालेंगे।

पाठ 2, कुल 4 में से13 चरण

चेंज इवेंट दस्तावेज़ की संरचना, CoddyKit पर MongoDB Academy का एक निःशुल्क पाठ है। यह 4 में से 2वाँ पाठ है। आप नीचे पूरा पाठ निःशुल्क पढ़ सकते हैं—फिर अंतर्निहित कोड संपादक और 24/7 एआई ट्यूटर के साथ ब्राउज़र में इसका व्यावहारिक अभ्यास कर सकते हैं। यह MongoDB Academy सीखने के मार्ग का हिस्सा है और आपकी प्रगति वेब तथा CoddyKit ऐप पर सिंक होती रहती है। MongoDB Academy पाठ्यक्रम में कुल 4 पाठ शामिल हैं।

Change Event दस्तावेज़ की संरचना

Change stream द्वारा भेजा गया प्रत्येक इवेंट एक change event दस्तावेज़ होता है, जिसमें फ़ील्ड का एक मानक समूह होता है। सबसे महत्वपूर्ण फ़ील्ड हैं operationType (क्या हुआ), ns (कौन-सा नेमस्पेस प्रभावित हुआ), documentKey (प्रभावित दस्तावेज़ की _id) और संचालन-विशिष्ट फ़ील्ड जैसे fullDocument और updateDescription। इस संरचना को समझने से आप ऐसे इवेंट हैंडलर लिख सकते हैं जो प्रत्येक संचालन प्रकार पर सही ढंग से प्रतिक्रिया दें।

operationType फ़ील्ड

operationType फ़ील्ड यह बताता है कि किस प्रकार का बदलाव हुआ। सामान्य मानों में शामिल हैं: 'insert' (नया दस्तावेज़ जोड़ा गया), 'update' (दस्तावेज़ के फ़ील्ड बदले गए), 'replace' (पूरा दस्तावेज़ बदला गया), 'delete' (दस्तावेज़ हटाया गया) और 'invalidate' (change stream अमान्य हो गया, जैसे संग्रह हटा दिया गया हो)। संग्रह या डेटाबेस संचालन के लिए 'drop', 'rename' और 'dropDatabase' भी होते हैं।

for await (const change of changeStream) {
  switch (change.operationType) {
    case 'insert':   handleInsert(change); break;
    case 'update':   handleUpdate(change); break;
    case 'replace':  handleReplace(change); break;
    case 'delete':   handleDelete(change); break;
    case 'invalidate':
      console.log('Change stream invalidated — collection may have been dropped');
      await changeStream.close();
      break;
    default:
      console.log('Other operation:', change.operationType);
  }
}

ns (Namespace) फ़ील्ड

ns फ़ील्ड प्रभावित संग्रह का नेमस्पेस एक ऑब्जेक्ट के रूप में रखता है, जिसमें दो गुण होते हैं: ns.db (डेटाबेस का नाम) और ns.coll (संग्रह का नाम)। यह फ़ील्ड तब आवश्यक होता है जब आप डेटाबेस या क्लाइंट स्तर पर change stream खोलते हैं और कई संग्रहों के इवेंट एक ही stream पर आते हैं। इवेंट को सही हैंडलर तक पहुँचाने के लिए ns.coll का उपयोग करें।

// Database-level stream receives events from all collections
const dbStream = client.db('ecommerce').watch();

for await (const change of dbStream) {
  const collectionName = change.ns.coll;
  const database = change.ns.db;

  if (collectionName === 'orders') {
    await handleOrderChange(change);
  } else if (collectionName === 'products') {
    await handleProductChange(change);
  }
}

documentKey फ़ील्ड

documentKey फ़ील्ड उस दस्तावेज़ की _id रखता है जो बदलाव से प्रभावित हुआ था। यह 'invalidate' और संग्रह-स्तरीय संचालन को छोड़कर सभी संचालन प्रकारों में मौजूद होता है। शार्ड किए गए संग्रहों में documentKey, _id के साथ शार्ड कुंजी फ़ील्ड भी रख सकता है। इस फ़ील्ड से आप पूरा दस्तावेज़ पढ़े बिना यह पहचान सकते हैं कि कौन-सा विशिष्ट दस्तावेज़ बदला।

// documentKey is available on all CRUD events
for await (const change of changeStream) {
  const affectedId = change.documentKey._id;
  console.log('Document affected:', affectedId);

  // Use the ID to invalidate cache entries
  if (change.operationType === 'update' || change.operationType === 'delete') {
    cache.invalidate(affectedId.toString());
  }
}

Insert इवेंट: fullDocument फ़ील्ड

'insert' संचालन के लिए change event में fullDocument फ़ील्ड शामिल होता है, जिसमें जोड़ा गया पूरा दस्तावेज़ होता है, जिसमें अपने-आप बनाई गई _id भी शामिल है। Insert इवेंट के लिए यह डिफ़ॉल्ट रूप से उपलब्ध होता है—update इवेंट के विपरीत, जिनमें updateLookup के साथ इसे स्पष्ट रूप से सक्षम करना पड़ता है। नए डेटा को तुरंत संसाधित करने के लिए इसका उपयोग करें, ताकि बाद की क्वेरी भेजने की आवश्यकता न हो।

// Insert event structure:
// {
//   _id: { _data: '...' },           // resume token
//   operationType: 'insert',
//   ns: { db: 'shop', coll: 'orders' },
//   documentKey: { _id: ObjectId('...') },
//   fullDocument: {                   // the inserted document
//     _id: ObjectId('...'),
//     customerId: '123',
//     total: 49.99,
//     status: 'pending'
//   }
// }

if (change.operationType === 'insert') {
  await sendOrderConfirmationEmail(change.fullDocument.customerId, change.fullDocument);
}

Update इवेंट: updateDescription फ़ील्ड

'update' ऑपरेशन के लिए, परिवर्तन इवेंट में पूरे दस्तावेज़ के बजाय updateDescription ऑब्जेक्ट शामिल होता है। इसमें दो उप-फ़ील्ड होते हैं: updatedFields (फ़ील्ड पथों को उनके नए मानों से जोड़ने वाला मानचित्र) और removedFields (अनसेट किए गए फ़ील्ड पथों की सारणी)। यह डेल्टा प्रारूप संक्षिप्त और प्रभावी होता है—यह पूरे दस्तावेज़ की स्थिति नहीं, बल्कि केवल हुए परिवर्तनों की जानकारी देता है।

// Update event structure:
// {
//   operationType: 'update',
//   documentKey: { _id: ObjectId('...') },
//   updateDescription: {
//     updatedFields: {
//       'status': 'shipped',
//       'tracking.number': 'TRACK123'
//     },
//     removedFields: ['processingNotes']
//   }
// }

if (change.operationType === 'update') {
  const fields = change.updateDescription.updatedFields;
  if (fields.status === 'shipped') {
    await sendShippingNotification(change.documentKey._id);
  }
}

Replace इवेंट: पूर्ण प्रतिस्थापन

'replace' इवेंट तब होता है जब replaceOne() को कॉल किया जाता है और पूरे दस्तावेज़ ( _id को छोड़कर) को बदल दिया जाता है। परिवर्तन इवेंट में पूरे नए दस्तावेज़ वाला fullDocument शामिल होता है। यह update इवेंट से अलग है, क्योंकि इसमें updateDescription नहीं होता—आप यह नहीं जान सकते कि क्या बदला, केवल नई स्थिति जान सकते हैं। replace इवेंट को insert इवेंट की तरह प्रोसेस करें: fullDocument से पूरे नए स्टेट को पढ़ें।

// Replace event — includes the complete new document
if (change.operationType === 'replace') {
  const newDocument = change.fullDocument;
  // Re-index the entire document
  await searchIndex.replace(newDocument._id, newDocument);
}

Delete इवेंट: केवल _id

'delete' इवेंट के लिए fullDocument फ़ील्ड null होता है, क्योंकि इवेंट को प्रोसेस किए जाने तक दस्तावेज़ पहले ही हट चुका होता है। केवल documentKey (जिसमें _id होता है) विश्वसनीय रूप से उपलब्ध रहता है। यदि आपके delete हैंडलर को दस्तावेज़ की सामग्री चाहिए, तो आपको हटाने से पहले ज़रूरी जानकारी संग्रहीत करनी होगी (जैसे, ऑडिट लॉग में), क्योंकि change streams पहले ही हटाए जा चुके दस्तावेज़ वापस नहीं ला सकते।

// Delete event — fullDocument is null
// {
//   operationType: 'delete',
//   documentKey: { _id: ObjectId('...') },
//   fullDocument: null  // document is gone
// }

if (change.operationType === 'delete') {
  const deletedId = change.documentKey._id;
  // Remove from search index
  await searchIndex.delete(deletedId);
  // Remove from cache
  cache.delete(deletedId.toString());
  // Cannot access the document content anymore!
}

Resume Token (_id फ़ील्ड)

हर परिवर्तन इवेंट के _id फ़ील्ड में एक resume token संग्रहीत होता है ({ _data: '...' } ऑब्जेक्ट)। यह टोकन oplog में इवेंट की स्थिति की पहचान करता है। हर इवेंट को प्रोसेस करने के बाद resume token संग्रहीत करें, ताकि आपका ऐप पुनः शुरू होने पर resumeAfter या startAfter विकल्प का उपयोग करके वहीं से stream फिर शुरू कर सके जहाँ वह रुकी थी। इससे कम-से-कम-एक-बार डिलीवरी की गारंटी मिलती है।

// Save resume token after each event
for await (const change of changeStream) {
  await processChange(change);
  // Persist the token so we can resume after restart
  await db.collection('resumeTokens').updateOne(
    { streamId: 'orderStream' },
    { $set: { token: change._id } },
    { upsert: true }
  );
}

invalidate इवेंट को संभालना

'invalidate' इवेंट संकेत देता है कि change stream अब जारी नहीं रह सकती—आमतौर पर इसलिए क्योंकि देखी जा रही collection हटा दी गई, डेटाबेस हटा दिया गया, या replica set में rollback हुआ। invalidate इवेंट के बाद change stream अपने-आप बंद हो जाती है। आपके ऐप को इसे अनदेखा करने के बजाय stream फिर खोलकर (या प्रशासकों को सूचित करके) संभालना चाहिए। 'invalidate' प्रकार की जाँच करें और तय करें कि stream फिर खोलनी है या ऐप बंद करना है।

for await (const change of changeStream) {
  if (change.operationType === 'invalidate') {
    console.warn('Change stream invalidated (collection may have been dropped)');
    // Optionally reopen after the collection is recreated
    await changeStream.close();
    break;
  }
  await processChange(change);
}

पूर्ण इवेंट हैंडलर का उदाहरण

सभी इवेंट प्रकारों को एक ही मजबूत हैंडलर में मिलाकर switch-आधारित रूटिंग करने से कोड का रखरखाव आसान होता है। हर case केवल उन्हीं फ़ील्ड को पढ़ता है जिनके उस operation type के लिए उपलब्ध होने की गारंटी है। operationType, namespace और documentKey को शामिल करने वाली संरचित लॉगिंग जोड़ने से यह अच्छी तरह देखा जा सकता है कि आपका change stream क्या प्रोसेस कर रहा है।

async function handleChange(change) {
  const { operationType, ns, documentKey } = change;
  console.log('[' + ns.coll + '] ' + operationType + ' on ' + documentKey._id);

  switch (operationType) {
    case 'insert':
      await onInsert(change.fullDocument);
      break;
    case 'update':
      await onUpdate(documentKey._id, change.updateDescription.updatedFields);
      break;
    case 'replace':
      await onReplace(change.fullDocument);
      break;
    case 'delete':
      await onDelete(documentKey._id);
      break;
    case 'invalidate':
      throw new Error('Stream invalidated');
  }
}

त्वरित जाँच

इस पाठ में MongoDB और NoSQL डेटाबेस की अवधारणाओं के बारे में अपनी समझ जाँचें।

इंटरैक्टिव पाठ में इसका उत्तर दें

पाठ का पुनरावलोकन

इस पाठ में आपने सीखा: हर परिवर्तन इवेंट में operationType, ns, documentKey और fullDocument तथा updateDescription जैसे operation-विशिष्ट फ़ील्ड होते हैं, insert/replace इवेंट में fullDocument होता है, लेकिन delete इवेंट में नहीं होता (दस्तावेज़ पहले ही हट चुका होता है), और इवेंट का _id फ़ील्ड resume token होता है, जिसका उपयोग ज्ञात स्थिति से stream फिर शुरू करने के लिए किया जाता है। आगे हम aggregation pipelines की सहायता से change stream इवेंट को फ़िल्टर करना सीखेंगे।

शुरुआत निःशुल्क

एआई शिक्षक के साथ JavaScript सीखें — निःशुल्क

अपने ब्राउज़र में वास्तविक कोड लिखें और चलाएँ, चौबीसों घंटे एआई शिक्षक से तुरंत सहायता पाएँ, और वेब या ऐप पर वहीं से शुरू करें जहाँ आपने छोड़ा था।

पाठ्यक्रम
30
पाठ
120
निःशुल्क सीखना शुरू करेंपूरा पाठ्यक्रम देखें

अक्सर पूछे जाने वाले प्रश्न

क्या “चेंज इवेंट दस्तावेज़ की संरचना” पाठ निःशुल्क है?

हाँ—“चेंज इवेंट दस्तावेज़ की संरचना” का पूरा पाठ यहाँ वेब पर निःशुल्क पढ़ा जा सकता है। इंटरैक्टिव अभ्यास (अंतर्निहित कोड संपादक और 24/7 एआई ट्यूटर) करने और MongoDB Academy पाठ्यक्रम का बाकी हिस्सा अनलॉक करने के लिए CoddyKit PRO लें। MongoDB Academy पाठ्यक्रम में कुल 4 पाठ शामिल हैं।

“चेंज इवेंट दस्तावेज़ की संरचना” में मैं क्या सीखूँगा?

शिक्षार्थी चेंज इवेंट के फ़ील्ड—operationType, fullDocument, updateDescription, ns, documentKey—का निरीक्षण करेंगे और प्रत्येक ऑपरेशन प्रकार को संभालेंगे। आप ब्राउज़र में सीधे चलाए जाने वाले व्यावहारिक कोड के साथ MongoDB Academy का अभ्यास करते हैं, और पाठ पूरा करते समय 24/7 एआई ट्यूटर आपके प्रश्नों के उत्तर देता है।

क्या MongoDB Academy शुरू करने के लिए मुझे किसी अनुभव की आवश्यकता है?

पहले के अनुभव की आवश्यकता नहीं है। CoddyKit पर MongoDB Academy शुरुआती से लेकर उन्नत शिक्षार्थियों तक सभी के लिए व्यवस्थित किया गया है, इसलिए आप यहीं से या शुरुआत से सीखना शुरू कर सकते हैं और अपनी गति से आगे बढ़ सकते हैं। यह 4 में से 2वाँ पाठ है।

“चेंज इवेंट दस्तावेज़ की संरचना” पाठ पूरा करने में कितना समय लगता है?

CoddyKit का अधिकांश पाठ लगभग 5–10 मिनट में पूरा हो जाता है। हर पाठ छोटा और संवादात्मक है, इसलिए आप लगातार प्रगति करते हैं और वेब या ऐप पर वहीं से सीखना जारी रख सकते हैं जहाँ आपने छोड़ा था।

क्या मैं इस MongoDB Academy पाठ में कोड लिख और चला सकता हूँ?

हाँ। हर MongoDB Academy पाठ में एक अंतर्निर्मित कोड संपादक शामिल है, जिससे आप सीधे अपने ब्राउज़र में वास्तविक कोड लिख और चला सकते हैं और तुरंत एआई प्रतिक्रिया पा सकते हैं—स्थानीय सेटअप की आवश्यकता नहीं है।

इस पाठ्यक्रम के सभी पाठ

  1. किसी संग्रह पर चेंज स्ट्रीम खोलना
  2. चेंज इवेंट दस्तावेज़ की संरचना
  3. एग्रीगेशन डेटा-प्रवाह से इवेंट फ़िल्टर करना
  4. बाधा के बाद चेंज स्ट्रीम फिर से शुरू करना
← MongoDB Academy पर वापस जाएँ