MongoDB डॉट नोटेशन ट्यूटोरियल: नेस्टेड फ़ील्ड्स को क्वेरी करना

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

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

डॉट नोटेशन से हमारा आशय नेस्टेड फ़ील्ड्स को पीरियड कैरेक्टर डिलिमिटर से अलग करने से है। उदाहरण के लिए:

root_field.nested_field_1.next_layer_nested_field_1

नेस्टिंग की हर लेयर के लिए, क्वेरी करते समय हम बस उस लेयर के बीच में एक पीरियड जोड़ते हैं। जैसे-जैसे हम ट्यूटोरियल में आगे बढ़ेंगे, और विस्तृत उदाहरण देखेंगे।

यदि आप MongoDB के साथ शुरुआत कर रहे हैं, तो DataCamp का Introduction to MongoDB in Python कोर्स ज़रूर देखें।

पूर्वापेक्षाएँ

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

इस उदाहरण के लिए, हम "dbinc" डेटाबेस और "people" कलेक्शन के भीतर निम्न डेटा का उपयोग करेंगे:

[
    {
        "name": "Nic Raboy",
        "websites": [
            {
                "type": "other",
                "name": "Portfolio",
                "url": "https://www.nraboy.com"
            },
            {
                "type": "social",
                "name": "LinkedIn",
                "url": "https://www.linkedin.com/in/nraboy"
            }
        ],
        "employment": {
            "employer": "MongoDB",
            "address": {
                "street": "1633 Broadway",
                "city": "New York",
                "state": "New York",
                "postal_code": 10019
            }
        }
    },
    {
        "name": "Tony Kim",
        "websites": [
            {
                "type": "social",
                "name": "LinkedIn",
                "url": "https://www.linkedin.com/in/hyung-kim/"
            },
            {
                "type": "coding",
                "name": "GitHub",
                "url": "https://github.com/hjkmines"
            }
        ],
        "employment": {
            "employer": "MongoDB",
            "address": {
                "street": "1633 Broadway",
                "city": "New York",
                "state": "New York",
                "postal_code": 10019
            }
        }
    }
]

ऊपर दिया गया डेटा दो डॉक्युमेंट्स का प्रतिनिधित्व करता है जो नेस्टेड ऑब्जेक्ट्स और एरेज़ होने के कारण काफ़ी जटिल हैं। एक दिलचस्प तथ्य यह है कि MongoDB BSON डॉक्युमेंट्स में 100 से अधिक स्तरों की नेस्टिंग को सपोर्ट करता है।

यदि आप साथ-साथ अभ्यास करने की योजना बना रहे हैं, तो सुनिश्चित करें कि ये डॉक्युमेंट्स आपके MongoDB इंस्टेंस में मौजूद हों।

विभिन्न तरीकों से MongoDB में डेटा क्वेरी करना

हम सरल से शुरू करेंगे और धीरे-धीरे अधिक जटिल हिस्सों की ओर बढ़ेंगे। अच्छी बात यह है कि यहाँ जटिल का अर्थ आवश्यक रूप से कठिन नहीं है।

मान लीजिए कि हम अपने कलेक्शन में उन सभी लोगों को खोजना चाहते हैं जो MongoDB के लिए काम करते हैं। हम निम्न जैसी क्वेरी चला सकते हैं:

use dbinc;

db.people.find({
	"employment.employer": "MongoDB"
});

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

use dbinc;

db.people.find({
	"employment.address.state": "New York"
});

ऊपर की क्वेरी में हमने डॉक्युमेंट के भीतर तीन स्तर तक क्वेरी किया, और यह बिना किसी समस्या के काम कर गया।

अब, आइए उस नेस्टेड ऑब्जेक्ट्स के एरे के साथ काम करना देखें। हम जो करना चाहते हैं, उसके अनुसार क्वेरी करने के कुछ तरीके हैं।

मान लीजिए कि हम उन सभी लोगों को वापस पाना चाहते हैं जिनके पास "Portfolio" वेबसाइट सूचीबद्ध है। हम निम्न जैसी क्वेरी चला सकते हैं:

use dbinc;

db.people.find({
	"websites.name": "Portfolio"
});

