MongoDB Academy · पाठ

insertOne और insertMany

शिक्षार्थी एकल और थोक दस्तावेज़ डालेंगे तथा प्रत्येक कार्रवाई द्वारा लौटाए गए अपने-आप बनाए गए _id फ़ील्ड का निरीक्षण करेंगे।

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

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

इंसर्ट की दो विधियाँ

MongoDB collection में दस्तावेज़ जोड़ने के लिए दो विधियाँ प्रदान करता है:

insertOne(doc) — एक दस्तावेज़ डालता है और acknowledged तथा insertedId वाला ऑब्जेक्ट लौटाता है
insertMany(docs) — दस्तावेज़ों का एक ऐरे डालता है और acknowledged तथा insertedIds लौटाता है (ऐरे इंडेक्स को बनाए गए _id से जोड़ने वाला ऑब्जेक्ट)

मंगोश में दोनों विधियाँ सिंक्रोनस होती हैं और Node.js ड्राइवर कोड में Promises लौटाती हैं। त्रुटियों को सही ढंग से संभालने के लिए async Node.js functions में हमेशा await का उपयोग करें।

// insertOne
const res1 = await db.collection('users').insertOne({ name: 'Alice', age: 28 });
console.log(res1.insertedId); // ObjectId('...')

// insertMany
const res2 = await db.collection('users').insertMany([
  { name: 'Bob', age: 32 },
  { name: 'Carol', age: 25 }
]);
console.log(res2.insertedIds);
// { '0': ObjectId('...'), '1': ObjectId('...') }

अपने-आप बनाया गया ObjectId

जब आप बिना _id फ़ील्ड के कोई दस्तावेज़ डालते हैं, तो MongoDB अपने-आप एक ObjectId बनाता है। ObjectId, BSON का 12-बाइट प्रकार है जिसकी संरचना किसी केंद्रीय काउंटर के बिना वितरित नोड्स में वैश्विक विशिष्टता सुनिश्चित करती है:

बाइट 0-3: Unix टाइमस्टैम्प (सेकंड) — इंसर्ट के समय के आधार पर लगभग क्रमबद्ध करना संभव बनाता है
बाइट 4-8: यादृच्छिक मान (हर प्रक्रिया के लिए एक बार बनाया जाता है)
बाइट 9-11: बढ़ता हुआ काउंटर (यादृच्छिक मान से शुरू किया जाता है)

इस डिज़ाइन का अर्थ है कि एक ही मिलीसेकंड में दस्तावेज़ डालने वाले दो अलग-अलग सर्वर भी अलग-अलग ObjectIds बनाएँगे, जिससे वितरित इंसर्ट में टकराव नहीं होगा।

// Auto-generated ObjectId on insert
db.items.insertOne({ name: 'Widget' });
// { acknowledged: true, insertedId: ObjectId('64a2f3b1c9e7e12345678901') }

// Extract timestamp from an ObjectId
const id = ObjectId('64a2f3b1c9e7e12345678901');
print(id.getTimestamp());
// ISODate('2023-07-03T10:15:29.000Z')

// Sorting by _id gives approximate insertion order
db.items.find({}).sort({ _id: 1 });

अपना _id देना

अपना _id मान देकर आप अपने-आप बनाए गए ObjectId को बदल सकते हैं। कोई भी BSON प्रकार काम करता है: स्ट्रिंग, संख्या, UUID या यहाँ तक कि नेस्ट किया हुआ ऑब्जेक्ट। केवल एक आवश्यकता है कि वह मान collection के भीतर विशिष्ट होना चाहिए।

कस्टम _ids तब उपयोगी होते हैं जब आपके पास पहले से कोई स्वाभाविक विशिष्ट कुंजी हो — जैसे उत्पाद का SKU, उपयोगकर्ता नाम का स्लग या किसी बाहरी सिस्टम की ID। हालांकि, शार्ड किए गए क्लस्टर में कस्टम _ids के रूप में लगातार बढ़ने वाले पूर्णांकों से बचें — वे उस शार्ड पर लेखन का अत्यधिक दबाव बनाते हैं जिसमें सबसे बड़ी कुंजी-सीमा होती है।

// String _id (natural key)
db.products.insertOne({
  _id: 'SKU-WH-BLK-42',
  name: 'Wireless Headphones Black',
  price: 79.99
});

