मोंगोडीबी $फ़िल्टर

MongoDB में, $filter एकत्रीकरण पाइपलाइन ऑपरेटर एक निर्दिष्ट शर्त के आधार पर एक सरणी का सबसेट देता है।

$filter ऑपरेटर केवल उन तत्वों के साथ एक सरणी देता है जो स्थिति से मेल खाते हैं, उनके मूल क्रम में।

सिंटैक्स

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

{ $filter: { input: <array>, as: <string>, cond: <expression> } }

प्रत्येक फ़ील्ड को नीचे समझाया गया है।

फ़ील्ड	विनिर्देश
`input`	एक अभिव्यक्ति जो एक सरणी को हल करती है।
`as`	यह एक वैकल्पिक फ़ील्ड है। यह वैरिएबल के लिए एक नाम निर्दिष्ट करता है जो `input` . के प्रत्येक व्यक्तिगत तत्व का प्रतिनिधित्व करता है सरणी। यदि कोई नाम निर्दिष्ट नहीं है (अर्थात यदि आप इस फ़ील्ड को छोड़ देते हैं), तो वैरिएबल नाम डिफ़ॉल्ट रूप से `this` हो जाता है ।
`cond`	एक अभिव्यक्ति जो एक बूलियन मान का समाधान करती है जिसका उपयोग यह निर्धारित करने के लिए किया जाता है कि क्या किसी तत्व को आउटपुट सरणी में शामिल किया जाना चाहिए। यह व्यंजक `input` . के प्रत्येक तत्व का संदर्भ देता है `as` . में निर्दिष्ट चर नाम के साथ अलग-अलग सरणी ।

उदाहरण

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

{ "_id" : 1, "player" : "Homer", "scores" : [ 1, 5, 3 ] }
{ "_id" : 2, "player" : "Marge", "scores" : [ 8, 17, 18 ] }
{ "_id" : 3, "player" : "Bart", "scores" : [ 15, 11, 8 ] }

यहां $filter . लागू करने का एक उदाहरण दिया गया है सरणी तत्वों को scores . में फ़िल्टर करने के लिए ऑपरेटर फ़ील्ड:

db.players.aggregate([
  { 
    $match: { _id: { $in: [ 1, 2, 3 ] } } 
  },
  {
    $project: {
        highScores: {
          $filter: {
              input: "$scores",
              as: "score",
              cond: { $gt: [ "$$score", 10 ] }
          }
        }
    }
  }
])

परिणाम:

{ "_id" : 1, "highScores" : [ ] }
{ "_id" : 2, "highScores" : [ 17, 18 ] }
{ "_id" : 3, "highScores" : [ 15, 11 ] }

इस उदाहरण में, हमने सरणियों को केवल उन तत्वों के लिए फ़िल्टर किया है जिनका मान 10 से अधिक है। केवल वे मान लौटाए जाते हैं।

कोई भी मान जो 10 से कम है उसे परिणाम से हटा दिया जाता है। पहले दस्तावेज़ के मामले में, यह एक खाली सरणी में परिणत होता है।

यहाँ, हमने as . का प्रयोग किया है रिटर्न वेरिएबल का नाम देने के लिए फ़ील्ड score . फिर हमने उस चर को cond . में संदर्भित किया $$score . का उपयोग करके फ़ील्ड . जैसा कि बताया गया है, आप as . को छोड़ सकते हैं फ़ील्ड, और फिर $$this . का उपयोग करके वापसी चर देखें . इस पर बाद में।

खाली सरणी

यदि सरणी खाली है, तो एक खाली सरणी लौटा दी जाती है।

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

{ "_id" : 4, "player" : "Farnsworth", "scores" : [ ] }

यहां बताया गया है कि जब हम $filter लागू करते हैं तो क्या होता है उस सरणी के लिए:

db.players.aggregate([
  { 
    $match: { _id: { $in: [ 4 ] } } 
  },
  {
    $project: {
        highScores: {
          $filter: {
              input: "$scores",
              as: "score",
              cond: { $gt: [ "$$score", 10 ] }
          }
        }
    }
  }
])

परिणाम:

{ "_id" : 4, "highScores" : [ ] }

गलत प्रकार

$filter लागू करना उस फ़ील्ड में जिसमें कोई सरणी नहीं है, एक त्रुटि देता है।

उदाहरण:

db.players.aggregate([
  { 
    $match: { _id: { $in: [ 4 ] } } 
  },
  {
    $project: {
        highScores: {
          $filter: {
              input: "$player",
              as: "player",
              cond: { $gt: [ "$$player", 10 ] }
          }
        }
    }
  }
])

परिणाम:

Error: command failed: {
	"ok" : 0,
	"errmsg" : "input to $filter must be an array not string",
	"code" : 28651,
	"codeName" : "Location28651"
} : aggregate failed :
[email protected]/mongo/shell/utils.js:25:13
[email protected]/mongo/shell/assert.js:18:14
[email protected]/mongo/shell/assert.js:618:17
[email protected]/mongo/shell/assert.js:708:16
[email protected]/mongo/shell/db.js:266:5
[email protected]/mongo/shell/collection.js:1046:12
@(shell):1:1

शून्य मान

यदि फ़ील्ड में null है एक सरणी के बजाय, परिणाम null है ।

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

{ "_id" : 5, "player" : "Meg", "scores" : null }

यहां बताया गया है कि जब हम $filter लागू करते हैं तो क्या होता है score . तक फ़ील्ड:

db.players.aggregate([
  { 
    $match: { _id: { $in: [ 5 ] } } 
  },
  {
    $project: {
        highScores: {
          $filter: {
              input: "$scores",
              as: "score",
              cond: { $gt: [ "$$score", 10 ] }
          }
        }
    }
  }
])

परिणाम:

{ "_id" : 5, "highScores" : null }

गैर-मौजूद फ़ील्ड

$filter लागू करना उस फ़ील्ड के लिए जो मौजूद नहीं है null . में परिणाम देता है लौटाया जा रहा है।

उदाहरण:

db.players.aggregate([
  { 
    $match: { _id: { $in: [ 5 ] } } 
  },
  {
    $project: {
        highScores: {
          $filter: {
              input: "$name",
              as: "name",
              cond: { $gt: [ "$$name", 10 ] }
          }
        }
    }
  }
])

परिणाम:

{ "_id" : 5, "highScores" : null }

परिवर्तनीय नाम वैकल्पिक है

पिछले उदाहरणों में, मैं as . का उपयोग करता हूं चर को एक नाम निर्दिष्ट करने के लिए फ़ील्ड।

जैसा कि बताया गया है, as फ़ील्ड वैकल्पिक है। अगर आप इस फ़ील्ड को छोड़ देते हैं, तो वैरिएबल नाम डिफ़ॉल्ट रूप से this . हो जाता है ।

यहां एक उदाहरण दिया गया है:

db.players.aggregate([
  { 
    $match: { _id: { $in: [ 1, 2, 3 ] } } 
  },
  {
    $project: {
        highScores: {
          $filter: {
              input: "$scores",
              cond: { $gt: [ "$$this", 10 ] }
          }
        }
    }
  }
])

परिणाम:

{ "_id" : 1, "highScores" : [ ] }
{ "_id" : 2, "highScores" : [ 17, 18 ] }
{ "_id" : 3, "highScores" : [ 15, 11 ] }

यह पहले उदाहरण जैसा ही है, इस उदाहरण को छोड़कर, हम as . को छोड़ देते हैं फ़ील्ड, और इसलिए $$this . का उपयोग करके वेरिएबल को देखें ।