MongoDB रिकॉर्ड ढूंढें जहां सरणी फ़ील्ड खाली नहीं है

Question

मेरे सभी रिकॉर्ड्स में "चित्र" नामक एक फ़ील्ड है। यह फ़ील्ड तार की एक सरणी है।

मैं अब नए 10 रिकॉर्ड चाहता हूं जहां यह सरणी खाली नहीं है।

मैं चारों ओर गुगली कर चुका हूं, लेकिन अजीब तरह से मैं इस पर ज्यादा नहीं पाया हूं। मैंने $ विकल्प में पढ़ा है, लेकिन मैं सोच रहा था कि देशी कार्यों के लिए कितना धीमा है, और अगर कोई बेहतर समाधान है।

और फिर भी, यह काम नहीं करता है:

ME.find({$where: 'this.pictures.length > 0'}).sort('-created').limit(10).execFind()

कुछ भी नहीं लौटाता। this.picturesलंबाई के बिना छोड़ने से काम नहीं चलता है, लेकिन फिर यह खाली रिकॉर्ड भी देता है।

Answer 1

यदि आपके पास ऐसे दस्तावेज भी हैं जिनकी कुंजी नहीं है, तो आप उपयोग कर सकते हैं:

ME.find({ pictures: { $exists: true, $not: {$size: 0} } })

$ आकार शामिल होने पर MongoDB अनुक्रमित का उपयोग नहीं करता है, इसलिए यहां एक बेहतर समाधान है:

ME.find({ pictures: { $exists: true, $ne: [] } })

