MongoDB को जोड़ना और बनाना SQL का उपयोग करके जुड़ता है:भाग 2

जॉइन SQL और NoSQL डेटाबेस के बीच प्रमुख विशिष्ट विशेषताओं में से एक है। SQL डेटाबेस में, हम एक ही या अलग-अलग डेटाबेस में दो तालिकाओं के बीच JOIN कर सकते हैं। हालाँकि, MongoDB के लिए ऐसा नहीं है क्योंकि यह एक ही डेटाबेस में दो संग्रहों के बीच JOIN संचालन की अनुमति देता है।

MongoDB में जिस तरह से डेटा प्रस्तुत किया जाता है, उसे मूल स्क्रिप्ट क्वेरी फ़ंक्शंस का उपयोग करने के अलावा इसे एक संग्रह से दूसरे संग्रह में जोड़ना लगभग असंभव हो जाता है। MongoDB या तो संबंधित वस्तुओं को एक अलग दस्तावेज़ में संग्रहीत करके डेटा को सामान्य करता है या यह किसी अन्य अलग दस्तावेज़ में डेटा से संबंधित है।

कोई इस डेटा को मैन्युअल संदर्भों का उपयोग करके संबंधित कर सकता है जैसे कि एक दस्तावेज़ का _id फ़ील्ड जो किसी अन्य दस्तावेज़ में संदर्भ के रूप में सहेजा जाता है। फिर भी, प्रक्रिया को थोड़ा कठिन बनाते हुए, कुछ आवश्यक डेटा प्राप्त करने के लिए कई प्रश्नों को करने की आवश्यकता होती है।

इसलिए हम जॉइन अवधारणा का उपयोग करने का संकल्प लेते हैं जो डेटा के संबंध को सुविधाजनक बनाता है। MongoDB में जॉइन ऑपरेशन $lookup ऑपरेटर के उपयोग के माध्यम से प्राप्त किया जाता है, जिसे संस्करण 3.2 में पेश किया गया था।

$लुकअप ऑपरेटर

जॉइन अवधारणा के पीछे मुख्य विचार एक संग्रह से दूसरे संग्रह में डेटा के बीच सहसंबंध प्राप्त करना है। $lookup ऑपरेटर का मूल सिंटैक्स है:

{
   $lookup:
     {
       from: <collection to join>,
       localField: <field from the input documents>,
       foreignField: <field from the documents of the "from" collection>,
       as: <output array field>
     }
}

एसक्यूएल ज्ञान के संबंध में, हम हमेशा जानते हैं कि जॉइन ऑपरेशन का परिणाम स्थानीय और विदेशी तालिका से सभी क्षेत्रों को जोड़ने वाली एक अलग पंक्ति है। MongoDB के लिए, यह एक अलग मामला है जिसमें परिणाम दस्तावेज़ स्थानीय संग्रह दस्तावेज़ की एक सरणी के रूप में जोड़े जाते हैं। उदाहरण के लिए, हमारे पास दो संग्रह हैं; 'छात्र' और 'इकाइयाँ'

विद्यार्थी

{"_id" : 1,"name" : "James Washington","age" : 15.0,"grade" : "A","score" : 10.5}
{"_id" : 2,"name" : "Clinton Ariango","age" : 14.0,"grade" : "B","score" : 7.5}
{"_id" : 3,"name" : "Mary Muthoni","age" : 16.0,"grade" : "A","score" : 11.5}

इकाइयां

{"_id" : 1,"Maths" : "A","English" : "A","Science" : "A","History" : "B"}
{"_id" : 2,"Maths" : "B","English" : "B","Science" : "A","History" : "B"}
{"_id" : 3,"Maths" : "A","English" : "A","Science" : "A","History" : "A"}

हम जॉइन दृष्टिकोण के साथ $lookup ऑपरेटर का उपयोग करके संबंधित ग्रेड के साथ छात्र इकाइयों को पुनः प्राप्त कर सकते हैं। यानी

db.getCollection('students').aggregate([{
$lookup:
    {
        from: "units",
        localField: "_id",
        foreignField : "_id",
        as: "studentUnits"
    }
}])

जो हमें नीचे परिणाम देगा:

{"_id" : 1,"name" : "James Washington","age" : 15,"grade" : "A","score" : 10.5,
    "studentUnits" : [{"_id" : 1,"Maths" : "A","English" : "A","Science" : "A","History" : "B"}]}
{"_id" : 2,"name" : "Clinton Ariango","age" : 14,"grade" : "B","score" : 7.5,
    "studentUnits" : [{"_id" : 2,"Maths" : "B","English" : "B","Science" : "A","History" : "B"}]}
{"_id" : 3,"name" : "Mary Muthoni","age" : 16,"grade" : "A","score" : 11.5,
    "studentUnits" : [{"_id" : 3,"Maths" : "A","English" : "A","Science" : "A","History" : "A"}]}

