MongoDB嵌套回复评论：聚合查询结果异常问题排查

问题场景 #

现有多级评论链结构如下：

[id: 10] 根评论
|
|-- [id: 11] 回复根评论
|   |
|   |-- [id: 12] 回复根评论的回复
|       |
|       |-- [id: 13] 该评论链最底层评论
|
|-- [id: 19] 根评论的另一条回复

每条评论的parents数组包含从根到自身的完整路径，例如最底层评论的parents为[10, 11, 12, 13]。需要查询返回根评论+完整嵌套回复的结构，期望输出示例：

{
    "_id": "10",
    "postId": "333",
    "replies": [
        {
            "_id": "11",
            "replies": [
                {
                    "_id": "12",
                    "replies": [{"_id": "13", ...}]
                }
            ]
        },
        {"_id": "19", ...}
    ],
    ...
}

当前聚合查询返回结果异常，根评论ID被错误包含在嵌套结构中，原查询代码如下：

db.comments.aggregate([
        {
            $match: { $and: [
                { "postId": "333" },
                { "parents": { $size: 1 } }
            ]}
        },
        {
            $lookup: {
                from: "comments",
                localField: "_id",
                foreignField: "parents",
                pipeline: [{ $sort: { "createdAt": 1 }}],
                as: "replies"
            }
        },
    {
        $sort: { "createdAt": -1 }
    }
]);

问题根源 #

原查询存在两个核心问题：

1. 匹配逻辑错误：$lookup用parents作为匹配字段，而parents是完整路径数组，只要数组包含根评论ID的评论都会被拉取，无法区分直接子评论和深层嵌套评论，导致结构混乱。
2. 不支持多级嵌套：仅做了一级$lookup，无法递归拉取深层回复，只能获取根评论的直接子评论，无法构建完整的多级评论链。

修正方案 #

方案1：递归$lookup（精准控制层级） #

适用于明确知道评论最大层级的场景，通过嵌套$lookup递归拉取每一层回复：

db.comments.aggregate([
    // 筛选目标帖子的根评论（parents长度为1，仅包含自身ID）
    {
        $match: {
            "postId": "333",
            "parents": { $size: 1 }
        }
    },
    // 拉取根评论的直接子评论
    {
        $lookup: {
            from: "comments",
            let: { parentId: "$_id" },
            pipeline: [
                {
                    $match: {
                        $expr: {
                            // 匹配直接子评论：parents倒数第二个元素是当前父评论ID
                            $eq: [{ $arrayElemAt: ["$parents", -2] }, "$$parentId"]
                        }
                    }
                },
                { $sort: { "createdAt": 1 } },
                // 递归拉取子评论的回复
                {
                    $lookup: {
                        from: "comments",
                        let: { childParentId: "$_id" },
                        pipeline: [
                            {
                                $match: {
                                    $expr: {
                                        $eq: [{ $arrayElemAt: ["$parents", -2] }, "$$childParentId"]
                                    }
                                }
                            },
                            { $sort: { "createdAt": 1 } },
                            // 继续嵌套可支持更深层级，这里以3层为例
                            {
                                $lookup: {
                                    from: "comments",
                                    let: { deepParentId: "$_id" },
                                    pipeline: [
                                        {
                                            $match: {
                                                $expr: {
                                                    $eq: [{ $arrayElemAt: ["$parents", -2] }, "$$deepParentId"]
                                                }
                                            }
                                        },
                                        { $sort: { "createdAt": 1 } }
                                    ],
                                    as: "replies"
                                }
                            }
                        ],
                        as: "replies"
                    }
                }
            ],
            as: "replies"
        }
    },
    // 根评论按创建时间倒序排列
    { $sort: { "createdAt": -1 } }
]);

方案2：$graphLookup（自动递归所有层级） #

适用于不确定评论层级的场景，用$graphLookup自动遍历所有嵌套评论，再通过自定义函数转为嵌套结构：

db.comments.aggregate([
    // 筛选目标帖子的根评论
    {
        $match: {
            "postId": "333",
            "parents": { $size: 1 }
        }
    },
    // 递归拉取所有子评论，返回扁平化结果
    {
        $graphLookup: {
            from: "comments",
            startWith: "$_id",
            connectFromField: "_id",
            connectToField: { $arrayElemAt: ["$parents", -2] }, // 子评论的父ID是其parents倒数第二个元素
            as: "replies",
            depthField: "depth", // 可选，记录当前评论相对于根的层级
            restrictSearchWithMatch: { "postId": "333" }, // 限定只查当前帖子的评论
            pipeline: [{ $sort: { "createdAt": 1 } }] // 子评论按创建时间正序排列
        }
    },
    // 将扁平化的replies转为层级嵌套结构
    {
        $addFields: {
            replies: {
                $function: {
                    body: function(replies) {
                        const commentMap = new Map();
                        // 先把所有评论存入Map，方便快速查找
                        replies.forEach(comment => {
                            commentMap.set(comment._id, { ...comment, replies: [] });
                        });
                        // 构建嵌套关系
                        replies.forEach(comment => {
                            const parentId = comment.parents[comment.parents.length - 2];
                            if (commentMap.has(parentId)) {
                                commentMap.get(parentId).replies.push(commentMap.get(comment._id));
                            }
                        });
                        // 返回根评论的直接子评论（parents长度为2的评论）
                        return replies.filter(c => c.parents.length === 2).map(c => commentMap.get(c._id));
                    },
                    args: ["$replies"],
                    lang: "js"
                }
            }
        }
    },
    { $sort: { "createdAt": -1 } }
]);

核心修正点 #

• 替换匹配逻辑：通过$arrayElemAt: ["$parents", -2]获取评论的直接父ID，精准匹配子评论，避免根ID被错误包含
• 实现多级嵌套：用递归$lookup或$graphLookup拉取所有层级的回复，构建完整评论链
• 结构整理：将扁平化结果转为嵌套结构，符合预期的输出格式

内容的提问来源于stack exchange，提问作者Ali Celebi