मोंगो - मैच जहां वस्तु कुंजी परिवर्तनशील है

MongoDB 3.4.4 के साथ, दस्तावेज़ को क्वेरी करने के लिए एकत्रीकरण ढांचे का उपयोग करें। यह $objectToArray से संभव हुआ है। ऑपरेटर जो आपको संसाधित फ़ील्ड में कुंजियों को कुंजी/मान जोड़े की एक सरणी में मैप करने की अनुमति देता है। सूची को फ़िल्टर करना और आपकी किसी भी स्थिति से मेल खाने वाली कुंजी प्राप्त करना आसान होगा।

निम्नलिखित उदाहरण में, एकत्रीकरण पाइपलाइन में एक अतिरिक्त फ़ील्ड होता है जिसमें कुंजी (कुंजी) होती है जो झूठी मान होने की उपरोक्त स्थिति से मेल खाती है, इसलिए आदर्श रूप से यह एक सरणी होगी:

db.collection.aggregate([
    { "$addFields": {
        "notProcessed": { 
            "$map" : {
                "input": {
                    "$filter": {
                        "input": { "$objectToArray": "$processed" },
                        "as": "el",
                        "cond": { "$not": "$$el.v" }
                    }
                },
                "in": "$$this.k"
            }
        }
    } }
])

जो पैदावार

{
    "_id" : ObjectId("5501b1648ef0b4eccc41814e"),
    "link" : "xxxxx.jpg",
    "processed" : {
        "320" : true,
        "480" : true,
        "540" : true,
        "720" : true,
        "800" : true,
        "1080" : true,
        "original" : false,
        "iPhone" : true
    },
    "notProcessed" : [ 
        "original"
    ]
}

स्पष्टीकरण

नेस्टेड एक्सप्रेशन से शुरू करना

{
    "$filter": {
        "input": { "$objectToArray": "$processed" },
        "as": "el",
        "cond": { "$not": "$$el.v" }
    }
}

$filter में इनपुट ऑपरेटर { "$objectToArray": "$processed" } कुंजियों को processed में बदल देगा इस सरणी की कुंजी:

[ 
    {
        "k" : "320",
        "v" : true
    }, 
    {
        "k" : "480",
        "v" : true
    }, 
    {
        "k" : "540",
        "v" : true
    }, 
    {
        "k" : "720",
        "v" : true
    }, 
    {
        "k" : "800",
        "v" : true
    }, 
    {
        "k" : "1080",
        "v" : true
    }, 
    {
        "k" : "original",
        "v" : false
    }, 
    {
        "k" : "iPhone",
        "v" : true
    }
]

और $filter उपरोक्त सरणी को केवल उन ऑब्जेक्ट तत्वों के लिए फ़िल्टर करेगा जिनके v संपत्ति है NOT true :

[ 
    {
        "k" : "original",
        "v" : false
    }
]

$map फिर केवल मानों के साथ एक मैप की गई सरणी लौटाएगा

[ { "k" : "original", "v" : false } ] => [ "original" ]

तो आप बस

[ "original" ]

परिणामस्वरूप।

पुराने MongoDB संस्करणों के साथ, डायनेमिक कुंजियों के विरुद्ध क्वेरी जारी करना बहुत कठिन होने वाला है। इस दस्तावेज़ मॉडल का अनुसरण करने के लिए अपनी स्कीमा को संशोधित करने पर विचार करें जो क्वेरी करना आसान है:

// this operation changes the schema
var processed = [];
db.collection.find().forEach( function(doc) {
     for(key in doc.processed) {
        if(doc.processed.hasOwnProperty(key)) {
            var item = { key: key, value: doc.processed[key] }
            processed.push(item);            
        }
     }
     doc.processed = processed;
     db.collection.save(doc);
});

// modified schema    

{ 
    "link": "xxxxx.jpg"
    "_id": ObjectId("5501b1648ef0b4eccc41814e"),
    "processed": [
         { "key": "320", "value": true },
         { "key": "480", "value": true },
         { "key": "540", "value": true },
         { "key": "720", "value": true },
         { "key": "800", "value": true },
         { "key": "1080", "value": true },
         { "key": "original", "value": false },
         { "key": "iPhone", "value": true }
    ]
}

आपकी खोज क्वेरी सरल होगी

db.collection.find({"processed.value": false});

या $map का इस्तेमाल करें और $filter false के साथ कुंजियों को वापस करने के लिए मान

db.collection.aggregate([
    { "$project": {
        "link": 1,
        "notProcessed": { 
            "$map" : {
                "input": {
                    "$filter": {
                        "input": "$processed",
                        "as": "el",
                        "cond": { "$not": "$$el.v" }
                    }
                },
                "in": "$$this.k"
            }
        }
    } }
])