जैसा कि पहले उल्लेख किया गया है, यदि हम SQL अवधारणा का उपयोग करके जॉइन करते हैं, तो हमें Studio3T प्लेटफॉर्म में अलग-अलग दस्तावेज़ों के साथ वापस कर दिया जाएगा।

SELECT *
  FROM students
    INNER JOIN units
      ON students._id = units._id

db.getCollection("students").aggregate(
    [
        { 
            "$project" : {
                "_id" : NumberInt(0), 
                "students" : "$$ROOT"
            }
        }, 
        { 
            "$lookup" : {
                "localField" : "students._id", 
                "from" : "units", 
                "foreignField" : "_id", 
                "as" : "units"
            }
        }, 
        { 
            "$unwind" : {
                "path" : "$units", 
                "preserveNullAndEmptyArrays" : false
            }
        }
    ]
);

उपरोक्त SQL क्वेरी नीचे दिए गए परिणाम लौटाएगी:

{ "students" : {"_id" : NumberInt(1),"name" : "James Washington","age" : 15.0,"grade" : "A","score" : 10.5}, 
    "units" : {"_id" : NumberInt(1),"Maths" : "A","English" : "A","Science" : "A","History" : "B"}}
{ "students" : {"_id" : NumberInt(2), "name" : "Clinton Ariango","age" : 14.0,"grade" : "B","score" : 7.5 }, 
    "units" : {"_id" : NumberInt(2),"Maths" : "B","English" : "B","Science" : "A","History" : "B"}}
{ "students" : {"_id" : NumberInt(3),"name" : "Mary Muthoni","age" : 16.0,"grade" : "A","score" : 11.5},
"units" : {"_id" : NumberInt(3),"Maths" : "A","English" : "A","Science" : "A","History" : "A"}}

प्रदर्शन की अवधि स्पष्ट रूप से आपकी क्वेरी की संरचना पर निर्भर करेगी। उदाहरण के लिए, यदि आपके पास एक संग्रह में दूसरे के ऊपर कई दस्तावेज़ हैं, तो आपको संग्रह से कम दस्तावेज़ों के साथ एकत्रीकरण करना चाहिए और फिर अधिक दस्तावेज़ों वाले संग्रह में देखना चाहिए। इस तरह, कम दस्तावेज़ संग्रह से चुने गए फ़ील्ड की तलाश काफी इष्टतम है और अधिक दस्तावेज़ों के साथ संग्रह में चुने गए फ़ील्ड के लिए एकाधिक लुकअप करने से कम समय लगता है। इसलिए यह सलाह दी जाती है कि पहले छोटे संग्रह को रखा जाए।

एक रिलेशनल डेटाबेस के लिए, डेटाबेस का क्रम कोई मायने नहीं रखता क्योंकि अधिकांश SQL दुभाषियों के पास ऑप्टिमाइज़र होते हैं, जिनके पास यह तय करने के लिए अतिरिक्त जानकारी तक पहुँच होती है कि कौन सा पहले होना चाहिए।

मोंगोडीबी के मामले में, हमें जॉइन ऑपरेशन को सुविधाजनक बनाने के लिए एक इंडेक्स का उपयोग करने की आवश्यकता होगी। हम सभी जानते हैं कि सभी MongoDB दस्तावेज़ों में एक _id कुंजी होती है जिसे एक संबंधपरक DBM के लिए प्राथमिक कुंजी माना जा सकता है। एक इंडेक्स $lookup विदेशी कुंजी में उपयोग किए जाने पर ऑपरेशन का समर्थन करने के अलावा उस डेटा की मात्रा को कम करने का एक बेहतर मौका प्रदान करता है जिसे एक्सेस करने की आवश्यकता होती है।

एकत्रीकरण पाइपलाइन में, एक इंडेक्स का उपयोग करने के लिए, हमें यह सुनिश्चित करना होगा कि मानदंड से मेल नहीं खाने वाले दस्तावेज़ों को फ़िल्टर करने के लिए $match पहले चरण में किया गया हो। उदाहरण के लिए यदि हम 1 के बराबर _id फ़ील्ड मान वाले छात्र के लिए परिणाम प्राप्त करना चाहते हैं:

select * 
from students 
  INNER JOIN units 
    ON students._id = units._id 
      WHERE students._id = 1;

इस मामले में आपको जो समान MongoDB कोड मिलेगा वह है:

db.getCollection("students").aggregate(
[{"$project" : { "_id" : NumberInt(0), "students" : "$$ROOT" }}, 
     {  "$lookup" : {"localField" : "students._id", "from" : "units",  "foreignField" : "_id",  "as" : "units"} }, 
     { "$unwind" : { "path" : "$units","preserveNullAndEmptyArrays" : false } }, 
      { "$match" : {"students._id" : NumberLong(1) }}
    ]);

