MongoDB Query API के साथ शुरुआत करें

एक लोकप्रिय NoSQL डेटाबेस के रूप में, MongoDB आपके डेटा को प्रबंधित करने का एक लचीला और स्केलेबल तरीका प्रदान करता है। यह गाइड इसके सहज Query API में महारत हासिल करने के लिए आपका प्रारंभिक बिंदु है, जो आपको सरल BSON (बाइनरी JSON) का उपयोग करके अपने डेटा के साथ इंटरैक्ट करने देता है, जो दक्षता और डेटा प्रकारों के लिए अनुकूलित है। 

पूरे लेख में, हम आधारभूत create, read, update, delete (CRUD) ऑपरेशंस कवर करेंगे, फ़िल्टर और प्रोजेक्शन के साथ सटीक क्वेरी करना सीखेंगे, डेटा ट्रांसफ़ॉर्मेशन के लिए एग्रीगेशन पाइपलाइनों की शक्ति को समझेंगे, और प्रदर्शन बढ़ाने के लिए इंडेक्सिंग पर बात करेंगे। अंत तक, आपके पास अपनी MongoDB कलेक्शंस में डेटा को कुशलता से प्राप्त करने और संसाधित करने की मजबूत नींव होगी।

आधारभूत अवधारणाएँ: CRUD ऑपरेशंस

किसी भी डेटाबेस इंटरैक्शन की रीढ़ CRUD है: create, read, update, और delete। आइए देखें कि MongoDB में प्रत्येक को कैसे किया जाता है।

डेटा बनाना (insert)

किसी कलेक्शन में नए डॉक्यूमेंट्स जोड़ने के लिए आप insert मेथड्स का उपयोग करते हैं। MongoDB में डॉक्यूमेंट्स JSON जैसे ऑब्जेक्ट होते हैं।

insertOne()

यह मेथड किसी कलेक्शन में एक सिंगल डॉक्यूमेंट जोड़ने के लिए उपयोग होता है।

// A sample document to insert
const newProduct = {
  name: "Wireless Mouse",
  brand: "Logitech",
  price: 29.99,
  inStock: true
};

// Insert the new document into the 'products' collection
db.products.insertOne(newProduct);संचालित द्वारा

insertMany()

यह मेथड एक साथ कई डॉक्यूमेंट्स जोड़ता है, जो उन्हें एक-एक करके जोड़ने से कहीं अधिक कुशल है।

// An array of documents to insert
const newProducts = [
  { name: "Mechanical Keyboard", brand: "Corsair", price: 129.99, inStock: false },
  { name: "Gaming Headset", brand: "Razer", price: 99.99, inStock: true },
  { name: "Webcam", brand: "LogiTech", price: 79.99, inStock: true }
];

// Insert the array of documents into the 'products' collection
db.products.insertMany(newProducts);संचालित द्वारा

डेटा पढ़ना (find)

find() मेथड किसी कलेक्शन से डॉक्यूमेंट्स प्राप्त करने का आपका प्रमुख टूल है। जब आप find() कॉल करते हैं, तो यह तुरंत सभी डॉक्यूमेंट्स नहीं लौटाता। इसके बजाय, यह एक कर्सर लौटाता है। यह बड़े रिज़ल्ट सेट्स को बिना सब कुछ एक साथ मेमोरी में लोड किए कुशलतापूर्वक हैंडल करने का तरीका है।

सबसे सरल find() कॉल कोई आर्ग्युमेंट नहीं लेती और कलेक्शन के हर डॉक्यूमेंट के लिए एक कर्सर लौटाती है।

// Find and return a cursor to all documents in the 'products' collection
db.products.find();संचालित द्वारा

यहाँ mongosh (MongoDB शेल) में उस कर्सर ऑब्जेक्ट का उदाहरण है और आप उससे कैसे इंटरैक्ट कर सकते हैं:

// Find all products and assign the returned cursor to a variable
const productCursor = db.products.find();