MongoDB 2.6 रिलीज के बाद से, आप ऑपरेटर के साथ तुलना कर सकते हैं $gtलेकिन अप्रत्याशित परिणाम पैदा कर सकते हैं (आप इस उत्तर में एक अलग स्पष्टीकरण पा सकते हैं :

ME.find({ pictures: { $gt: [] } })

Comments

मेरे लिए यह सही दृष्टिकोण है, क्योंकि यह सुनिश्चित करता है कि सरणी मौजूद है और खाली नहीं है।

— लिएंड्रोसीआर

मैं उसी कार्यक्षमता का उपयोग करके कैसे प्राप्त कर सकता हूंmongoengine

— रोहित खत्री

CAREFUL, ME.find({ pictures: { $gt: [] } })IS DANGEROUS, यहां तक ​​कि नए MongoDB संस्करणों में भी। यदि आपके पास अपनी सूची फ़ील्ड पर एक इंडेक्स है और क्वेरी के दौरान उस इंडेक्स का उपयोग किया जाता है, तो आपको अप्रत्याशित परिणाम प्राप्त होंगे। उदाहरण के लिए: db.doc.find({'nums': { $gt: [] }}).hint({ _id: 1 }).count()सही संख्या db.doc.find({'nums': { $gt: [] }}).hint({ nums: 1 }).count()देता है , जबकि रिटर्न 0।

— वोजिक्कस्टेफन

यह जानने के लिए कि यह आपके लिए काम क्यों नहीं कर सकता, जानने के लिए नीचे मेरा विस्तृत जवाब देखें: stackoverflow.com/a/42601244/1579058

— wojcikstefan

@ wojcikstefan की टिप्पणी को लोगों को अंतिम सुझाव का उपयोग करने से रोकने के लिए ऊपर उठाने की आवश्यकता है, जो वास्तव में, कुछ परिस्थितियों में मिलान दस्तावेजों को वापस नहीं करता है।

— थॉमस जुंग

Answer 2

कुछ और देखने के बाद, विशेष रूप से मोंगोडब दस्तावेजों में, और एक साथ बिट्स की गूंज, यह उत्तर था:

ME.find({pictures: {$exists: true, $not: {$size: 0}}})

Comments

यह काम नहीं करता है। मुझे नहीं पता कि यह पहले काम किया था, लेकिन यह उन वस्तुओं को भी लौटाएगा जिनके पास 'चित्र' कुंजी नहीं है।

— बजे

अविश्वसनीय है कि इस उत्तर में 63 अपवोट्स हैं, जब वास्तव में @rdsoze ने जो कहा है वह सच है - क्वेरी रिकॉर्ड भी लौटाएगी जिसमें फ़ील्ड नहीं है pictures।

— डेन डैस्कलेस्कु

सावधान रहें, यदि $ आकार लिंक में शामिल है, तो mongoDB अनुक्रमित का उपयोग नहीं करेगा । {$ Ne: []} और संभवतः {$ ne: null} को शामिल करना बेहतर होगा।

— लेवेंटे डोबसन

@rdsoze प्रश्न की पहली पंक्ति में कहा गया है "मेरे सभी रिकॉर्ड में" चित्र "नामक फ़ील्ड है। यह फ़ील्ड एक सरणी है" । क्या अधिक है, यह पूरी तरह से यथार्थवादी और सामान्य परिदृश्य है। यह उत्तर गलत नहीं है, यह प्रश्न के लिखित रूप में सटीक रूप से काम करता है, और इस तथ्य के लिए इसकी आलोचना या आलोचना करता है कि यह एक अलग समस्या को हल नहीं करता है मूर्खतापूर्ण है।

— मार्क अमेरी

@ क्या सभी दस्तावेज कहते हैं कि यदि आप क्वेरी में $ आकार का उपयोग करते हैं, तो यह आपको तेज परिणाम देने के लिए किसी भी सूचकांक का उपयोग नहीं करेगा। इसलिए यदि आपके पास उस फ़ील्ड पर एक इंडेक्स है और आप इसका उपयोग करना चाहते हैं, तो {$ ne: []} जैसे अन्य तरीकों से चिपके रहें, यदि वह आपके लिए काम करता है, तो यह आपके इंडेक्स का उपयोग करेगा।

— लेवेंटे डोब्सन

Answer 3

यह आपके लिए भी काम कर सकता है:

ME.find({'pictures.0': {$exists: true}});

Comments

अच्छा! इससे आप न्यूनतम आकार की जांच भी कर सकते हैं। क्या आप जानते हैं कि सरणियों को हमेशा अनुक्रमिक रूप से अनुक्रमित किया जाता है? क्या कभी ऐसा कोई मामला होगा जहां pictures.2मौजूद है लेकिन pictures.1नहीं है?

— अनुश्र 9'13

$existsऑपरेटर एक बूलियन, नहीं एक ऑफसेट है। trueइसके बजाय @tenbatsu का उपयोग किया जाना चाहिए 1।

— इखिलाबाई

@ अनुश्रु Would there ever be a case where pictures.2 exists but pictures.1 does not? हां, यह मामला हो सकता है।

— Bndr

@ TheBrr केवल तभी हो सकता है यदि picturesकोई सब-डॉक हो, न कि कोई सरणी। जैसेpictures: {'2': 123}

— जॉनीएचके

यह अच्छा और सहज है, लेकिन अगर प्रदर्शन महत्वपूर्ण है, तो सावधान रहें - यह एक पूर्ण संग्रह स्कैन करेगा भले ही आपके पास एक सूचकांक हो pictures।

— wojcikstefan

Answer 4

आप क्वेरी करते समय दो बातों की परवाह करते हैं - सटीकता और प्रदर्शन। इसे ध्यान में रखते हुए, मैंने MongoDB v3.0.14 में कुछ अलग तरीकों का परीक्षण किया।

TL, DR db.doc.find({ nums: { $gt: -Infinity }})सबसे तेज़ और सबसे विश्वसनीय है (कम से कम MongoDB संस्करण मैंने परीक्षण किया)।

संपादित करें: यह अब MongoDB v3.6 में काम करता है! संभावित समाधान के लिए इस पोस्ट के अंतर्गत टिप्पणियां देखें।

सेट अप

मैंने 1k डॉक्स w / oa सूची फ़ील्ड, एक खाली सूची के साथ 1k डॉक्स और एक गैर-रिक्त सूची वाले 5 डॉक्स सम्मिलित किए।

for (var i = 0; i < 1000; i++) { db.doc.insert({}); }
for (var i = 0; i < 1000; i++) { db.doc.insert({ nums: [] }); }
for (var i = 0; i < 5; i++) { db.doc.insert({ nums: [1, 2, 3] }); }
db.doc.createIndex({ nums: 1 });

मैं मानता हूं कि यह प्रदर्शन को गंभीरता से लेने के लिए पर्याप्त नहीं है, क्योंकि मैं नीचे दिए गए परीक्षणों में हूं, लेकिन यह विभिन्न प्रश्नों और शुद्धता को चुनने के लिए पर्याप्त है।

टेस्ट

db.doc.find({'nums': {'$exists': true}}) गलत परिणाम देता है (जो हम पूरा करने की कोशिश कर रहे हैं)।

MacBook-Pro(mongod-3.0.14) test> db.doc.find({'nums': {'$exists': true}}).count()
1005

-

db.doc.find({'nums.0': {'$exists': true}})सही परिणाम देता है, लेकिन यह पूर्ण संग्रह स्कैन ( COLLSCANस्पष्टीकरण में सूचना चरण) का उपयोग करके भी धीमा है ।

MacBook-Pro(mongod-3.0.14) test> db.doc.find({'nums.0': {'$exists': true}}).count()
5
MacBook-Pro(mongod-3.0.14) test> db.doc.find({'nums.0': {'$exists': true}}).explain()
{
  "queryPlanner": {
    "plannerVersion": 1,
    "namespace": "test.doc",
    "indexFilterSet": false,
    "parsedQuery": {
      "nums.0": {
        "$exists": true
      }
    },
    "winningPlan": {
      "stage": "COLLSCAN",
      "filter": {
        "nums.0": {
          "$exists": true
        }
      },
      "direction": "forward"
    },
    "rejectedPlans": [ ]
  },
  "serverInfo": {
    "host": "MacBook-Pro",
    "port": 27017,
    "version": "3.0.14",
    "gitVersion": "08352afcca24bfc145240a0fac9d28b978ab77f3"
  },
  "ok": 1
}

-

db.doc.find({'nums': { $exists: true, $gt: { '$size': 0 }}})गलत परिणाम देता है। ऐसा इसलिए है क्योंकि एक अवैध सूचकांक स्कैन बिना किसी दस्तावेज को आगे बढ़ाए। यह इंडेक्स के बिना सटीक लेकिन धीमा होने की संभावना होगी।

MacBook-Pro(mongod-3.0.14) test> db.doc.find({'nums': { $exists: true, $gt: { '$size': 0 }}}).count()
0
MacBook-Pro(mongod-3.0.14) test> db.doc.find({'nums': { $exists: true, $gt: { '$size': 0 }}}).explain('executionStats').executionStats.executionStages
{
  "stage": "KEEP_MUTATIONS",
  "nReturned": 0,
  "executionTimeMillisEstimate": 0,
  "works": 2,
  "advanced": 0,
  "needTime": 0,
  "needFetch": 0,
  "saveState": 0,
  "restoreState": 0,
  "isEOF": 1,
  "invalidates": 0,
  "inputStage": {
    "stage": "FETCH",
    "filter": {
      "$and": [
        {
          "nums": {
            "$gt": {
              "$size": 0
            }
          }
        },
        {
          "nums": {
            "$exists": true
          }
        }
      ]
    },
    "nReturned": 0,
    "executionTimeMillisEstimate": 0,
    "works": 1,
    "advanced": 0,
    "needTime": 0,
    "needFetch": 0,
    "saveState": 0,
    "restoreState": 0,
    "isEOF": 1,
    "invalidates": 0,
    "docsExamined": 0,
    "alreadyHasObj": 0,
    "inputStage": {
      "stage": "IXSCAN",
      "nReturned": 0,
      "executionTimeMillisEstimate": 0,
      "works": 1,
      "advanced": 0,
      "needTime": 0,
      "needFetch": 0,
      "saveState": 0,
      "restoreState": 0,
      "isEOF": 1,
      "invalidates": 0,
      "keyPattern": {
        "nums": 1
      },
      "indexName": "nums_1",
      "isMultiKey": true,
      "direction": "forward",
      "indexBounds": {
        "nums": [
          "({ $size: 0.0 }, [])"
        ]
      },
      "keysExamined": 0,
      "dupsTested": 0,
      "dupsDropped": 0,
      "seenInvalidated": 0,
      "matchTested": 0
    }
  }
}

-

db.doc.find({'nums': { $exists: true, $not: { '$size': 0 }}})सही परिणाम देता है, लेकिन प्रदर्शन खराब है। यह तकनीकी रूप से एक सूचकांक स्कैन करता है, लेकिन फिर यह सभी डॉक्स को आगे बढ़ाता है और फिर उनके माध्यम से फ़िल्टर करना पड़ता है)।

