MongoDB
 sql >> डेटाबेस >  >> NoSQL >> MongoDB

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

MongoDB में, $not एकत्रीकरण पाइपलाइन ऑपरेटर एक बूलियन का मूल्यांकन करता है और विपरीत बूलियन मान देता है।

दूसरे शब्दों में, जब बूलियन true . का मूल्यांकन करता है , $not ऑपरेटर false लौटाता है . और जब बूलियन false . का मूल्यांकन करता है , $not ऑपरेटर true लौटाता है ।

उदाहरण

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

{ "_id" : 1, "data" : true }
{ "_id" : 2, "data" : false }

यहां बताया गया है कि जब हम $not apply लागू करते हैं तो क्या होता है data . के लिए प्रत्येक दस्तावेज़ का क्षेत्र:

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

परिणाम:

{ "data" : true, "result" : false }
{ "data" : false, "result" : true }

हम देख सकते हैं कि $not प्रत्येक बूलियन के विपरीत लौटा।

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

$not ऑपरेटर 0 . का मूल्यांकन करता है , null , और undefined false . के रूप में - जिसका अर्थ है कि यह true लौटाता है ।

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

{ "_id" : 3, "data" : 0 }
{ "_id" : 4, "data" : null }
{ "_id" : 5, "data" : undefined }

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

db.test.aggregate(
   [
     { $match: { _id: { $in: [ 3, 4, 5 ] } } },
     { $project: { 
        _id: 0,
        data: 1,
        result: { $not: [ "$data" ] } } 
         }
   ]
)

परिणाम:

{ "data" : 0, "result" : true }
{ "data" : null, "result" : true }
{ "data" : undefined, "result" : true }

जैसा कि अपेक्षित था, वे सभी true वापस आ गए (जिसका अर्थ है कि उन्होंने false . के रूप में मूल्यांकन किया ।

अन्य सभी मान

$not ऑपरेटर अन्य सभी मान true . के रूप में - जिसका अर्थ है कि यह false लौटाता है ।

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

{ "_id" : 6, "data" : [ true ] }
{ "_id" : 7, "data" : [ false ] }
{ "_id" : 8, "data" : 5 }
{ "_id" : 9, "data" : "Bat" }
{ "_id" : 10, "data" : ISODate("2021-01-03T23:30:15.100Z") }

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

db.test.aggregate(
   [
     { $match: { _id: { $in: [ 6, 7, 8, 9, 10 ] } } },
     { $project: { 
        _id: 0,
        data: 1,
        result: { $not: [ "$data" ] } } 
         }
   ]
)

परिणाम:

{ "data" : [ true ], "result" : false }
{ "data" : [ false ], "result" : false }
{ "data" : 5, "result" : false }
{ "data" : "Bat", "result" : false }
{ "data" : ISODate("2021-01-03T23:30:15.100Z"), "result" : false }

वे सभी false लौटाते हैं (जिसका अर्थ है कि वे true . का मूल्यांकन करते हैं )।

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

$not लागू किया जा रहा है उस फ़ील्ड के लिए जो मौजूद नहीं है false . का मूल्यांकन करता है (जिसका अर्थ है कि यह true लौटाता है )।

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

{ "_id" : 11 }

और हम $not . लागू करते हैं उसके लिए:

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

परिणाम:

{ "result" : true }

दूसरे ऑपरेटर को नकारें

$not ऑपरेटर का उपयोग किसी अन्य ऑपरेटर के बूलियन आउटपुट को नकारने के लिए किया जा सकता है।

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

{ "_id" : 1, "name" : "Wag", "type" : "Dog", "weight" : 20 }
{ "_id" : 2, "name" : "Bark", "type" : "Dog", "weight" : 10 }
{ "_id" : 3, "name" : "Meow", "type" : "Cat", "weight" : 7 }
{ "_id" : 4, "name" : "Scratch", "type" : "Cat", "weight" : 8 }
{ "_id" : 5, "name" : "Bruce", "type" : "Kangaroo", "weight" : 100 }
{ "_id" : 6, "name" : "Hop", "type" : "Kangaroo", "weight" : 130 }
{ "_id" : 7, "name" : "Punch", "type" : "Kangaroo", "weight" : 200 }
{ "_id" : 8, "name" : "Snap", "type" : "Cat", "weight" : 12 }
{ "_id" : 9, "name" : "Ruff", "type" : "Dog", "weight" : 30 }

हम उपयोग कर सकते हैं $not कहने के साथ संयोजन में, $gt भार क्षेत्र का मूल्यांकन करने के लिए:

db.pets.aggregate(
   [
     { $project: { 
        _id: 0,
        name: 1,
        weight: 1,
        result: { $not: [ { $gt: [ "$weight", 100 ] } ] } } 
         }
   ]
)

परिणाम:

{ "name" : "Wag", "weight" : 20, "result" : true }
{ "name" : "Bark", "weight" : 10, "result" : true }
{ "name" : "Meow", "weight" : 7, "result" : true }
{ "name" : "Scratch", "weight" : 8, "result" : true }
{ "name" : "Bruce", "weight" : 100, "result" : true }
{ "name" : "Hop", "weight" : 130, "result" : false }
{ "name" : "Punch", "weight" : 200, "result" : false }
{ "name" : "Snap", "weight" : 12, "result" : true }
{ "name" : "Ruff", "weight" : 30, "result" : true }

इसे दोहराने के लिए, यह फिर से है लेकिन इस बार हम $gt . के लिए एक फ़ील्ड आउटपुट करते हैं परिणाम, साथ ही नहीं . के लिए फ़ील्ड $gt परिणाम:

db.pets.aggregate(
   [
     { $project: { 
        _id: 0,
        weight: 1,
        gt: { $gt: [ "$weight", 100 ] },
        notGt: { $not: [ { $gt: [ "$weight", 100 ] } ] } } 
         }
   ]
)

परिणाम:

{ "weight" : 20, "gt" : false, "notGt" : true }
{ "weight" : 10, "gt" : false, "notGt" : true }
{ "weight" : 7, "gt" : false, "notGt" : true }
{ "weight" : 8, "gt" : false, "notGt" : true }
{ "weight" : 100, "gt" : false, "notGt" : true }
{ "weight" : 130, "gt" : true, "notGt" : false }
{ "weight" : 200, "gt" : true, "notGt" : false }
{ "weight" : 12, "gt" : false, "notGt" : true }
{ "weight" : 30, "gt" : false, "notGt" : true }

हर बार $gt परिणामस्वरूप true , $not ऑपरेटर ने इसे false . पर फ़्लिप कर दिया . और हर बार $gt परिणामस्वरूप false , $not इसे true . पर फ़्लिप कर दिया ।


  1. Redis
  2.   
  3. MongoDB
  4.   
  5. Memcached
  6.   
  7. HBase
  8.   
  9. CouchDB
  1. मोंगोडीबी $strcasecmp

  2. MongoDB में सरणी के अंदर सरणी के अंदर एम्बेडेड ऑब्जेक्ट को अपडेट करें

  3. क्या मोंगोडीबी को प्रति अनुरोध कई बार पूछना ठीक है?

  4. MongoDB में एक कॉलम का उच्चतम मूल्य प्राप्त करना

  5. मोंगोडब मानदंड से मेल खाने वाली सभी वस्तुओं में सभी सरणी तत्वों की गणना करता है