// Number _id
db.categories.insertOne({ _id: 100, name: 'Electronics' });

// Duplicate _id throws E11000 duplicate key error:
db.categories.insertOne({ _id: 100, name: 'Gadgets' });
// MongoServerError: E11000 duplicate key error

insertMany: बड़े पैमाने पर इंसर्ट

insertMany दस्तावेज़ों का एक ऐरे स्वीकार करता है। यह लूप में insertOne को बार-बार कॉल करने की तुलना में काफी अधिक कुशल है, क्योंकि यह सभी दस्तावेज़ों को नेटवर्क के एक ही आवागमन में भेजता है और MongoDB आंतरिक रूप से लेखनों को बैच में बाँट सकता है।

डिफ़ॉल्ट रूप से, insertMany दस्तावेज़ों को क्रमबद्ध मोड में डालता है: यदि किसी दस्तावेज़ का वैलिडेशन विफल हो जाए या उसका _id दोहराया गया हो, तो कार्रवाई रुक जाती है और बाकी दस्तावेज़ नहीं डाले जाते। अव्यवस्थित मोड पर जाने के लिए दूसरे आर्ग्युमेंट के रूप में { ordered: false } सेट करें; इस मोड में कुछ दस्तावेज़ विफल होने पर भी MongoDB बाकी दस्तावेज़ डालना जारी रखता है।

// Ordered insertMany (default) - stops on first error
db.users.insertMany([
  { name: 'Alice' },
  { name: 'Bob' },
  { name: 'Carol' }
]);

// Unordered insertMany - continues after errors
db.users.insertMany(
  [
    { _id: 1, name: 'Alice' },
    { _id: 1, name: 'Duplicate' },  // Will fail (dup key)
    { _id: 2, name: 'Bob' }         // Still inserted in unordered mode
  ],
  { ordered: false }
);

insertedIds ऑब्जेक्ट की जाँच करना

insertMany से मिलने वाले परिणाम ऑब्जेक्ट में insertedIds एक ऐरे के बजाय ऑब्जेक्ट होता है। इसकी कुंजियाँ ऐरे इंडेक्स की स्ट्रिंग और मान बनाए गए ObjectIds होते हैं। इससे आप हर इनपुट दस्तावेज़ को उसके परिणामस्वरूप बने _id से जोड़ सकते हैं।

Node.js में आप आगे की प्रक्रिया के लिए अक्सर डाले गए दस्तावेज़ों को उनकी IDs से फिर जोड़ते हैं — उदाहरण के लिए, किसी दूसरी collection में ऐसे संबंधित दस्तावेज़ बनाने के लिए जो इन नए _ids का संदर्भ देते हों।

const docs = [
  { name: 'Widget A', price: 10 },
  { name: 'Widget B', price: 20 },
  { name: 'Widget C', price: 30 }
];

const result = await db.collection('products').insertMany(docs);

console.log(result.insertedCount); // 3
console.log(result.insertedIds);
// {
//   '0': ObjectId('...'),
//   '1': ObjectId('...'),
//   '2': ObjectId('...')
// }

// Attach _ids back to original docs
docs.forEach((doc, i) => {
  doc._id = result.insertedIds[i];
});

WriteConcern: स्थायित्व नियंत्रित करना

डिफ़ॉल्ट रूप से, insertOne और insertMany कनेक्शन की डिफ़ॉल्ट लेखन विश्वसनीयता का उपयोग करते हैं—आमतौर पर w: 1, जिसका अर्थ है कि प्राथमिक सर्वर लेखन की पुष्टि करता है। आप इसे प्रत्येक ऑपरेशन के लिए बदल सकते हैं:

{ w: 0 } — बिना पुष्टि की प्रतीक्षा किए आगे बढ़ना (सबसे तेज़, असुरक्षित)
{ w: 1 } — प्राथमिक सर्वर द्वारा पुष्टि (डिफ़ॉल्ट)
{ w: 'majority' } — प्रतिकृति सेट के अधिकांश सदस्यों द्वारा पुष्टि (सबसे सुरक्षित)
{ j: true } — इसके अतिरिक्त, लेखन को डिस्क पर जर्नल में फ्लश करना आवश्यक बनाता है