MacBook-Pro(mongod-3.0.14) test> db.doc.find({'nums': { $exists: true, $not: { '$size': 0 }}}).count()
5
MacBook-Pro(mongod-3.0.14) test> db.doc.find({'nums': { $exists: true, $not: { '$size': 0 }}}).explain('executionStats').executionStats.executionStages
{
  "stage": "KEEP_MUTATIONS",
  "nReturned": 5,
  "executionTimeMillisEstimate": 0,
  "works": 2016,
  "advanced": 5,
  "needTime": 2010,
  "needFetch": 0,
  "saveState": 15,
  "restoreState": 15,
  "isEOF": 1,
  "invalidates": 0,
  "inputStage": {
    "stage": "FETCH",
    "filter": {
      "$and": [
        {
          "nums": {
            "$exists": true
          }
        },
        {
          "$not": {
            "nums": {
              "$size": 0
            }
          }
        }
      ]
    },
    "nReturned": 5,
    "executionTimeMillisEstimate": 0,
    "works": 2016,
    "advanced": 5,
    "needTime": 2010,
    "needFetch": 0,
    "saveState": 15,
    "restoreState": 15,
    "isEOF": 1,
    "invalidates": 0,
    "docsExamined": 2005,
    "alreadyHasObj": 0,
    "inputStage": {
      "stage": "IXSCAN",
      "nReturned": 2005,
      "executionTimeMillisEstimate": 0,
      "works": 2015,
      "advanced": 2005,
      "needTime": 10,
      "needFetch": 0,
      "saveState": 15,
      "restoreState": 15,
      "isEOF": 1,
      "invalidates": 0,
      "keyPattern": {
        "nums": 1
      },
      "indexName": "nums_1",
      "isMultiKey": true,
      "direction": "forward",
      "indexBounds": {
        "nums": [
          "[MinKey, MaxKey]"
        ]
      },
      "keysExamined": 2015,
      "dupsTested": 2015,
      "dupsDropped": 10,
      "seenInvalidated": 0,
      "matchTested": 0
    }
  }
}

