如何在MongoDB中使用$graphLookup查询树形结构的所有子节点？

问题场景 #

我在MongoDB中存储了树形结构数据，每个节点代表文件夹、项目、文档、文件等对象，每个节点通过ParentIds列表关联父节点。需要通过指定节点的_id，用$graphLookup聚合查询所有直接和间接子节点。

例如，查询“Project 1”的_id时，需返回“Document 1”、“File 1”、“File 2”和“Document 2”。

数据模型定义 #

TreeNode类（C#）：

public class TreeNode
{
    [BsonId]
    [BsonRepresentation(BsonType.ObjectId)]
    public string Id { get; set; }

    public string Name { get; set; }

    public string ObjectType { get; set; }

    [BsonRepresentation(BsonType.ObjectId)]
    public List<string> ParentIds { get; set; } = new List<string>();
}

测试数据插入代码 #

public async Task InsertNewTestData()
{
    if (await CheckIfDataExistsInCollection())
        return;

    var id1 = ObjectId.GenerateNewId().ToString(); 
    var id2 = ObjectId.GenerateNewId().ToString(); 
    var id3 = ObjectId.GenerateNewId().ToString(); 
    var id4 = ObjectId.GenerateNewId().ToString(); 
    var id5 = ObjectId.GenerateNewId().ToString(); 
    var id6 = ObjectId.GenerateNewId().ToString(); 
    var id7 = ObjectId.GenerateNewId().ToString(); 

    var objects = new List<TreeNode>
    {
        new TreeNode { Id = id1, Name = "Workspace", ObjectType = "folder", ParentIds = new List<string>() },
        new TreeNode { Id = id2, Name = "Project 1", ObjectType = "project", ParentIds = new List<string> { id1 } },
        new TreeNode { Id = id3, Name = "Document 1", ObjectType = "document", ParentIds = new List<string> { id2 } },
        new TreeNode { Id = id4, Name = "File 1", ObjectType = "file", ParentIds = new List<string> { id3 } },
        new TreeNode { Id = id5, Name = "File 2", ObjectType = "file", ParentIds = new List<string> { id3 } },
        new TreeNode { Id = id6, Name = "Document 2", ObjectType = "document", ParentIds = new List<string> { id2 } },
        new TreeNode { Id = id7, Name = "Project 2", ObjectType = "project", ParentIds = new List<string> { id1 } },
    };

    await _context.ObjectsTree.InsertManyAsync(objects);
}

尝试的无效代码 #

var pipeline = new[]
{
    new BsonDocument("$match", new BsonDocument("_id", new ObjectId("_id"))),
    new BsonDocument("$graphLookup", new BsonDocument
    {
        { "from", "ObjectsTree" },
        { "startWith", "$ParentIds" },
        { "connectFromField", "_id" },
        { "connectToField", "ParentIds" },
        { "as", "children" },
        { "depthField", "depth" }
    })
};

var result = await _context.ObjectsTree.Aggregate<BsonDocument>(pipeline).ToListAsync();

问题分析 #

当前$graphLookup配置存在核心错误：

• startWith参数错误：应该从目标节点的_id出发查找子节点，而非目标节点的ParentIds列表
• 类型匹配隐患：传入的ID字符串需转换为ObjectId类型，与MongoDB中存储的_id和ParentIds类型保持一致，避免字符串与ObjectId不匹配导致的匹配失败

解决方案 #

正确的聚合管道代码 #

// targetId为传入的"Project 1"的_id字符串
var targetObjectId = new ObjectId(targetId);

var pipeline = new[]
{
    // 匹配目标节点
    new BsonDocument("$match", new BsonDocument("_id", targetObjectId)),
    // 执行图查找，递归获取所有子节点
    new BsonDocument("$graphLookup", new BsonDocument
    {
        { "from", "ObjectsTree" },
        { "startWith", "$_id" }, // 从目标节点ID开始，查找包含此ID的子节点
        { "connectFromField", "_id" }, // 父节点的_id作为连接源
        { "connectToField", "ParentIds" }, // 子节点的ParentIds列表作为连接目标
        { "as", "children" }, // 存储结果的字段名
        { "depthField", "depth" }, // 可选：记录节点与目标节点的层级深度
        { "maxDepth", -1 } // 可选：-1表示无深度限制，默认值也是-1
    }),
    // 可选：过滤掉目标节点自身，只保留子节点
    new BsonDocument("$project", new BsonDocument
    {
        "_id", 1,
        "Name", 1,
        "ObjectType", 1,
        "ParentIds", 1,
        "children", new BsonDocument("$filter", new BsonDocument
        {
            { "input", "$children" },
            { "cond", new BsonDocument("$ne", new BsonArray { "$$this.depth", 0 }) }
        })
    })
};

var result = await _context.ObjectsTree.Aggregate<BsonDocument>(pipeline).ToListAsync();

关键修正点 #

1. startWith参数修正：设置为$_id，确保从目标节点自身出发，递归查找所有将此ID包含在ParentIds中的子节点
2. 类型一致性保证：将传入的字符串ID转换为ObjectId，与MongoDB中存储的类型匹配，避免类型不匹配导致的匹配失效
3. 可选的子节点过滤：通过$filter排除depth为0的目标节点自身，仅返回真正的子节点

验证结果 #

执行上述代码后，查询“Project 1”的ID时，children数组会按层级返回：

• Document 1（depth=1）
• Document 2（depth=1）
• File 1（depth=2）
• File 2（depth=2）
  完全符合预期需求。

内容的提问来源于stack exchange，提问作者Jovan Dimov