मोंगोडीबी $ मर्जऑब्जेक्ट्स

MongoDB में, $mergeObjects एग्रीगेशन पाइपलाइन ऑपरेटर कई दस्तावेज़ों को एक दस्तावेज़ में जोड़ता है।

सिंटैक्स

$mergeObjects ऑपरेटर दो सिंटैक्स का समर्थन करता है।

सिंटैक्स 1:

{ $mergeObjects: [ <document1>, <document2>, ... ] }

सिंटैक्स 2:

{ $mergeObjects: <document> }

पहला सिंटैक्स कई तर्कों को स्वीकार करता है और दूसरा सिंटैक्स एक तर्क को स्वीकार करता है।

सिंटैक्स 1 का उदाहरण (एकाधिक तर्क)

पहले सिंटैक्स में $mergeObjects . प्रदान करना शामिल है एक से अधिक तर्क/दस्तावेज़ के साथ। $mergeObjects फिर उन दस्तावेज़ों को एक में मिला देता है।

मान लीजिए हमारे पास users . नामक संग्रह है निम्नलिखित दस्तावेज़ के साथ:

{
	"_id" : 1,
	"name" : {
		"f_name" : "Homer",
		"l_name" : "Simpson"
	},
	"contact" : {
		"email" : "example@sqldat.com",
		"ph" : null
	}
}

हम $mergeObjects . का उपयोग कर सकते हैं nameको मर्ज करने के लिए और contact फ़ील्ड:

db.users.aggregate(
  [
    {
      $project:
        { 
          user: { $mergeObjects: [ "$name", "$contact" ] }
        }
    }
  ]
).pretty()

परिणाम:

{
	"_id" : 1,
	"user" : {
		"f_name" : "Homer",
		"l_name" : "Simpson",
		"email" : "example@sqldat.com",
		"ph" : null
	}
}

इस मामले में, हमने दोनों फ़ील्ड को user . नामक एक फ़ील्ड में मर्ज कर दिया है . यदि हमारे पास अधिक फ़ील्ड/दस्तावेज़ होते तो हम उन्हें भी मर्ज कर सकते थे यदि हम चाहते थे।

डुप्लिकेट फ़ील्ड नाम

यदि मर्ज किए जाने वाले दस्तावेज़ों में डुप्लिकेट फ़ील्ड नाम हों, तो $mergeObjects फ़ील्ड को अधिलेखित कर देता है क्योंकि यह दस्तावेज़ों को मर्ज करता है। इसलिए, परिणामी दस्तावेज़ के फ़ील्ड में उस फ़ील्ड के लिए मर्ज किए गए अंतिम दस्तावेज़ का मान होता है।

मान लीजिए हमारे पास निम्नलिखित दस्तावेज़ हैं:

{
	"_id" : 2,
	"name" : {
		"f_name" : "Peter",
		"l_name" : "Griffin"
	},
	"contact" : {
		"email" : "example@sqldat.com",
		"f_name" : "Bart"
	}
}

हम देख सकते हैं कि दोनों दस्तावेज़ों में f_name . नामक एक फ़ील्ड है .

यहां बताया गया है कि जब हम उन दस्तावेज़ों को मर्ज करते हैं तो क्या होता है:

db.users.aggregate(
  [
    { $match: { _id: 2 } },
    {
      $project:
        { 
          user: { $mergeObjects: [ "$name", "$contact" ] }
        }
    }
  ]
).pretty()

परिणाम:

{
	"_id" : 2,
	"user" : {
		"f_name" : "Bart",
		"l_name" : "Griffin",
		"email" : "example@sqldat.com"
	}
}

f_name परिणामी दस्तावेज़ में फ़ील्ड में Bart है , जो कि विलय किए गए अंतिम दस्तावेज़ का मान है।

शून्य मान

अगर किसी दस्तावेज़ को null के साथ मर्ज किया जा रहा है , परिणामी दस्तावेज़ बिना किसी परिवर्तन के वापस कर दिया जाएगा।

लेकिन अगर मर्ज किए जाने वाले सभी दस्तावेज़ null हैं , फिर एक खाली दस्तावेज़ लौटा दिया जाता है।

मान लीजिए हमारे पास निम्नलिखित दस्तावेज हैं:

{
	"_id" : 3,
	"name" : {
		"f_name" : "Hubert",
		"l_name" : "Farnsworth"
	},
	"contact" : null
}
{ "_id" : 4, "name" : null, "contact" : null }

यहां बताया गया है कि जब हम name . को मर्ज करते हैं तो क्या होता है और contact उन दो दस्तावेज़ों में फ़ील्ड:

db.users.aggregate(
  [
    { $match: { _id: { $in: [ 3, 4 ] } } },
    {
      $project:
        { 
          user: { $mergeObjects: [ "$name", "$contact" ] }
        }
    }
  ]
)

