Nin mongodb

So sánh trên $setIsSubset là một lựa chọn ngắn hơn so với điều kiện $or mà bạn đang sử dụng, dù vậy về cơ bản nó vẫn có giá trị để thực hiện những gì bạn đang làm

Điều hấp dẫn duy nhất với $setIsSubset là mỗi đối số là một mảng, do đó bạn cần chuyển đổi một phần tử thành một mảng phần tử duy nhất. Điều này đủ dễ dàng bằng cách sử dụng

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

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

Hoặc nếu bạn thích, thì thay vào đó hãy so khớp mảng đối số với giá trị số ít, với

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

Trường hợp

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

Và tất nhiên vì một trong hai hình thức về cơ bản là cung cấp

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

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

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

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

Nó thực sự phụ thuộc vào cách bạn nhìn vào nó, nhưng chỉ đơn giản là các đối số được cung cấp thì bạn không thực sự đạt được bất cứ điều gì so với biểu mẫu ban đầu với $or. Nó có thể trông gọn gàng hơn một chút và "dễ gõ hơn", nhưng thông thường tôi sẽ không trực tiếp "gõ" logic như vậy vào đường dẫn tổng hợp, mà thay vào đó tạo ra phần cấu trúc đó dựa trên danh sách đơn giản ngay từ đầu

i. e

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

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

Và sau đó chỉ cần sử dụng nội dung mảng được ánh xạ lại trong định nghĩa đường ống

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

Dù bạn nhìn nó theo cách nào, hãy nhớ rằng tất cả chỉ là cấu trúc dữ liệu và bạn có các quy trình cơ bản để thao tác. Cả bên trong quá trình xử lý đường ống và cả trong chính việc xây dựng đường ống

Nin trong MongoDB là gì?

Làm cách nào để sử dụng Nin trong MongoDB?

Làm cách nào để sắp xếp dữ liệu trong MongoDB?

Làm cách nào để sử dụng elemMatch trong MongoDB?