MongoDB未知深度嵌入数据/数组的$lookup实现方案问询

我有一个多层未知/动态嵌套的数据结构（示例如下）：

{
  "_id": "652be26ec569bba673fa3539",
  "a": [
    {"_id": "652be3616dbd4840c17adf1f", "noteIds": ["652be3c5090a2b22c1d35a2d", "652be3d0ba2da5cb7ddf36ac"]},
    {"_id": "652be3f0d02743f9059e583d", "noteIds": ["652be401bb0100c78a55ce3a", "652be40947bcd5275d272d46"]}
  ],
  "b": {
    "c": {
      "noteIds": ["652be47a0994896f73ce4c48", "652be481cef028a036e09646"]
    }
  }
}

已知关联路径（如a.noteIds、b.c.noteIds）是动态的，无法硬编码到代码中。需要通过MongoDB的$lookup操作，将所有嵌套位置的noteIds替换为对应的notes文档，最终得到如下结构：

{
  "_id": "652be26ec569bba673fa3539",
  "a": [
    {"_id": "652be3616dbd4840c17adf1f", "notes": [{"_id": "652be3c5090a2b22c1d35a2d", ...}, {"_id": "652be3d0ba2da5cb7ddf36ac", ...}]},
    {"_id": "652be3f0d02743f9059e583d", "notes": [{"_id": "652be401bb0100c78a55ce3a", ...}, {"_id": "652be40947bcd5275d272d46", ...}]}
  ],
  "b": {
    "c": {
      "notes": [{"_id": "652be47a0994896f73ce4c48", ...}, {"_id": "652be481cef028a036e09646", ...}]
    }
  }
}

解决方案 #

由于嵌套深度未知且路径动态，纯聚合操作符难以处理，推荐使用MongoDB 4.4+支持的$function实现递归遍历与替换，步骤如下：

1. 提取所有noteIds并去重

通过递归遍历文档，收集所有位置的noteIds，避免多次$lookup影响性能：

{
  $addFields: {
    allNoteIds: {
      $function: {
        body: function(doc) {
          let ids = [];
          function traverse(obj) {
            if (obj && typeof obj === 'object') {
              if (Array.isArray(obj)) {
                obj.forEach(item => traverse(item));
              } else {
                if (obj.noteIds && Array.isArray(obj.noteIds)) {
                  ids.push(...obj.noteIds);
                }
                Object.values(obj).forEach(val => traverse(val));
              }
            }
          }
          traverse(doc);
          return [...new Set(ids)]; // 去重减少关联量
        },
        args: ["$$ROOT"],
        lang: "js"
      }
    }
  }
}

2. 批量关联notes集合

用收集到的allNoteIds执行一次$lookup，获取所有对应的笔记文档：

{
  $lookup: {
    from: "notes",
    localField: "allNoteIds",
    foreignField: "_id",
    as: "notesLookup"
  }
}

3. 递归替换noteIds为notes

将关联结果转为Map快速查找，再次递归遍历原文档，替换所有noteIds字段为对应的笔记数组，并删除原noteIds字段：

{
  $addFields: {
    mappedDoc: {
      $function: {
        body: function(doc, notes) {
          const noteMap = new Map(notes.map(n => [n._id.toString(), n]));
          function replaceIds(obj) {
            if (obj && typeof obj === 'object') {
              if (Array.isArray(obj)) {
                return obj.map(item => replaceIds(item));
              } else {
                const newObj = {...obj};
                if (newObj.noteIds) {
                  newObj.notes = newObj.noteIds.map(id => noteMap.get(id.toString())).filter(Boolean);
                  delete newObj.noteIds;
                }
                Object.keys(newObj).forEach(key => {
                  newObj[key] = replaceIds(newObj[key]);
                });
                return newObj;
              }
            }
            return obj;
          }
          return replaceIds(doc);
        },
        args: ["$$ROOT", "$notesLookup"],
        lang: "js"
      }
    }
  }
}

4. 清理临时字段并替换根文档

将处理后的mappedDoc作为根文档，移除临时生成的allNoteIds和notesLookup字段：

{
  $replaceRoot: { newRoot: "$mappedDoc" }
},
{
  $project: { allNoteIds: 0, notesLookup: 0 }
}

注意事项 #

• 该方案依赖MongoDB 4.4及以上版本的$function特性，若使用更低版本，需通过复杂的聚合操作符组合模拟递归，实现成本极高
• 递归遍历需注意文档是否存在循环引用，若有需在遍历逻辑中添加循环引用检测
• 批量收集noteIds后单次$lookup的模式，相比多次嵌套$lookup能大幅提升查询性能

内容的提问来源于stack exchange，提问作者alex-e-leon