ऊपर की क्वेरी एक ही परिणाम देगी क्योंकि केवल एक डॉक्युमेंट में "Portfolio" सूचीबद्ध था। ध्यान दें कि एरे होने के बावजूद, यहाँ भी डॉट नोटेशन काम करता है। बारीकी यह है कि "Portfolio" उस एरे में कहीं न कहीं कम-से-कम एक बार मौजूद होना चाहिए।

यहीं से चीज़ें दिलचस्प हो सकती हैं।

मान लीजिए कि हम लौटाए जा रहे परिणामों को और सीमित करना चाहते हैं। हम अधिक फ़िल्टर मानदंड जोड़कर ऐसा करेंगे, लेकिन जब एरेज़ के भीतर नेस्टेड ऑब्जेक्ट्स के साथ काम करते हैं, तो चीज़ें थोड़ी अलग होती हैं। उदाहरण के लिए, निम्न लें:

use dbinc;

db.people.find({
    "websites.name": "Portfolio",
    "websites.type": "social"
});

ऊपर के उदाहरण में, हम कह रहे हैं कि हमें ऐसे परिणाम चाहिए जहाँ "Portfolio" और "social" दोनों एरे में मौजूद हों, पर ज़रूरी नहीं कि उसी ऑब्जेक्ट में हों। हमें केवल एक परिणाम मिलता है क्योंकि "Tony Kim" डॉक्युमेंट में "social" है, पर "Portfolio" नहीं। यदि हमें ऐसे परिणाम चाहिए हों जहाँ दोनों फ़ील्ड्स एक ही ऑब्जेक्ट में मौजूद हों, तो हम उसके लिए डॉट नोटेशन का उपयोग नहीं कर पाएंगे।

हालाँकि यह इस विशेष ट्यूटोरियल के दायरे से बाहर है, $elemMatch ऑपरेटर का इस तरह उपयोग करने से काम हो जाएगा:

use dbinc;

db.people.find(
    { 
        "websites": { 
            "$elemMatch": { 
                "name": "Portfolio",
                "type": "social" 
            }
        }
    }
);

ऊपर की स्थिति में कोई परिणाम वापस नहीं आएगा क्योंकि हमारे सैंपल डेटा में एक ही ऑब्जेक्ट के भीतर मिलते-जुलते name और type मौजूद नहीं हैं।

यदि आप एरेज़ के साथ काम कर रहे हैं और आपको उस एरे का इंडेक्स पता है जिसके साथ आप काम करना चाहते हैं, तो आप डॉट नोटेशन का उपयोग जारी रख सकते हैं। उदाहरण के लिए, निम्न देखें:

use dbinc;

db.people.find({
    "websites.0.name": "Portfolio"
});

ऊपर की क्वेरी उस एरे के इंडेक्स का उपयोग करती है जिसके विरुद्ध आप मिलान करना चाहते हैं। इस परिदृश्य में, हम वे सभी डॉक्युमेंट लौटाना चाहते हैं जहाँ एरे की पहली आइटम का name "Portfolio" हो।

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

निष्कर्ष

आपने अभी अपने MongoDB क्वेरियों में डॉट नोटेशन का एक त्वरित परिचय देखा। हमने सीखा:

• डॉट नोटेशन नेस्टेड ऑब्जेक्ट्स के लिए काम करता है।
• आप एरेज़ के लिए डॉट नोटेशन का उपयोग कर सकते हैं, लेकिन आपकी अपेक्षाओं के आधार पर कुछ सीमाएँ होती हैं।
• $elemMatch ऑपरेटर आवश्यक है यदि आप किसी एकल एरे ऑब्जेक्ट के भीतर कई फ़ील्ड्स का मिलान करना चाहते हैं।
• यदि आप एरे में विशिष्ट तत्वों पर क्वेरी करना चाहते हैं, तो डॉट नोटेशन में एरे इंडेक्स का उपयोग किया जा सकता है।

आपकी MongoDB कलेक्शंस में डेटा संभवतः फ्लैट नहीं होगा, यानी किसी बिंदु पर आपके पास नेस्टेड ऑब्जेक्ट्स, नेस्टेड एरेज़, ऑब्जेक्ट्स के भीतर नेस्टेड एरेज़ और अन्य किसी भी जटिल संयोजन होंगे। अच्छी बात यह है कि MongoDB समृद्ध क्वेरी API के माध्यम से इस जानकारी के साथ काम करना आसान बनाता है।

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