// Safe insert: confirmed by majority of replica set + journaled
await db.collection('orders').insertOne(
  { orderId: 'ORD-001', total: 99.99, status: 'pending' },
  { writeConcern: { w: 'majority', j: true } }
);
// Slower than w:1 but guaranteed durable even if primary crashes

डुप्लिकेट कुंजी त्रुटियों को संभालना

जब कोई इंसर्ट यूनिक इंडेक्स का उल्लंघन करता है, तो MongoDB डुप्लिकेट कुंजी त्रुटि (E11000) उत्पन्न करता है—सबसे सामान्यतः _id की विशिष्टता संबंधी आवश्यकता के कारण, लेकिन उपयोगकर्ता द्वारा बनाए गए किसी भी यूनिक इंडेक्स के कारण भी। Node.js में, यह कोड 11000 वाली MongoServerError उत्पन्न करता है।

जब डुप्लिकेट कुंजी त्रुटियों की संभावना हो, तो इंसर्ट को हमेशा try/catch में रखें (जैसे, ईमेल के आधार पर users को अपसर्ट करते समय)। डुप्लिकेट को अन्य लेखन त्रुटियों से अलग पहचानने के लिए त्रुटि कोड जाँचें और उचित प्रतिक्रिया दें—API से 409 Conflict लौटाएँ या इसके बजाय मौजूदा दस्तावेज़ को अपडेट करें।

try {
  await db.collection('users').insertOne({
    email: 'alice@example.com',
    name: 'Alice'
  });
} catch (err) {
  if (err.code === 11000) {
    // Duplicate key - email already exists
    console.log('User with this email already exists');
    // Respond with HTTP 409 Conflict in an API
  } else {
    throw err;  // Re-throw unexpected errors
  }
}

लूप के साथ परीक्षण डेटा भरना

किसी collection में वास्तविक-जैसा परीक्षण डेटा भरना विकास के सामान्य कार्यों में से एक है। आप यह कार्य सीधे mongosh में JavaScript लूप का उपयोग करके कर सकते हैं या Node.js स्क्रिप्ट लिख सकते हैं। बड़े डेटा सेट के लिए, एक बहुत बड़ी array के बजाय 500-1000 documents के बैच में insertMany का उपयोग करें—इससे मेमोरी संबंधी समस्याएँ टलती हैं और प्रगति पर नज़र रखना संभव होता है।

Node.js में वास्तविक-जैसा नकली डेटा बनाने के लिए @faker-js/faker लाइब्रेरी का व्यापक रूप से उपयोग किया जाता है। यह वास्तविक-जैसे नाम, ईमेल, पते, तिथियाँ और कई अन्य फ़ील्ड प्रकार बनाती है, जिससे परीक्षण डेटा और वास्तविक डेटा में अंतर करना कठिन हो जाता है।

// Seed 100 test users in mongosh
const users = [];
for (let i = 1; i <= 100; i++) {
  users.push({
    name: 'User ' + i,
    email: 'user' + i + '@example.com',
    age: 18 + (i % 50),
    active: i % 3 !== 0,
    createdAt: new Date(Date.now() - i * 86400000)
  });
}
db.users.insertMany(users);
// { acknowledged: true, insertedCount: 100 }

इंसर्ट किए गए दस्तावेज़ों की जाँच करना

इंसर्ट के बाद हमेशा जाँचें कि आपका डेटा सही ढंग से दर्ज हुआ है। उपयोगी जाँच कमांड:

db.collection.countDocuments({}) — कुल संख्या
db.collection.findOne({ _id: insertedId }) — लौटाए गए _id के आधार पर किसी विशिष्ट दस्तावेज़ की पुष्टि करें
db.collection.find({}).sort({ _id: -1 }).limit(5) — हाल ही में इंसर्ट किए गए 5 दस्तावेज़ देखें

स्वचालित परीक्षणों में केवल यह जाँच न करें कि इंसर्ट सफल हुआ (कोई त्रुटि उत्पन्न नहीं हुई), बल्कि यह भी जाँचें कि संग्रहीत दस्तावेज़ में अपेक्षित फ़ील्ड मान हैं—इंसर्ट के दौरान सूक्ष्म प्रकार-रूपांतरण या मिडलवेयर परिवर्तन फ़ील्ड बदल सकते हैं।

