MongoDB में, $setIsSubset एकत्रीकरण पाइपलाइन ऑपरेटर दो सरणियों को स्वीकार करता है और true returns लौटाता है जब पहली सरणी दूसरे का सबसेट हो, और false जब यह नहीं है।
पहली सरणी को एक सबसेट भी माना जाता है जब वह दूसरी सरणी के बराबर होती है।
$setIsSubset दो तर्कों को स्वीकार करता है, जिनमें से दोनों कोई भी मान्य अभिव्यक्ति हो सकते हैं, जब तक कि वे प्रत्येक एक सरणी को हल करते हैं। $setIsSubset सरणियों को सेट के रूप में मानता है।
उदाहरण
मान लीजिए हमारे पास data . नामक संग्रह है निम्नलिखित दस्तावेजों के साथ:
{ "_id" : 1, "a" : [ 1, 2, 3 ], "b" : [ 1, 2, 3 ] }
{ "_id" : 2, "a" : [ 1, 2, 3 ], "b" : [ 1, 2 ] }
{ "_id" : 3, "a" : [ 1, 2 ], "b" : [ 1, 2, 3 ] }
{ "_id" : 4, "a" : [ 1, 2, 3 ], "b" : [ 3, 4, 5 ] }
{ "_id" : 5, "a" : [ 1, 2, 3 ], "b" : [ 4, 5, 6 ] }
हम $setIsSubset . लागू कर सकते हैं a . के विरुद्ध ऑपरेटर और b उन दस्तावेज़ों में फ़ील्ड।
उदाहरण:
db.data.aggregate(
[
{ $match: { _id: { $in: [ 1, 2, 3, 4, 5 ] } } },
{
$project:
{
_id: 0,
a: 1,
b: 1,
result: { $setIsSubset: [ "$a", "$b" ] }
}
}
]
)परिणाम:
{ "a" : [ 1, 2, 3 ], "b" : [ 1, 2, 3 ], "result" : true }
{ "a" : [ 1, 2, 3 ], "b" : [ 1, 2 ], "result" : false }
{ "a" : [ 1, 2 ], "b" : [ 1, 2, 3 ], "result" : true }
{ "a" : [ 1, 2, 3 ], "b" : [ 3, 4, 5 ], "result" : false }
{ "a" : [ 1, 2, 3 ], "b" : [ 4, 5, 6 ], "result" : false } नेस्टेड सरणी
$setIsSubset ऑपरेटर किसी भी नेस्टेड सरणियों में नहीं उतरता है। यह केवल शीर्ष-स्तरीय सरणियों का मूल्यांकन करता है।
मान लीजिए हमारे संग्रह में निम्नलिखित दस्तावेज़ भी हैं:
{ "_id" : 6, "a" : [ 1, 2, 3 ], "b" : [ [ 1, 2, 3 ] ] }
{ "_id" : 7, "a" : [ 1, 2, 3 ], "b" : [ [ 1, 2 ], 3 ] }
और हम $setIsSubset . लागू करते हैं उन दो दस्तावेज़ों के लिए:
db.data.aggregate(
[
{ $match: { _id: { $in: [ 6, 7 ] } } },
{
$project:
{
_id: 0,
a: 1,
b: 1,
result: { $setIsSubset: [ "$a", "$b" ] }
}
}
]
)परिणाम:
{ "a" : [ 1, 2, 3 ], "b" : [ [ 1, 2, 3 ] ], "result" : false }
{ "a" : [ 1, 2, 3 ], "b" : [ [ 1, 2 ], 3 ], "result" : false }
पहले दस्तावेज़ में, b फ़ील्ड में एक सरणी होती है जिसमें केवल एक तत्व होता है - एक और सरणी। इस मामले में यह पाया गया कि a b . का उपसमुच्चय नहीं है .
हालांकि, मान लें कि हमारे पास निम्नलिखित दस्तावेज हैं:
{ "_id" : 8, "a" : [ [ 1, 2, 3 ] ], "b" : [ [ 1, 2, 3 ] ] }
{ "_id" : 9, "a" : [ [ 1, 2, 3 ] ], "b" : [ [ 1, 2 ], 3 ] }
दस्तावेज़ 8 में a . दोनों पर एक नेस्टेड सरणी है और b फ़ील्ड, और दोनों सरणियाँ समान हैं।
यहां बताया गया है कि जब हम $setIsSubset . लागू करते हैं तो क्या होता है उन दस्तावेज़ों के लिए:
db.data.aggregate(
[
{ $match: { _id: { $in: [ 8, 9 ] } } },
{
$project:
{
_id: 0,
a: 1,
b: 1,
result: { $setIsSubset: [ "$a", "$b" ] }
}
}
]
)परिणाम:
{ "a" : [ [ 1, 2, 3 ] ], "b" : [ [ 1, 2, 3 ] ], "result" : true }
{ "a" : [ [ 1, 2, 3 ] ], "b" : [ [ 1, 2 ], 3 ], "result" : false }
पहले दस्तावेज़ में, a b . से मेल खाता है बिल्कुल, और इसलिए परिणाम true है ।
दूसरे दस्तावेज़ में, a b . का उपसमुच्चय नहीं है , और इसलिए परिणाम false . है ।
अनुपलब्ध फ़ील्ड
$setIsSubset लागू किया जा रहा है एक गैर-मौजूद फ़ील्ड के परिणामस्वरूप त्रुटि होती है।
निम्नलिखित दस्तावेजों पर विचार करें:
{ "_id" : 10, "a" : [ 1, 2, 3 ] }
{ "_id" : 11, "b" : [ 1, 2, 3 ] }
{ "_id" : 12 }
पहले दस्तावेज़ में b नहीं है फ़ील्ड, दूसरे दस्तावेज़ में a नहीं है फ़ील्ड, और तीसरे दस्तावेज़ में या तो नहीं है।
यहां बताया गया है कि जब हम $setIsSubset . लागू करते हैं तो क्या होता है a . के लिए और b फ़ील्ड:
db.data.aggregate(
[
{ $match: { _id: { $in: [ 10, 11, 12 ] } } },
{
$project:
{
_id: 0,
a: 1,
b: 1,
result: { $setIsSubset: [ "$a", "$b" ] }
}
}
]
)परिणाम:
Error: command failed: {
"ok" : 0,
"errmsg" : "both operands of $setIsSubset must be arrays. Second argument is of type: missing",
"code" : 17042,
"codeName" : "Location17042"
} : aggregate failed :
[email protected]/mongo/shell/utils.js:25:13
[email protected]/mongo/shell/assert.js:18:14
[email protected]/mongo/shell/assert.js:639:17
[email protected]/mongo/shell/assert.js:729:16
[email protected]/mongo/shell/db.js:266:5
[email protected]/mongo/shell/collection.js:1058:12
@(shell):1:1 गलत डेटा प्रकार
$setIsSubset . के दोनों ऑपरेंड सरणी होना चाहिए। यदि वे नहीं हैं, तो एक त्रुटि उत्पन्न होती है।
मान लीजिए हमारे संग्रह में निम्नलिखित दस्तावेज हैं:
{ "_id" : 13, "a" : [ 1, 2, 3 ], "b" : 3 }
{ "_id" : 14, "a" : 3, "b" : [ 1, 2, 3 ] }
{ "_id" : 15, "a" : 2, "b" : 3 }
और हम $setIsSubset . लागू करते हैं उन दस्तावेज़ों के लिए:
db.data.aggregate(
[
{ $match: { _id: { $in: [ 13, 14, 15 ] } } },
{
$project:
{
_id: 0,
a: 1,
b: 1,
result: { $setIsSubset: [ "$a", "$b" ] }
}
}
]
)परिणाम:
Error: command failed: {
"ok" : 0,
"errmsg" : "both operands of $setIsSubset must be arrays. Second argument is of type: double",
"code" : 17042,
"codeName" : "Location17042"
} : aggregate failed :
[email protected]/mongo/shell/utils.js:25:13
[email protected]/mongo/shell/assert.js:18:14
[email protected]/mongo/shell/assert.js:639:17
[email protected]/mongo/shell/assert.js:729:16
[email protected]/mongo/shell/db.js:266:5
[email protected]/mongo/shell/collection.js:1058:12
@(shell):1:1 डुप्लिकेट मान
$setIsSubset ऑपरेटर डुप्लिकेट को अनदेखा करता है। यह तत्वों के क्रम की भी उपेक्षा करता है..
मान लीजिए हमारे पास निम्नलिखित दस्तावेज हैं:
{ "_id" : 16, "a" : [ 1, 1, 2, 2, 3, 3 ], "b" : [ 1, 2, 3 ] }
{ "_id" : 17, "a" : [ 1, 1, 2, 2, 3, 3 ], "b" : [ 1, 2 ] }
{ "_id" : 18, "a" : [ 1, 1, 2, 2, 3, 3 ], "b" : [ ] }
{ "_id" : 19, "a" : [ 3, 2, 1, 2, 3, 1 ], "b" : [ 2, 3, 1 ] }
{ "_id" : 20, "a" : [ 1, 3, 2, 2, 3, 1 ], "b" : [ 2, 1 ] }
{ "_id" : 21, "a" : [ 2, 3, 1, 2, 3, 1 ], "b" : [ ] }
फिर हम $setIsSubset . लागू करते हैं उनके लिए ऑपरेटर:
db.data.aggregate(
[
{ $match: { _id: { $in: [ 16, 17, 18, 19, 20, 21 ] } } },
{
$project:
{
_id: 0,
a: 1,
b: 1,
result: { $setIsSubset: [ "$a", "$b" ] }
}
}
]
)परिणाम:
{ "a" : [ 1, 1, 2, 2, 3, 3 ], "b" : [ 1, 2, 3 ], "result" : true }
{ "a" : [ 1, 1, 2, 2, 3, 3 ], "b" : [ 1, 2 ], "result" : false }
{ "a" : [ 1, 1, 2, 2, 3, 3 ], "b" : [ ], "result" : false }
{ "a" : [ 3, 2, 1, 2, 3, 1 ], "b" : [ 2, 3, 1 ], "result" : true }
{ "a" : [ 1, 3, 2, 2, 3, 1 ], "b" : [ 2, 1 ], "result" : false }
{ "a" : [ 2, 3, 1, 2, 3, 1 ], "b" : [ ], "result" : false } 
