MongoDB $ या एकत्रीकरण पाइपलाइन ऑपरेटर

MongoDB में, $or एग्रीगेशन पाइपलाइन ऑपरेटर एक या अधिक एक्सप्रेशन का मूल्यांकन करता है और true returns देता है यदि कोई true . का मूल्यांकन करता है . अन्यथा यह false लौटाता है ।

सिंटैक्स

वाक्य रचना इस प्रकार है:

{ $or: [ <expression1>, <expression2>, ... ] }

उदाहरण

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

{ "_id" : 1, "a" : 10, "b" : 2, "c" : 20 }

यहां बताया गया है कि जब हम $or का उपयोग करते हैं तो क्या होता है उस दस्तावेज़ के विरुद्ध दो स्थितियों का परीक्षण करने के लिए:

db.data.aggregate(
   [
     { $match: { _id: 1 } },
     { $project: { 
        _id: 0,
        a: 1,
        b: 1,
        result: { $or: [ 
              { $gt: [ "$a", 9 ] }, 
              { $lt: [ "$b", 1 ] }
            ] } 
          } 
         }
   ]
)

परिणाम:

{ "a" : 10, "b" : 2, "result" : true }

हम देख सकते हैं कि $or लौटा true , भले ही कोई एक भाव false . का समाधान करता हो . ऐसा इसलिए है क्योंकि यह true लौटाता है अगर कोई भावों में से true हैं ।

यहाँ यह फिर से है, लेकिन दोनों अभिव्यक्तियों के साथ false . का समाधान हो रहा है ।

db.data.aggregate(
   [
     { $match: { _id: 1 } },
     { $project: { 
        _id: 0,
        a: 1,
        b: 1,
        result: { $or: [ 
              { $gt: [ "$a", 20 ] }, 
              { $lt: [ "$b", 1 ] }
            ] } 
          } 
         }
   ]
)

परिणाम:

{ "a" : 10, "b" : 2, "result" : false }

दो से अधिक तर्क

जैसा कि बताया गया है, $or एक या अधिक भावों को स्वीकार करता है। पिछला उदाहरण दो अभिव्यक्तियों का उपयोग करता है। यहां एक उदाहरण दिया गया है जो तीन का उपयोग करता है:

db.data.aggregate(
   [
     { $match: { _id: 1 } },
     { $project: { 
        _id: 0,
        a: 1,
        b: 1,
        c: 1,
        result: { $or: [ 
              { $gt: [ "$a", 9 ] }, 
              { $lt: [ "$b", 3 ] }, 
              { $gt: [ "$c", 30 ] } 
            ] } 
          } 
         }
   ]
)

परिणाम:

{ "a" : 10, "b" : 2, "c" : 20, "result" : true }

इस मामले में परिणाम true है , भले ही तीसरा मान false . का मूल्यांकन करता हो ।

एक तर्क

यह देखते हुए कि $or एक या अधिक भाव स्वीकार करता है, एक तर्क देना संभव है।

उदाहरण:

db.data.aggregate(
   [
     { $match: { _id: 1 } },
     { $project: { 
        _id: 0,
        a: 1,
        result: { $or: [ 
              { $gt: [ "$a", 9 ] }
            ] } 
          } 
         }
   ]
)

परिणाम:

{ "a" : 10, "result" : true }

शून्य, शून्य और अपरिभाषित मान

$or ऑपरेटर 0 . का मूल्यांकन करता है , null , और undefined false . के रूप में ।

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

{ "_id" : 2, "a" : 0, "b" : 2 }
{ "_id" : 3, "a" : 10, "b" : 0 }
{ "_id" : 4, "a" : 0, "b" : 0 }
{ "_id" : 5, "a" : null, "b" : 2 }
{ "_id" : 6, "a" : 10, "b" : null }
{ "_id" : 7, "a" : null, "b" : null }
{ "_id" : 8, "a" : undefined, "b" : 2 }
{ "_id" : 9, "a" : 10, "b" : undefined }
{ "_id" : 10, "a" : undefined, "b" : undefined }

यहां बताया गया है कि जब हम $or लागू करते हैं तो क्या होता है :

db.data.aggregate(
   [
     { $match: { _id: { $in: [ 2, 3, 4, 5, 6, 7, 8, 9, 10 ] } } },
     { $project: { 
        _id: 0,
        a: 1,
        b: 1,
        result: { $or: [ "$a", "$b" ] } }
         }
   ]
)

परिणाम:

{ "a" : 0, "b" : 2, "result" : true }
{ "a" : 10, "b" : 0, "result" : true }
{ "a" : 0, "b" : 0, "result" : false }
{ "a" : null, "b" : 2, "result" : true }
{ "a" : 10, "b" : null, "result" : true }
{ "a" : null, "b" : null, "result" : false }
{ "a" : undefined, "b" : 2, "result" : true }
{ "a" : 10, "b" : undefined, "result" : true }
{ "a" : undefined, "b" : undefined, "result" : false }

यहां, मैंने केवल फ़ील्ड को अभिव्यक्ति के रूप में उपयोग किया है।

जब हम 0 . वाले फ़ील्ड में केवल एक तर्क लागू करते हैं तो यह कैसा दिखता है , null , और undefined :

db.data.aggregate(
   [
     { $match: { _id: { $in: [ 4, 7, 10 ] } } },
     { $project: { 
        _id: 0,
        a: 1,
        result: { $or: [ "$a" ] } }
         }
   ]
)

परिणाम:

{ "a" : 0, "result" : false }
{ "a" : null, "result" : false }
{ "a" : undefined, "result" : false }

सभी फ़ील्ड false लौटाते हैं ।

आह्वान $or बिना किसी तर्क के

जब बिना किसी तर्क के आह्वान किया जाता है, तो $or ऑपरेटर false का मूल्यांकन करता है ।

उदाहरण:

db.data.aggregate(
   [
     { $match: { _id: { $in: [ 1 ] } } },
     { $project: { 
        _id: 0,
        result: { $or: [ ] } }
         }
   ]
)

परिणाम:

{ "result" : false }