// The variable 'productCursor' now holds the cursor object, not the documents themselves.
// To get the documents, you need to iterate over the cursor.

// You can convert the cursor to an array to see all the documents
const allProducts = productCursor.toArray();
console.log(allProducts);

// Or, you can manually iterate through the documents
while (productCursor.hasNext()) {
  const product = productCursor.next();
  console.log(product);
}संचालित द्वारा

कर्सर स्वयं एक ऑब्जेक्ट होता है जिसमें toArray(), hasNext() और next() जैसे विभिन्न मेथड्स होते हैं, जो आपको रिज़ल्ट सेट के डॉक्यूमेंट्स को प्राप्त और उपयोग करने देते हैं।

डेटा अपडेट करना (update)

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

updateOne()

यह मेथड फ़िल्टर से मेल खाने वाले पहले डॉक्यूमेंट को अपडेट करता है।

// Update the 'Wireless Mouse' document to set its price to 39.99
db.products.updateOne(
  { name: "Wireless Mouse" }, // Filter to find the document
  { $set: { price: 39.99 } } // Update operator
);संचालित द्वारा

updateMany()

यह मेथड निर्दिष्ट फ़िल्टर से मेल खाने वाले सभी डॉक्यूमेंट्स को अपडेट करता है।

// Update all 'LogiTech' brand products to be in stock
db.products.updateMany(
  { brand: "LogiTech" }, // Filter to find the documents
  { $set: { inStock: true } } // Update operator
);संचालित द्वारा

डेटा हटाना (delete)

डॉक्यूमेंट्स को हटाने के लिए आप delete मेथड्स का उपयोग करते हैं। ये भी हटाए जाने वाले डॉक्यूमेंट्स को निर्धारित करने के लिए एक फ़िल्टर लेते हैं।

deleteOne()

यह मेथड फ़िल्टर से मेल खाने वाले पहले डॉक्यूमेंट को हटाता है।

// Delete the 'Webcam' document
db.products.deleteOne({ name: "Webcam" });संचालित द्वारा

deleteMany()

यह मेथड फ़िल्टर से मेल खाने वाले सभी डॉक्यूमेंट्स को हटाता है। किसी कलेक्शन के सभी डॉक्यूमेंट्स हटाने के लिए आप खाली फ़िल्टर {} दे सकते हैं।

// Delete all documents that are not in stock
db.products.deleteMany({ inStock: false });संचालित द्वारा

सटीक प्राप्ति: क्वेरी फ़िल्टर्स

क्वेरी फ़िल्टर्स MongoDB की शक्ति के केंद्र में हैं। ये find() और update मेथड्स में पहला आर्ग्युमेंट होते हैं और आपको सटीक रूप से चुनने देते हैं कि किन डॉक्यूमेंट्स पर काम करना है।

तुलनात्मक ऑपरेटर

ये ऑपरेटर किसी फ़ील्ड के मान की किसी निर्दिष्ट मान से तुलना करने देते हैं।

$eq (बराबर)

यह उन डॉक्यूमेंट्स को ढूँढता है जहाँ कोई फ़ील्ड किसी मान के बराबर हो।

// Find all products that are made by 'Razer'
db.products.find({ brand: { $eq: "Razer" } });
// This can be simplified to:
// db.products.find({ brand: "Razer" });संचालित द्वारा

$gt और $gte (से बड़ा, बड़ा या बराबर)

ये उन डॉक्यूमेंट्स को ढूँढते हैं जहाँ किसी फ़ील्ड का मान निर्दिष्ट मान से बड़ा ($gt) या बड़ा या बराबर ($gte) हो।

// Find all products with a price greater than 100
db.products.find({ price: { $gt: 100 } });संचालित द्वारा

$lt और $lte (से छोटा, छोटा या बराबर)

