मोंगो एकत्रीकरण $group $cond . में $in या $nin का उपयोग कैसे करें

$setIsSubset पर तुलना $or . से छोटा विकल्प है शर्त आप उपयोग कर रहे हैं, हालांकि यह अभी भी मूल रूप से मान्य है जो आप कर रहे हैं।

$setIsSubset . के साथ एकमात्र कैच यह है कि प्रत्येक तर्क एक सरणी है, इसलिए आपको एकल तत्व को एकल तत्व सरणी के रूप में परिवर्तित करने की आवश्यकता है। यह $map का उपयोग करके काफी आसान है :

db.collectionName.aggregate([
    { "$group": {
        "_id": "$createdAt",
        "count": { "$sum": 1 },
        "count_failure": {
            "$sum": {
                "$cond": [
                    { "$setIsSubset": [
                        { "$map": {
                            "input": ["A"],
                            "as": "el",
                            "in": "$id"
                        }},
                        [ 0,100,101,102,103,104,105 ],
                    ]},
                    1,
                    0
                ]
            }
        }
    }}    
])

या यदि आप चाहें, तो इसके बजाय एकवचन मान के विरुद्ध तर्कों की सरणी का मिलान $anyElementTrue :

db.collectionName.aggregate([
    { "$group": {
        "_id": "$createdAt",
        "count": { "$sum": 1 },
        "count_failure": {
            "$sum": {
                "$cond": [
                    { "$anyElementTrue": { "$map": {
                        "input": [ 0,100,101,102,103,104,105 ],
                        "as": "el",
                        "in": { "$eq": [ "$$el", "$id" ] }
                    }}},
                    1,
                    0
                ]
            }
        }
    }}
])

जहां $map एकवचन को एक सरणी में मजबूर करने के बजाय एकवचन से मेल खाने के लिए तर्कों को पार कर रहा है।

और निश्चित रूप से कोई भी फॉर्म अनिवार्य रूप से true/false . की आपूर्ति कर रहा है $cond . के लिए तो आप तर्क को उल्टा कर सकते हैं $not जहां आवश्यक हो:

db.collectionName.aggregate([
    { "$group": {
        "_id": "$createdAt",
        "count": { "$sum": 1 },
        "count_failure": {
            "$sum": {
                "$cond": [
                    { "$not": [{ "$anyElementTrue": { "$map": {
                        "input": [ 0,100,101,102,103,104,105 ],
                        "as": "el",
                        "in": { "$eq": [ "$$el", "$id" ] }
                    }}}]},
                    1,
                    0
                ]
            }
        }
    }}
])

यह वास्तव में इस पर निर्भर करता है कि आप इसे कैसे देखते हैं, लेकिन केवल आपूर्ति किए गए तर्कों के रूप में आपको मूल रूप से $or के साथ वास्तव में कुछ भी हासिल नहीं होता है . यह थोड़ा साफ और "टाइप करने में आसान" लग सकता है, लेकिन आम तौर पर मैं इस तरह के तर्क को सीधे एकत्रीकरण पाइपलाइन में "टाइपिंग" नहीं करता, बल्कि पहली जगह में एक सादे सूची के आधार पर संरचना के उस हिस्से को उत्पन्न करता हूं:

यानी

var failList = [ 0,100,101,102,103,104,105 ];

var orCondition = failList.map(function(el) { 
    return { "$eq": [ "$id", el ] }
})

और फिर पाइपलाइन परिभाषा में केवल पुन:मैप की गई सरणी सामग्री का उपयोग करना:

    { "$group": {
        "_id": "$createdAt",
        "count": { "$sum": 1 },
        "count_failure": {
            "$sum": {
                "$cond": [
                    { "$or": orCondition },
                    1,
                    0
                ]
            }
        }
    }}
])

आप इसे किसी भी तरह से देखें, याद रखें कि यह केवल डेटा संरचनाएं हैं और आपके पास हेरफेर करने के लिए बुनियादी प्रक्रियाएं हैं। दोनों पाइपलाइन प्रसंस्करण के अंदर और पाइपलाइन निर्माण में भी।