// Insert and immediately verify
const { insertedId } = await db.collection('orders').insertOne({
  customerId: ObjectId('...'),
  items: [{ sku: 'A1', qty: 2 }],
  total: 39.98,
  status: 'pending'
});

const stored = await db.collection('orders').findOne({ _id: insertedId });
console.log(stored.status);   // 'pending'
console.log(stored.total);    // 39.98

लेन-देन और एक से अधिक इंसर्ट

जब आपको एक से अधिक collections में परमाणु रूप से दस्तावेज़ इंसर्ट करने हों—अर्थात सभी एक साथ सफल हों या सभी विफल—तो बहु-दस्तावेज़ लेन-देन का उपयोग करें। लेन-देन के बिना, यदि पहला इंसर्ट सफल होने के बाद दूसरा विफल हो जाए, तो आपका डेटा असंगत स्थिति में आ जाएगा।

लेन-देन से विलंब बढ़ता है, इसलिए इनका उपयोग केवल उन मामलों में करें जहाँ परमाणुता वास्तव में आवश्यक हो। अधिकांश single-collection bulk inserts के लिए, ordered mode वाला insertMany collection स्तर पर पर्याप्त परमाणुता प्रदान करता है (विफलता से पहले के सभी दस्तावेज़ इंसर्ट हो जाते हैं, या rollback आवश्यक होने पर कोई भी नहीं)।

// Atomic insert across two collections using a transaction
const session = client.startSession();
try {
  await session.withTransaction(async () => {
    await db.collection('orders').insertOne(
      { total: 99.99, customerId: custId }, { session }
    );
    await db.collection('orderEvents').insertOne(
      { type: 'created', orderId: ordId }, { session }
    );
  });
} finally {
  await session.endSession();
}

प्रदर्शन सुझाव: Bulk Write API

एक ही बैच में मिश्रित ऑपरेशनों (इंसर्ट, अपडेट, डिलीट) के लिए db.collection.bulkWrite(operations) का उपयोग करें। यह अलग-अलग insertMany + updateMany कॉल की तुलना में अधिक दक्ष है, क्योंकि सभी ऑपरेशन एक ही नेटवर्क राउंड-ट्रिप साझा करते हैं।

array में प्रत्येक ऑपरेशन एक ऐसा object होता है जिसकी कुंजी insertOne, updateOne, deleteOne आदि जैसी होती है। परिणाम object इंसर्ट किए गए, बदले गए और डिलीट किए गए documents की संख्याओं का सारांश देता है। bulkWrite भी insertMany की तरह ordered/unordered modes का समर्थन करता है।

await db.collection('products').bulkWrite([
  { insertOne: { document: { name: 'New Product', price: 25 } } },
  { updateOne: {
      filter: { name: 'Old Product' },
      update: { $set: { price: 15 } }
  }},
  { deleteOne: { filter: { name: 'Discontinued' } } }
]);
// { insertedCount: 1, modifiedCount: 1, deletedCount: 1 }

त्वरित जाँच

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

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

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

इस पाठ में आपने सीखा: insertOne और insertMany दो इंसर्ट मेथड हैं—bulk data के लिए insertMany अधिक दक्ष है और ordered/unordered त्रुटि-प्रबंधन का समर्थन करता है, यदि आप _id न दें तो ObjectId अपने-आप बनाया जाता है और उसके पहले 4 bytes में इंसर्ट का timestamp होता है, जिससे लगभग क्रम निर्धारित किया जा सकता है, तथा लेखन विश्वसनीयता fire-and-forget (w:0) से majority-replicated (w:'majority') तक डेटा की टिकाऊपन नियंत्रित करती है। आगे हम find() cursor का विस्तार से अध्ययन करेंगे और dot notation के साथ nested fields और arrays को query करना सीखेंगे।

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

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

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

पाठ्यक्रम: 30
पाठ: 120

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

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

क्या “insertOne और insertMany” पाठ निःशुल्क है?

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

“insertOne और insertMany” में मैं क्या सीखूँगा?

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

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

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

“insertOne और insertMany” पाठ पूरा करने में कितना समय लगता है?

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

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

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

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

← MongoDB Academy पर वापस जाएँ