-

db.doc.find({'nums': { $exists: true, $ne: [] }})सही परिणाम देता है और थोड़ा तेज होता है, लेकिन प्रदर्शन अभी भी आदर्श नहीं है। यह IXSCAN का उपयोग करता है जो केवल मौजूदा सूची फ़ील्ड के साथ डॉक्स को आगे बढ़ाता है, लेकिन फिर एक-एक करके खाली सूचियों को फ़िल्टर करना पड़ता है।

MacBook-Pro(mongod-3.0.14) test> db.doc.find({'nums': { $exists: true, $ne: [] }}).count()
5
MacBook-Pro(mongod-3.0.14) test> db.doc.find({'nums': { $exists: true, $ne: [] }}).explain('executionStats').executionStats.executionStages
{
  "stage": "KEEP_MUTATIONS",
  "nReturned": 5,
  "executionTimeMillisEstimate": 0,
  "works": 1018,
  "advanced": 5,
  "needTime": 1011,
  "needFetch": 0,
  "saveState": 15,
  "restoreState": 15,
  "isEOF": 1,
  "invalidates": 0,
  "inputStage": {
    "stage": "FETCH",
    "filter": {
      "$and": [
        {
          "$not": {
            "nums": {
              "$eq": [ ]
            }
          }
        },
        {
          "nums": {
            "$exists": true
          }
        }
      ]
    },
    "nReturned": 5,
    "executionTimeMillisEstimate": 0,
    "works": 1017,
    "advanced": 5,
    "needTime": 1011,
    "needFetch": 0,
    "saveState": 15,
    "restoreState": 15,
    "isEOF": 1,
    "invalidates": 0,
    "docsExamined": 1005,
    "alreadyHasObj": 0,
    "inputStage": {
      "stage": "IXSCAN",
      "nReturned": 1005,
      "executionTimeMillisEstimate": 0,
      "works": 1016,
      "advanced": 1005,
      "needTime": 11,
      "needFetch": 0,
      "saveState": 15,
      "restoreState": 15,
      "isEOF": 1,
      "invalidates": 0,
      "keyPattern": {
        "nums": 1
      },
      "indexName": "nums_1",
      "isMultiKey": true,
      "direction": "forward",
      "indexBounds": {
        "nums": [
          "[MinKey, undefined)",
          "(undefined, [])",
          "([], MaxKey]"
        ]
      },
      "keysExamined": 1016,
      "dupsTested": 1015,
      "dupsDropped": 10,
      "seenInvalidated": 0,
      "matchTested": 0
    }
  }
}

