我有下表:

> db.foo.find()
{ "_id" : 1, "k" : [ { "a" : 50, "b" : 10 } ] }
{ "_id" : 2, "k" : [ { "a" : 90, "b" : 80 } ] }

在 k 字段上使用复合索引:

"key" : {
        "k.a" : 1,
        "k.b" : 1
},
"name" : "k.a_1_k.b_1"

如果我运行以下查询:

db.foo.aggregate([ 
    { $match:   { "k.a" : 50 } },
    { $project: { _id : 0, "dummy": {$literal:""} }} 
])

如果使用索引(有意义)并且不需要 FETCH 阶段:

"winningPlan" : {
        "stage" : "COUNT_SCAN",
        "keyPattern" : {
                "k.a" : 1,
                "k.b" : 1
        },
        "indexName" : "k.a_1_k.b_1",
        "isMultiKey" : false,
        "multiKeyPaths" : {
                "k.a" : [ ],
                "k.b" : [ ]
        },
        "isUnique" : false,
        "isSparse" : false,
        "isPartial" : false,
        "indexVersion" : 2,
        "indexBounds" : {
                "startKey" : {
                        "k.a" : 50,
                        "k.b" : { "$minKey" : 1 }
                },
                "startKeyInclusive" : true,
                "endKey" : {
                        "k.a" : 50,
                        "k.b" : { "$maxKey" : 1 }
                },
                "endKeyInclusive" : true
        }
}

但是，如果我运行以下使用 $elemMatch 的查询:

db.foo.aggregate([  
   { $match:   { k: {$elemMatch: {a : 50, b : { $in : [5, 6, 10]}}}} },
   { $project: { _id : 0, "dummy" : {$literal : ""}} } 
])

有一个 FETCH 阶段(AFAIK 不是必需的):

"winningPlan" : {
        "stage" : "FETCH",
        "filter" : {
                "k" : {
                        "$elemMatch" : {
                                "$and" : [
                                        { "a" : { "$eq" : 50 } },
                                        { "b" : { "$in" : [ 5, 6, 10 ] } }
                                ]
                        }
                }
        },
        "inputStage" : {
                "stage" : "IXSCAN",
                "keyPattern" : {
                        "k.a" : 1,
                        "k.b" : 1
                },
                "indexName" : "k.a_1_k.b_1",
                "isMultiKey" : false,
                "multiKeyPaths" : {
                        "k.a" : [ ],
                        "k.b" : [ ]
                },
                "isUnique" : false,
                "isSparse" : false,
                "isPartial" : false,
                "indexVersion" : 2,
                "direction" : "forward",
                "indexBounds" : {
                        "k.a" : [
                                "[50.0, 50.0]"
                        ],
                        "k.b" : [
                                "[5.0, 5.0]",
                                "[6.0, 6.0]",
                                "[10.0, 10.0]"
                        ]
                }
        }
},

我正在使用 MongoDB 3.4。 我问这个是因为我有一个包含大量文档的数据库，并且有一个使用 aggregate() 和 $elemMatch 的查询(它比不投影任何东西更有用，如这个问题 OFC，但理论上事情不需要 FETCH 阶段)。如果是 FETCH 阶段，我发现查询速度慢的主要原因是不需要 AFAIK。

当使用 $elemMatch 时，是否有一些逻辑强制 MongoDB 使用 FETCH，或者它只是缺少优化？

最佳答案

看起来即使是单个“$elemMatch”也会强制 mongo 执行 FETCH -> COUNT 而不是 COUNT_SCAN。通过简单的重现步骤在他们的 Jira 中打开了一张票 - https://jira.mongodb.org/browse/SERVER-35223

关于mongodb - 使用 $elemMatch 时，如果索引覆盖过滤器，为什么 MongoDB 会执行 FETCH 阶段？，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/47473283/