यदि आप SQL से परिचित हैं, तो आप UNION . के बारे में जान सकते हैं क्लॉज, जो दो प्रश्नों के परिणामों को एक परिणाम सेट में जोड़ता है। विशेष रूप से, UNION ALL डुप्लिकेट शामिल हैं।
MongoDB में, हम $unionWith . का उपयोग कर सकते हैं एकत्रीकरण पाइपलाइन चरण उसी प्रभाव को प्राप्त करने के लिए जो UNION ALL . है पैदा करता है। $unionWith चरण दो संग्रहों का एक संघ करता है - यह दो संग्रहों से पाइपलाइन परिणामों को एक एकल परिणाम सेट में जोड़ता है। और इसमें डुप्लीकेट शामिल हैं।
उदाहरण
मान लीजिए हम दो संग्रह बनाते हैं; एक जिसे cats . कहा जाता है और दूसरे को dogs . कहा जाता है . और हम उनमें निम्नलिखित दस्तावेज़ सम्मिलित करते हैं:
db.cats.insertMany([
{ _id: 1, name: "Fluffy", type: "Cat", weight: 5 },
{ _id: 2, name: "Scratch", type: "Cat", weight: 3 },
{ _id: 3, name: "Meow", type: "Cat", weight: 7 }
])
db.dogs.insertMany([
{ _id: 1, name: "Wag", type: "Dog", weight: 20 },
{ _id: 2, name: "Bark", type: "Dog", weight: 10 },
{ _id: 3, name: "Fluffy", type: "Dog", weight: 40 }
])
अब हम उन संग्रहों के विरुद्ध एक क्वेरी चला सकते हैं और $unionWith . का उपयोग कर सकते हैं प्रत्येक प्रश्न के परिणामों को संयोजित करने का चरण।
उदाहरण:
db.cats.aggregate( [
{ $set: { _id: "$_id" } },
{ $unionWith: { coll: "dogs", pipeline: [ { $set: { _id: "$_id" } } ] } },
{ $sort: { type: 1, weight: -1, name: 1 } }
] )परिणाम:
{ "_id" : 3, "name" : "Meow", "type" : "Cat", "weight" : 7 }
{ "_id" : 1, "name" : "Fluffy", "type" : "Cat", "weight" : 5 }
{ "_id" : 2, "name" : "Scratch", "type" : "Cat", "weight" : 3 }
{ "_id" : 3, "name" : "Fluffy", "type" : "Dog", "weight" : 40 }
{ "_id" : 1, "name" : "Wag", "type" : "Dog", "weight" : 20 }
{ "_id" : 2, "name" : "Bark", "type" : "Dog", "weight" : 10 }
इस उदाहरण में, प्रत्येक दस्तावेज़ में cat . के साथ एक प्रकार का फ़ील्ड होता है या dog और इसलिए यह बिल्कुल स्पष्ट है कि कौन सा दस्तावेज़ किस संग्रह से आता है।
लेकिन अगर दस्तावेज़ों में टाइप फ़ील्ड नहीं है, तो यह पता लगाना कठिन होगा कि एक संग्रह कहाँ समाप्त होता है और दूसरा शुरू होता है। इस मामले में, हम $set . पर एक स्ट्रिंग अक्षर का उपयोग कर सकते हैं संग्रह नाम का प्रतिनिधित्व करने के लिए मंच।
उदाहरण:
db.cats.aggregate( [
{ $set: { _id: "cat" } },
{ $unionWith: { coll: "dogs", pipeline: [ { $set: { _id: "dog" } } ] } },
{ $sort: { type: 1, weight: -1, name: 1 } }
] )परिणाम:
{ "_id" : "cat", "name" : "Meow", "type" : "Cat", "weight" : 7 }
{ "_id" : "cat", "name" : "Fluffy", "type" : "Cat", "weight" : 5 }
{ "_id" : "cat", "name" : "Scratch", "type" : "Cat", "weight" : 3 }
{ "_id" : "dog", "name" : "Fluffy", "type" : "Dog", "weight" : 40 }
{ "_id" : "dog", "name" : "Wag", "type" : "Dog", "weight" : 20 }
{ "_id" : "dog", "name" : "Bark", "type" : "Dog", "weight" : 10 } संग्रहों में क्रमित करना
पिछले उदाहरणों में, बिल्लियों और कुत्तों को इस तरह से क्रमबद्ध किया गया था कि उन्हें दो अलग-अलग समूहों में विभाजित किया गया था; पहले बिल्लियाँ, फिर कुत्ते। यह मुख्य रूप से इसलिए हुआ क्योंकि हमने type . के आधार पर सॉर्ट किया था पहले क्षेत्र।
लेकिन हम इसे किसी अन्य फ़ील्ड पर सॉर्ट कर सकते हैं, जिसके परिणामस्वरूप बिल्लियों और कुत्तों को जोड़ा जा सकता है।
उदाहरण:
db.cats.aggregate( [
{ $set: { _id: "cat" } },
{ $unionWith: { coll: "dogs", pipeline: [ { $set: { _id: "dog" } } ] } },
{ $sort: { name: 1 } }
] )परिणाम:
{ "_id" : "dog", "name" : "Bark", "type" : "Dog", "weight" : 10 }
{ "_id" : "cat", "name" : "Fluffy", "type" : "Cat", "weight" : 5 }
{ "_id" : "dog", "name" : "Fluffy", "type" : "Dog", "weight" : 40 }
{ "_id" : "cat", "name" : "Meow", "type" : "Cat", "weight" : 7 }
{ "_id" : "cat", "name" : "Scratch", "type" : "Cat", "weight" : 3 }
{ "_id" : "dog", "name" : "Wag", "type" : "Dog", "weight" : 20 } अनुमान
आप $project . का उपयोग कर सकते हैं यह निर्दिष्ट करने के लिए चरण कि पाइपलाइन में अगले चरण में किन क्षेत्रों को पारित किया जाना है। उदाहरण के लिए, इसलिए आप क्वेरी द्वारा लौटाए गए फ़ील्ड की संख्या कम कर सकते हैं।
उदाहरण:
db.cats.aggregate( [
{ $project: { name: 1, _id: 0 } },
{ $unionWith: { coll: "dogs", pipeline: [ { $project: { name: 1, _id: 0 } } ]} }
] )परिणाम:
{ "name" : "Fluffy" }
{ "name" : "Scratch" }
{ "name" : "Meow" }
{ "name" : "Wag" }
{ "name" : "Bark" }
{ "name" : "Fluffy" } डुप्लिकेट निकालें
आप $group . का उपयोग कर सकते हैं परिणाम से अनावश्यक डुप्लिकेट को समाप्त करने के लिए चरण।
उदाहरण के लिए, पिछली क्वेरी ने Fluffy नामक दो पालतू जानवर लौटाए। हम एक $group जोड़ सकते हैं अनावश्यक डुप्लिकेट को समाप्त करने के लिए उस क्वेरी को चरणबद्ध करें, ताकि केवल एक Fluffy लौटाया जा सके।
db.cats.aggregate( [
{ $project: { name: 1, _id: 0 } },
{ $unionWith: { coll: "dogs", pipeline: [ { $project: { name: 1, _id: 0 } } ]} },
{ $group: { _id: "$name" } }
] )परिणाम:
{ "_id" : "Meow" }
{ "_id" : "Bark" }
{ "_id" : "Scratch" }
{ "_id" : "Wag" }
{ "_id" : "Fluffy" } इस बार, केवल एक Fluffy लौटाया गया है।
मेल न खाने वाले कॉलम
MongoDB के $unionWith . के फायदों में से एक SQL का UNION ALL से अधिक है यह है कि इसका उपयोग गैर-मिलान वाले स्तंभों के साथ किया जा सकता है।
एसक्यूएल UNION खंड की आवश्यकता है कि:
- दोनों क्वेरीज़ समान संख्या में कॉलम लौटाती हैं
- एक ही क्रम में कॉलम
- मिलान वाले कॉलम संगत डेटा प्रकार के होने चाहिए
MongoDB $unionWith मंच इन सीमाओं को लागू नहीं करता है।
इसलिए, हम $unionWith . का उपयोग कर सकते हैं ऐसा कुछ करने के लिए:
db.cats.aggregate( [
{ $set: { _id: "$_id" } },
{ $unionWith: { coll: "employees", pipeline: [ { $set: { _id: "$_id" } } ] } },
{ $sort: { type: 1, salary: -1 } }
] )परिणाम:
{ "_id" : 2, "name" : "Sarah", "salary" : 128000 }
{ "_id" : 5, "name" : "Beck", "salary" : 82000 }
{ "_id" : 4, "name" : "Chris", "salary" : 45000 }
{ "_id" : 3, "name" : "Fritz", "salary" : 25000 }
{ "_id" : 1, "name" : "Fluffy", "type" : "Cat", "weight" : 5 }
{ "_id" : 2, "name" : "Scratch", "type" : "Cat", "weight" : 3 }
{ "_id" : 3, "name" : "Meow", "type" : "Cat", "weight" : 7 }
इस मामले में, हम cats . में शामिल हो गए employees . के साथ संग्रह संग्रह। employees संग्रह में cats . के समान फ़ील्ड नहीं थे संग्रह, लेकिन यह ठीक है - यह अभी भी काम कर रहा है।
