Cara menggunakan $in atau $nin dalam agregasi mongo $group $cond

Perbandingan di $setIsSubset adalah opsi yang lebih pendek daripada $or kondisi yang Anda gunakan, meskipun pada dasarnya masih valid untuk melakukan apa yang Anda lakukan.

Satu-satunya tangkapan dengan $setIsSubset adalah bahwa setiap argumen adalah array sehingga Anda perlu mengonversi elemen tunggal sebagai array elemen tunggal. Ini cukup mudah menggunakan $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
                ]
            }
        }
    }}    
])

Atau jika Anda mau, cocokkan larik argumen dengan nilai tunggal, dengan $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
                ]
            }
        }
    }}
])

Dimana $map alih-alih melintasi argumen untuk dicocokkan dengan singular daripada memaksa singular menjadi array.

Dan tentu saja karena kedua formulir pada dasarnya memasok true/false ke $cond maka Anda bisa membalikkan logika dengan $not jika diperlukan:

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
                ]
            }
        }
    }}
])

Itu benar-benar tergantung pada bagaimana Anda melihatnya, tetapi hanya sebagai argumen yang diberikan maka Anda tidak benar-benar mendapatkan apa pun dari bentuk aslinya dengan $or . Ini mungkin terlihat sedikit lebih bersih dan "lebih mudah untuk diketik", tetapi biasanya saya tidak akan "mengetik" logika seperti itu ke dalam pipa agregasi secara langsung, melainkan menghasilkan bagian struktur itu berdasarkan daftar biasa di tempat pertama:

yaitu

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

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

Dan kemudian hanya menggunakan konten array yang dipetakan ulang dalam definisi pipeline:

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

Apapun cara Anda melihatnya, ingat itu semua hanya struktur data dan Anda memiliki proses dasar untuk memanipulasi. Baik di dalam pemrosesan pipa maupun di dalam konstruksi pipa itu sendiri.