ये उन डॉक्यूमेंट्स को ढूँढते हैं जहाँ किसी फ़ील्ड का मान निर्दिष्ट मान से छोटा ($lt) या छोटा या बराबर ($lte) हो।

// Find all products with a price less than or equal to 50
db.products.find({ price: { $lte: 50 } });संचालित द्वारा

$ne (बराबर नहीं)

$ne उन डॉक्यूमेंट्स को ढूँढता है जहाँ कोई फ़ील्ड किसी निर्दिष्ट मान के बराबर नहीं है।

// Find all products that are NOT made by 'LogiTech'
db.products.find({ brand: { $ne: "LogiTech" } });संचालित द्वारा

$in और $nin (ऐरे में, ऐरे में नहीं)

ये उन डॉक्यूमेंट्स को ढूँढते हैं जहाँ किसी फ़ील्ड का मान किसी निर्दिष्ट मानों के ऐरे में ($in) या उसमें नहीं ($nin) है।

// Find all products from 'Razer' or 'Corsair'
db.products.find({ brand: { $in: ["Razer", "Corsair"] } });संचालित द्वारा

लॉजिकल ऑपरेटर

लॉजिकल ऑपरेटर कई शर्तों को मिलाकर जटिल क्वेरीज बनाते हैं।

$and

$and क्वेरी शर्तों को लॉजिकल AND के साथ जोड़ता है। सभी शर्तें सत्य होनी चाहिए।

// Find all products with a price greater than 50 AND are in stock
db.products.find({ $and: [{ price: { $gt: 50 } }, { inStock: true }] });
// This can be simplified by just listing the conditions:
// db.products.find({ price: { $gt: 50 }, inStock: true });संचालित द्वारा

$or

यह क्वेरी शर्तों को लॉजिकल OR के साथ जोड़ता है। कम से कम एक शर्त सत्य होनी चाहिए।

// Find all products with a brand of 'Corsair' OR a price less than 40
db.products.find({ $or: [{ brand: "Corsair" }, { price: { $lt: 40 } }] });संचालित द्वारा

एलीमेंट और इवैल्युएशन ऑपरेटर 

ये ऑपरेटर फ़िल्टरिंग के लिए और भी अधिक लचीलापन प्रदान करते हैं।

$exists

$exists उन डॉक्यूमेंट्स से मेल खाता है जिनमें कोई विशिष्ट फ़ील्ड मौजूद हो।

// Find all documents that have an 'inStock' field
db.products.find({ inStock: { $exists: true } });संचालित द्वारा

$regex

यह स्ट्रिंग फ़ील्ड्स में पैटर्न मिलान के लिए रेगुलर एक्सप्रेशंस का उपयोग करने देता है।

// Find all product names that start with 'Wireless'
db.products.find({ name: { $regex: /^Wireless/ } });संचालित द्वारा

अपने आउटपुट का रूप देना: प्रोजेक्शन

जब आप find() ऑपरेशन करते हैं, तो आप प्रत्येक डॉक्यूमेंट में केवल कुछ फ़ील्ड्स प्राप्त करने का चुनाव कर सकते हैं। इसे प्रोजेक्शन कहा जाता है और यह वह दूसरा आर्ग्युमेंट है जिसे आप find() में पास करते हैं। यह ट्रांसफ़र और प्रोसेस किए जाने वाले डेटा की मात्रा को कम करने में मदद करता है।

फ़ील्ड्स शामिल करना

आप जिन फ़ील्ड्स को लौटाना चाहते हैं उन्हें 1 सेट करके निर्दिष्ट कर सकते हैं।

// Find all products and return only the 'name' and 'price' fields
db.products.find({}, { name: 1, price: 1 });संचालित द्वारा

फ़ील्ड्स बाहर रखना

इसी तरह, जिन फ़ील्ड्स को छिपाना है उन्हें आप 0 सेट करके निर्दिष्ट कर सकते हैं।

// Find all products and hide the 'inStock' field
db.products.find({}, { inStock: 0 });संचालित द्वारा