-

db.doc.find({'nums': { $gt: [] }})भारत के लिए इस्तेमाल किया जाने वाला खतरनाक मामला है, इसका पता लगाया गया है। यह एक अमान्य सूचकांक स्कैन की वजह से है जो बिना दस्तावेजों के आगे बढ़ता है।

MacBook-Pro(mongod-3.0.14) test> db.doc.find({'nums': { $gt: [] }}).count()
0
MacBook-Pro(mongod-3.0.14) test> db.doc.find({'nums': { $gt: [] }}).hint({ nums: 1 }).count()
0
MacBook-Pro(mongod-3.0.14) test> db.doc.find({'nums': { $gt: [] }}).hint({ _id: 1 }).count()
5

MacBook-Pro(mongod-3.0.14) test> db.doc.find({'nums': { $gt: [] }}).explain('executionStats').executionStats.executionStages
{
  "stage": "KEEP_MUTATIONS",
  "nReturned": 0,
  "executionTimeMillisEstimate": 0,
  "works": 1,
  "advanced": 0,
  "needTime": 0,
  "needFetch": 0,
  "saveState": 0,
  "restoreState": 0,
  "isEOF": 1,
  "invalidates": 0,
  "inputStage": {
    "stage": "FETCH",
    "filter": {
      "nums": {
        "$gt": [ ]
      }
    },
    "nReturned": 0,
    "executionTimeMillisEstimate": 0,
    "works": 1,
    "advanced": 0,
    "needTime": 0,
    "needFetch": 0,
    "saveState": 0,
    "restoreState": 0,
    "isEOF": 1,
    "invalidates": 0,
    "docsExamined": 0,
    "alreadyHasObj": 0,
    "inputStage": {
      "stage": "IXSCAN",
      "nReturned": 0,
      "executionTimeMillisEstimate": 0,
      "works": 1,
      "advanced": 0,
      "needTime": 0,
      "needFetch": 0,
      "saveState": 0,
      "restoreState": 0,
      "isEOF": 1,
      "invalidates": 0,
      "keyPattern": {
        "nums": 1
      },
      "indexName": "nums_1",
      "isMultiKey": true,
      "direction": "forward",
      "indexBounds": {
        "nums": [
          "([], BinData(0, ))"
        ]
      },
      "keysExamined": 0,
      "dupsTested": 0,
      "dupsDropped": 0,
      "seenInvalidated": 0,
      "matchTested": 0
    }
  }
}

-

