我有一个平面文档集合，其中一些文档有一个 parent: ObjectId 字段，它指向同一集合中的另一个文档，即:

{id: 1, metadata: {text: "I'm a parent"}}
{id: 2, metadata: {text: "I'm child 1", parent: 1}}

现在我想检索 metadata.text = "I'm a parent" 及其子元素的所有父级。但我想要嵌套格式的数据，因此我可以在之后简单地处理它而无需查看 metadata.parent。输出应如下所示:

{
  id: 1,
  metadata: {text: "I'm a parent"},
  children: [
    {id: 2, metadata: {text: "I'm child 1", parent: 1}}
  ]
}

(children 也可以是父对象的 metadata 对象的一部分，如果这样更容易的话)

为什么我不以嵌套结构保存文档？我不想在数据库中以嵌套格式存储数据，因为这些文档是 GridFS 的一部分。

主要问题是:如何让 MongoDB 嵌套整个文档？还是我必须使用 Mongo 的聚合框架来完成该任务？

最佳答案

对于您要求的那种“投影”，聚合框架是正确的工具，因为只有那里才真正支持这种“文档 reshape ”。

另一种情况是“父/子”问题，您在使用聚合框架进行分组时再次需要“创造性”。完整的操作显示了本质上涉及的内容:

db.collection.aggregate([

    // Group parent and children together with conditionals
    { "$group": {
        "_id": { "$ifNull": [ "$metadata.parent", "$_id" ] },
        "metadata": {
            "$addToSet": {
                "$cond": [
                    { "$ifNull": [ "$metadata.parent", false ] },
                    false,
                    "$metadata"
                ]
            }
        },
        "children": {
            "$push": {
                "$cond": [
                    { "$ifNull": [ "$metadata.parent", false ] },
                    "$$ROOT",
                    false
                ]
            }
        }
    }},

    // Filter out "false" values
    { "$project": {
        "metadata": { "$setDifference": [ "$metadata", [false] ] },
        "children": { "$setDifference": [ "$children", [false] ] }
    }},

    // metadata is an array but should only have one item
    { "$unwind": "$metadata" },

    // This is essentially sorting the children as "sets" are un-ordered 
    { "$unwind": "$children" },
    { "$sort": { "_id": 1, "children._id": 1 } },
    { "$group": {
        "_id": "$_id",
        "metadata": { "$first": "$metadata" },
        "children": { "$push": "$children" }
    }}
])

这里最主要的是 $ifNull用于分组 _id 的运算符。这将选择$group在存在的“父”字段上，否则使用一般文档 _id。

用 $cond 完成了类似的事情运算符稍后评估哪些数据被添加到数组或“集合”。在下面$project false 值通过使用 $setDifference 过滤掉运营商。

如果最后$sort和 $group看起来很困惑，那么实际原因是因为使用的运算符是一个“集合”运算符，结果“集合”被认为是无序的。所以实际上那部分只是为了确保数组内容按照它们自己的 _id 字段的顺序出现。

如果没有来自 MongoDB 2.6 的额外运算符，这仍然可以完成，但只是稍有不同。

db.collection.aggregate([
    { "$group": {
        "_id": { "$ifNull": [ "$metadata.parent", "$_id" ] },
        "metadata": {
            "$addToSet": {
                "$cond": [
                    { "$ifNull": [ "$metadata.parent", false ] },
                    false,
                    "$metadata"
                ]
            }
        },
        "children": {
            "$push": {
                "$cond": [
                    { "$ifNull": [ "$metadata.parent", false ] },
                    { "_id": "$_id","metadata": "$metadata" },
                    false
                ]
            }
        }
    }},
    { "$unwind": "$metadata" },
    { "$match": { "metadata": { "$ne": false } } },
    { "$unwind": "$children" },
    { "$match": { "children": { "$ne": false } } },
    { "$sort": { "_id": 1, "children._id": 1 } },
    { "$group": {
        "_id": "$_id",
        "metadata": { "$first": "$metadata" },
        "children": { "$push": "$children" }
    }}
])

本质上是一样的，但没有在 MongoDB 2.6 中引入更新的运算符，所以这也适用于早期版本。

只要您的关系是单级父子关系，这一切都很好。对于嵌套级别，您需要改为调用 mapReduce 进程。

关于mongodb - 使用 MongoDB 投影嵌套整个文档？，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/25017543/