_id फ़ील्ड डिफ़ॉल्ट रूप से हमेशा लौटाया जाता है, जब तक कि आप उसे स्पष्ट रूप से एक्सक्लूड न करें।

_id फ़ील्ड

_id फ़ील्ड छिपाने के लिए, आपको इसे स्पष्ट रूप से 0 पर सेट करना होगा।

// Find all products, returning only 'name' and 'price', and hiding '_id'
db.products.find({}, { _id: 0, name: 1, price: 1 });संचालित द्वारा

उन्नत डेटा ट्रांसफ़ॉर्मेशन: एग्रीगेशन पाइपलाइंस

एग्रीगेशन MongoDB में डेटा प्रोसेसिंग के लिए एक शक्तिशाली फ़्रेमवर्क है। एक एग्रीगेशन पाइपलाइन कई स्टेज़ की श्रृंखला से बनी होती है जो डॉक्यूमेंट्स को प्रोसेस करती है और परिणामों को एक स्टेज़ से अगली स्टेज़ तक पास करती है।

$match

एक $match स्टेज़ क्वेरी फ़िल्टर के आधार पर डॉक्यूमेंट्स को फ़िल्टर करती है, ठीक वैसे ही जैसे find() में। यह अक्सर प्रोसेस किए जाने वाले डॉक्यूमेंट्स की संख्या कम करने के लिए पहली स्टेज़ होती है।

// Find all products with a brand of 'LogiTech'
db.products.aggregate([
  { $match: { brand: "LogiTech" } }
]);संचालित द्वारा

$group

$group स्टेज़ डॉक्यूमेंट्स को किसी निर्दिष्ट _id एक्सप्रेशन के आधार पर समूहित करती है और विभिन्न एक्यूम्युलेटर ऑपरेशंस कर सकती है, जैसे किसी फ़ील्ड का योग या औसत निकालना।

// Group products by brand and calculate the total number of products for each brand
db.products.aggregate([
  { $group: { _id: "$brand", totalProducts: { $sum: 1 } } }
]);संचालित द्वारा

$project

एक $project स्टेज़ स्ट्रीम में प्रत्येक डॉक्यूमेंट को फिर से आकार देती है, जैसा कि find() में प्रोजेक्शन में होता है। आप नए फ़ील्ड्स जोड़ सकते हैं, मौजूदा को हटा सकते हैं और डेटा में परिवर्तन कर सकते हैं।

// Project a new field 'nameAndPrice' for each document
db.products.aggregate([
  { $project: { name: 1, price: 1, nameAndPrice: { $concat: ["$name", " (", "$price", ")"] } } }
]);संचालित द्वारा

$sort

$sort स्टेज़ किसी निर्दिष्ट फ़ील्ड के आधार पर डॉक्यूमेंट्स का क्रम बदलती है। मान 1 आरोही क्रम के लिए है, और -1 अवरोही के लिए।

// Sort all products by price in descending order
db.products.aggregate([
  { $sort: { price: -1 } }
]);संचालित द्वारा

$limit और $skip

ये स्टेज़ पेजिनेशन के लिए उपयोग होती हैं। $skip पाइपलाइन की शुरुआत से निर्दिष्ट संख्या के डॉक्यूमेंट्स को छोड़ देती है, और $limit अगले स्टेज़ तक पास किए जाने वाले डॉक्यूमेंट्स की संख्या सीमित करती है।

// Skip the first 10 products and then return the next 5
db.products.aggregate([
  { $skip: 10 },
  { $limit: 5 }
]);संचालित द्वारा

एक सरल पाइपलाइन उदाहरण

यह एक पूर्ण उदाहरण है जो दिखाता है कि ये स्टेज़ एक साथ कैसे काम करती हैं।