db.doc.find({'nums.0’: { $gt: -Infinity }}) सही परिणाम देता है, लेकिन खराब प्रदर्शन (पूर्ण संग्रह स्कैन का उपयोग करता है)।

MacBook-Pro(mongod-3.0.14) test> db.doc.find({'nums.0': { $gt: -Infinity }}).count()
5
MacBook-Pro(mongod-3.0.14) test> db.doc.find({'nums.0': { $gt: -Infinity }}).explain('executionStats').executionStats.executionStages
{
  "stage": "COLLSCAN",
  "filter": {
    "nums.0": {
      "$gt": -Infinity
    }
  },
  "nReturned": 5,
  "executionTimeMillisEstimate": 0,
  "works": 2007,
  "advanced": 5,
  "needTime": 2001,
  "needFetch": 0,
  "saveState": 15,
  "restoreState": 15,
  "isEOF": 1,
  "invalidates": 0,
  "direction": "forward",
  "docsExamined": 2005
}

-

db.doc.find({'nums': { $gt: -Infinity }})आश्चर्य की बात है, यह बहुत अच्छी तरह से काम करता है! यह इंडेक्स स्कैन चरण से 5 डॉक्स को आगे बढ़ाते हुए सही परिणाम देता है और यह तेज है।

MacBook-Pro(mongod-3.0.14) test> db.doc.find({'nums': { $gt: -Infinity }}).explain('executionStats').executionStats.executionStages
{
  "stage": "FETCH",
  "nReturned": 5,
  "executionTimeMillisEstimate": 0,
  "works": 16,
  "advanced": 5,
  "needTime": 10,
  "needFetch": 0,
  "saveState": 0,
  "restoreState": 0,
  "isEOF": 1,
  "invalidates": 0,
  "docsExamined": 5,
  "alreadyHasObj": 0,
  "inputStage": {
    "stage": "IXSCAN",
    "nReturned": 5,
    "executionTimeMillisEstimate": 0,
    "works": 15,
    "advanced": 5,
    "needTime": 10,
    "needFetch": 0,
    "saveState": 0,
    "restoreState": 0,
    "isEOF": 1,
    "invalidates": 0,
    "keyPattern": {
      "nums": 1
    },
    "indexName": "nums_1",
    "isMultiKey": true,
    "direction": "forward",
    "indexBounds": {
      "nums": [
        "(-inf.0, inf.0]"
      ]
    },
    "keysExamined": 15,
    "dupsTested": 15,
    "dupsDropped": 10,
    "seenInvalidated": 0,
    "matchTested": 0
  }
}

Comments

आपके बहुत विस्तृत जवाब के लिए धन्यवाद @wojcikstefan दुर्भाग्य से, आपके सुझाए गए समाधान मेरे मामले में काम नहीं करते हैं। मेरे पास 2m दस्तावेजों के साथ एक MongoDB 3.6.4 संग्रह है, उनमें से ज्यादातर एक seen_eventsस्ट्रिंग सरणी है, जिसे अनुक्रमित भी किया गया है। के साथ खोज करते हुए { $gt: -Infinity }, मुझे तुरंत 0 दस्तावेज़ मिलते हैं। उपयोग करने से { $exists: true, $ne: [] }मुझे अधिक संभावित 1,2m डॉक्स मिलते हैं, FETCH स्टेज में बहुत समय बर्बाद होने के साथ: gist.github.com/N-Coder/b9e89a925e895c605d84bfeed642d82c

— NCode 15'18

यह रहे हों तो सही @Ncode लगता है कि आप - MongoDB v3.6 में यह अब काम करता है :( मैं कुछ मिनट के लिए इसके साथ चारों ओर खेला और यहाँ मैं क्या पाया है: 1. db.test_collection.find({"seen_events.0": {$exists: true}})बुरा है क्योंकि यह एक संग्रह स्कैन का उपयोग करता है 2.। db.test_collection.find({seen_events: {$exists: true, $ne: []}})है । बुरा है क्योंकि इसके IXSCAN सभी दस्तावेजों से मेल खाता है और फिर छानने धीमी FETCH चरण में किया जाता है 3. एक ही के लिए चला जाता db.test_collection.find({seen_events: {$exists: true, $not: {$size: 0}}})4. सभी अन्य प्रश्नों अमान्य परिणाम वापस।।

— wojcikstefan

@ एनकोड को एक उपाय मिला! यदि आप निश्चित हैं कि सभी गैर-रिक्त seen_eventsमें तार हैं, तो आप इसका उपयोग कर सकते हैं db.test_collection.find({seen_events: {$gt: ''}}).count():। यह पुष्टि करने के लिए कि यह अच्छा प्रदर्शन करता है, जाँच करें db.test_collection.find({seen_events: {$gt: ''}}).explain(true).executionStats। आप संभवतः यह लागू कर सकते हैं कि देखी गई घटनाएं स्कीमा सत्यापन के माध्यम से तार हैं: docs.mongodb.com/manual/core/schema-validation

— wojcikstefan

धन्यवाद! सभी मौजूदा मूल्य तार हैं इसलिए मैं इसे आज़माऊंगा। MongoDB Bugtracker

— NCode

Answer 5

2.6 रिलीज के साथ शुरू, यह करने के लिए एक और तरीका एक खाली सरणी के लिए क्षेत्र की तुलना है:

ME.find({pictures: {$gt: []}})

शेल में इसका परीक्षण:

> db.ME.insert([
{pictures: [1,2,3]},
{pictures: []},
{pictures: ['']},
{pictures: [0]},
{pictures: 1},
{foobar: 1}
])

> db.ME.find({pictures: {$gt: []}})
{ "_id": ObjectId("54d4d9ff96340090b6c1c4a7"), "pictures": [ 1, 2, 3 ] }
{ "_id": ObjectId("54d4d9ff96340090b6c1c4a9"), "pictures": [ "" ] }
{ "_id": ObjectId("54d4d9ff96340090b6c1c4aa"), "pictures": [ 0 ] }

तो इसमें ठीक प्रकार से डॉक्स शामिल हैं, जिसमें picturesकम से कम एक सरणी तत्व है, और उन डॉक्स को शामिल करता है जहां picturesया तो एक खाली सरणी है, कोई सरणी नहीं है, या गायब है।

Comments

यदि आप अनुक्रमणिका का उपयोग करने का प्रयास करते हैं, तो यह जवाब आपको परेशान कर सकता है। कर db.ME.createIndex({ pictures: 1 })और फिर db.ME.find({pictures: {$gt: []}})शून्य परिणाम लौटाएगा, कम से कम MongoDB v3.0.14 में

— wojcikstefan

@wojcikstefan अच्छी पकड़। इस पर नए सिरे से विचार करने की जरूरत है।

— जॉनीएचएचके

Answer 6

इसे प्राप्त करने के लिए आप निम्नलिखित में से किसी का उपयोग कर सकते हैं।
दोनों उन वस्तुओं के लिए परिणाम नहीं लौटाने का भी ध्यान रखते हैं जिनमें उनके पास अनुरोधित कुंजी नहीं है:

db.video.find({pictures: {$exists: true, $gt: {$size: 0}}})
db.video.find({comments: {$exists: true, $not: {$size: 0}}})

Answer 7

सभी और केवल उन दस्तावेजों को पुनः प्राप्त करें जहां 'चित्र' एक सरणी है और खाली नहीं है

ME.find({pictures: {$type: 'array', $ne: []}})

3.2 से पहले एक MongoDb संस्करण का उपयोग करते समय, के $type: 4बजाय का उपयोग करें $type: 'array'। ध्यान दें कि यह समाधान $ आकार का उपयोग नहीं करता है , इसलिए अनुक्रमित के साथ कोई समस्या नहीं है ("क्वेरी किसी क्वेरी के $ आकार वाले भाग के लिए अनुक्रमित का उपयोग नहीं कर सकते")

इन सहित अन्य समाधान (स्वीकृत उत्तर):

ME.find ({चित्र: {$ मौजूद: सत्य, $ नहीं: {$ आकार: 0}}}); ME.find ({चित्र: {$ मौजूद: सत्य, $ ne: []}})

कर रहे हैं गलत है क्योंकि वे हैं, भले ही दस्तावेज़ लौटाना उदाहरण के लिए, 'चित्र' है null, undefined, 0, आदि

Answer 8

$elemMatchऑपरेटर का उपयोग करें : प्रलेखन के अनुसार

$ ElemMatch ऑपरेटर उन दस्तावेजों से मेल खाता है जिनमें कम से कम एक तत्व के साथ एक सरणी फ़ील्ड होती है जो सभी निर्दिष्ट क्वेरी मानदंडों से मेल खाती है।

$elemMatchesयह सुनिश्चित करता है कि मान एक सरणी है और यह खाली नहीं है। तो क्वेरी कुछ इस तरह होगी

ME.find({ pictures: { $elemMatch: {$exists: true }}})

PS इस कोड का एक प्रकार MongoDB विश्वविद्यालय के M121 पाठ्यक्रम में पाया जाता है।

Answer 9

तुम भी सहायक विधि का उपयोग कर सकते हैं मौजूद है से अधिक मोंगो ऑपरेटर $ मौजूद है

ME.find()
    .exists('pictures')
    .where('pictures').ne([])
    .sort('-created')
    .limit(10)
    .exec(function(err, results){
        ...
    });

Answer 10

{ $where: "this.pictures.length > 1" }

$ का उपयोग करें जहां और इस पास करें ।field_name.length जो सरणी फ़ील्ड का आकार वापस लौटाए और संख्या की तुलना करके इसे जांचें। अगर किसी भी सरणी का कोई भी मान है तो सरणी आकार कम से कम 1 होना चाहिए। इसलिए सभी सरणी फ़ील्ड की लंबाई एक से अधिक है, इसका मतलब है कि उस सरणी में कुछ डेटा है

Answer 11

ME.find({pictures: {$exists: true}}) 

उस के रूप में सरल, यह मेरे लिए काम किया।