उपरोक्त क्वेरी के लिए दिया गया परिणाम होगा:

{"_id" : 1,"name" : "James Washington","age" : 15,"grade" : "A","score" : 10.5,
    "studentUnits" : [{"_id" : 1,"Maths" : "A","English" : "A","Science" : "A","History" : "B"}]}

जब हम $match चरण का उपयोग नहीं करते हैं या पहले चरण में नहीं करते हैं, यदि हम व्याख्या फ़ंक्शन के साथ जांच करते हैं, तो हमें COLLSCAN चरण भी शामिल होगा। दस्तावेज़ों के एक बड़े सेट के लिए कोलस्कैन करने में आम तौर पर बहुत समय लगता है। इस प्रकार हम एक इंडेक्स फ़ील्ड का उपयोग करने का संकल्प लेते हैं जिसमें व्याख्या कार्य में केवल IXSCAN चरण शामिल होता है। उत्तरार्द्ध का एक फायदा है क्योंकि हम दस्तावेजों में एक सूचकांक की जांच कर रहे हैं और सभी दस्तावेजों के माध्यम से स्कैन नहीं कर रहे हैं; परिणाम लौटने में देर नहीं लगेगी। आपके पास एक अलग डेटा संरचना हो सकती है जैसे:

{    "_id" : NumberInt(1), 
    "grades" : {"Maths" : "A", "English" : "A",  "Science" : "A", "History" : "B"
    }
}

हो सकता है कि हम ग्रेड को संपूर्ण एम्बेडेड ग्रेड फ़ील्ड के बजाय एक सरणी में विभिन्न निकायों के रूप में वापस करना चाहें।

उपरोक्त SQL क्वेरी लिखने के बाद, हमें परिणामी MongoDB कोड को संशोधित करने की आवश्यकता है। ऐसा करने के लिए, एग्रीगेशन कोड को कॉपी करने के लिए नीचे दाईं ओर कॉपी आइकन पर क्लिक करें:

इसके बाद एग्रीगेशन टैब पर जाएं और प्रस्तुत फलक पर, एक पेस्ट आइकन है, कोड पेस्ट करने के लिए उस पर क्लिक करें।

पहले चरण के रूप में चरण को शीर्ष पर ले जाने के लिए $match पंक्ति और फिर हरे रंग के ऊपर-तीर पर क्लिक करें। हालांकि, आपको पहले अपने संग्रह में एक इंडेक्स बनाना होगा जैसे:

db.students.createIndex(
   { _id: 1 },
   { name: studentId }
)

आपको कोड का नमूना नीचे मिलेगा:

db.getCollection("students").aggregate(
    [{ "$match" : {"_id" : 1.0}},
  { "$project" : {"_id" : NumberInt(0),"students" : "$$ROOT"}}, 
      { "$lookup" : {"localField" : "students._id","from" : "units","foreignField" : "_id","as" : "units"}}, 
      { "$unwind" : {"path" : "$units", "preserveNullAndEmptyArrays" : false}}
    ]

इस कोड के साथ हम नीचे परिणाम प्राप्त करेंगे:

{ "students" : {"_id" : NumberInt(1), "name" : "James Washington","age" : 15.0,"grade" : "A", "score" : 10.5}, 
    "units" : {"_id" : NumberInt(1), "grades" : {"Maths" : "A", "English" : "A", "Science" : "A",  "History" : "B"}}}

लेकिन हमें केवल यह चाहिए कि ग्रेड को लौटाए गए दस्तावेज़ में एक अलग दस्तावेज़ इकाई के रूप में रखा जाए, न कि उपरोक्त उदाहरण के रूप में। इसलिए हम $addfields चरण को नीचे के रूप में कोड जोड़ देंगे।

db.getCollection("students").aggregate(
    [{ "$match" : {"_id" : 1.0}},
  { "$project" : {"_id" : NumberInt(0),"students" : "$$ROOT"}}, 
      { "$lookup" : {"localField" : "students._id","from" : "units","foreignField" : "_id","as" : "units"}}, 
      { "$unwind" : {"path" : "$units", "preserveNullAndEmptyArrays" : false}},
      { "$addFields" : {"units" : "$units.grades"} }]

परिणामी दस्तावेज तब होंगे:

{
"students" : {"_id" : NumberInt(1), "name" : "James Washington", "grade" : "A","score" : 10.5}, 
     "units" : {"Maths" : "A", "English" : "A",  "Science" : "A", "History" : "B"}
}

लौटाया गया डेटा काफी साफ-सुथरा है, क्योंकि हमने एक अलग क्षेत्र के रूप में इकाइयों के संग्रह से एम्बेडेड दस्तावेज़ों को हटा दिया है।

हमारे अगले ट्यूटोरियल में, हम कई जॉइन के साथ प्रश्नों पर गौर करने जा रहे हैं।