// Find the average price of all products that are currently in stock,
// grouped by brand.
db.products.aggregate([
  { $match: { inStock: true } }, // Filter for products in stock
  { $group: { _id: "$brand", averagePrice: { $avg: "$price" } } } // Group and calculate average price
]);संचालित द्वारा

प्रदर्शन बढ़ाना: इंडेक्सिंग

इंडेक्स विशेष डेटा संरचनाएँ हैं जो किसी कलेक्शन के डेटा के छोटे, आसानी से पार किए जाने वाले हिस्से को स्टोर करती हैं। वे MongoDB को पूरी कलेक्शन स्कैन किए बिना डॉक्यूमेंट्स को तेज़ी से ढूँढने और प्राप्त करने देने के कारण क्वेरी प्रदर्शन को काफी बेहतर करती हैं।

createIndex()

आप उस फ़ील्ड पर इंडेक्स बनाते हैं जिस पर आप अक्सर क्वेरी या सॉर्ट करते हैं।

// Create a single-field index on the 'brand' field
db.products.createIndex({ brand: 1 });संचालित द्वारा

यहाँ 1 इंडेक्स के लिए आरोही क्रम को दर्शाता है। आप -1 का उपयोग अवरोही क्रम के लिए कर सकते हैं, जो उस दिशा में सॉर्ट करने वाली क्वेरीज के लिए लाभदायक हो सकता है।

जैसे brand फ़ील्ड पर इंडेक्स बनाना उन क्वेरीज (जैसे, db.products.find({ brand: "Razer" })) को बहुत तेज़ी से निष्पादित करेगा जो brand द्वारा फ़िल्टर करती हैं, खासकर जब आपकी कलेक्शन बढ़ती है।

किस फ़ील्ड्स को इंडेक्स करना है: विचार

आम तौर पर आपको उन फ़ील्ड्स पर इंडेक्स बनाने चाहिए जिन्हें आप अपनी क्वेरीज में अक्सर उपयोग करते हैं, जैसे find() फ़िल्टर में या एग्रीगेशन के $match स्टेज़ में।

• कार्डिनैलिटी: जिन फ़ील्ड्स में बहुत सारे यूनिक मान (उच्च कार्डिनैलिटी) होते हैं, जैसे उपयोगकर्ता का ईमेल पता, वे इंडेक्स के लिए उत्कृष्ट उम्मीदवार हैं।
• क्वेरी चयनात्मकता: कोई ऐसा फ़ील्ड जो दी गई क्वेरी के लिए डॉक्यूमेंट्स का छोटा उपसमुच्चय लौटाता है, वह भी एक बढ़िया उम्मीदवार है।
• सॉर्टिंग: यदि आप अक्सर किसी विशेष फ़ील्ड द्वारा अपने क्वेरी परिणामों को सॉर्ट करते हैं, तो उस फ़ील्ड पर इंडेक्स बनाना सॉर्ट ऑपरेशन को बहुत तेज़ बना देगा।

क्वेरीज पर प्रभाव

इंडेक्स प्रदर्शन पर महत्वपूर्ण प्रभाव डालते हैं। किसी इंडेक्स वाली क्वेरी अक्सर बिना इंडेक्स वाली समान क्वेरी की तुलना में कई गुना तेज़ होती है।

// Conceptual illustration of performance difference

// Without an index on 'brand':
// MongoDB performs a full collection scan, checking every document.
// This is slow, especially with millions of documents.
db.products.find({ brand: "Razer" });

// With an index on 'brand':
// MongoDB uses the index to quickly locate and return only the matching documents.
// This is very fast.
db.products.find({ brand: "Razer" });संचालित द्वारा

क्वेरीज को और अनुकूलित करने के लिए, आप db.collection.explain() मेथड का उपयोग कर सकते हैं ताकि क्वेरी प्रदर्शन का विश्लेषण किया जा सके और देखा जा सके कि इंडेक्स कैसे उपयोग हो रहे हैं।

निष्कर्ष: MongoDB में प्रवीणता की आपकी यात्रा

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

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