परिणाम:

{ "_id" : 3, "user" : { "f_name" : "Hubert", "l_name" : "Farnsworth" } }
{ "_id" : 4, "user" : {  } }

सिंटैक्स 2 के उदाहरण (एकल तर्क)

यहां दो उदाहरण दिए गए हैं जो एकल तर्क सिंटैक्स का उपयोग करते हैं।

$group स्टेज एक्यूमुलेटर

पहले उदाहरण में, $mergeObjects $group . के रूप में प्रयोग किया जाता है मंच संचायक।

मान लीजिए हमारे पास products . नामक संग्रह है निम्नलिखित दस्तावेजों के साथ:

{
	"_id" : 1,
	"product" : "Shirt",
	"inventory" : {
		"blue" : 10,
		"red" : 2
	}
}
{
	"_id" : 2,
	"product" : "Shirt",
	"inventory" : {
		"green" : 3,
		"black" : 1
	}
}
{
	"_id" : 3,
	"product" : "Shorts",
	"inventory" : {
		"blue" : 2,
		"red" : 8
	}
}
{
	"_id" : 4,
	"product" : "Shorts",
	"inventory" : {
		"green" : 5,
		"black" : 3
	}
}

हम इन दस्तावेज़ों को उनके product . के आधार पर समूहित कर सकते हैं फ़ील्ड, और फिर $mergeObjects . का उपयोग करें inventory को मर्ज करने के लिए प्रत्येक समूह के लिए फ़ील्ड:

db.products.aggregate( [
   { $group: { 
     _id: "$product", 
     mergedProducts: { $mergeObjects: "$inventory" } 
     } 
    }
]).pretty()

परिणाम:

{
	"_id" : "Shorts",
	"mergedProducts" : {
		"blue" : 2,
		"red" : 8,
		"green" : 5,
		"black" : 3
	}
}
{
	"_id" : "Shirt",
	"mergedProducts" : {
		"blue" : 10,
		"red" : 2,
		"green" : 3,
		"black" : 1
	}
}

सरणी

यह उदाहरण लागू होता है $mergeObjects एक दस्तावेज़ के लिए जिसमें दस्तावेज़ों की एक सरणी के साथ एक फ़ील्ड है।

मान लीजिए हमारे पास test . नामक संग्रह है निम्नलिखित दस्तावेजों के साथ:

{
	"_id" : 1,
	"data" : [
		{
			"a" : 1,
			"b" : 2
		},
		{
			"c" : 3,
			"d" : 4
		}
	]
}

हम $mergeObjects . लागू कर सकते हैं data . के लिए फ़ील्ड:

db.test.aggregate(
  [
    {
      $project:
        { 
          result: { $mergeObjects: "$data" }
        }
    }
  ]
)

परिणाम:

{ "_id" : 1, "result" : { "a" : 1, "b" : 2, "c" : 3, "d" : 4 } }

अनुपलब्ध फ़ील्ड

$mergeObjects किसी भी लापता फ़ील्ड को अनदेखा करता है। यही है, यदि आप किसी ऐसे क्षेत्र की आपूर्ति करते हैं जो मौजूद नहीं है, तो वह इसे अनदेखा कर देता है। यदि कोई भी फ़ील्ड मौजूद नहीं है, तो यह एक खाली दस्तावेज़ देता है।

उदाहरण:

db.users.aggregate(
  [
    {
      $project:
        { 
          user: { $mergeObjects: [ "$name", "$oops" ] }
        }
    }
  ]
).pretty()

परिणाम:

{ "_id" : 1, "user" : { "f_name" : "Homer", "l_name" : "Simpson" } }
{ "_id" : 2, "user" : { "f_name" : "Peter", "l_name" : "Griffin" } }
{ "_id" : 3, "user" : { "f_name" : "Hubert", "l_name" : "Farnsworth" } }
{ "_id" : 4, "user" : { } }

हालांकि, यहां क्या होता है जब कोई नहीं फ़ील्ड मौजूद हैं:

db.users.aggregate(
  [
    {
      $project:
        { 
          user: { $mergeObjects: [ "$wrong", "$oops" ] }
        }
    }
  ]
).pretty()

परिणाम:

{ "_id" : 1, "user" : { } }
{ "_id" : 2, "user" : { } }
{ "_id" : 3, "user" : { } }
{ "_id" : 4, "user" : { } }

परिणाम एक खाली दस्तावेज़ है।

एकल-तर्क सिंटैक्स का उपयोग करते समय भी ऐसा ही होता है।

उदाहरण:

db.products.aggregate( [
   { $group: { 
     _id: "$product", 
     mergedProducts: { $mergeObjects: "$oops!" } 
     } 
    }
]).pretty()

परिणाम:

{ "_id" : "Shorts", "mergedProducts" : { } }
{ "_id" : "Shirt", "mergedProducts" : { } }