MongoDB深度嵌套对象的指定对象获取更新及深层文件详情查询方法

问题 #

1. 如何在MongoDB中，未知嵌套深度的情况下，获取并更新深度嵌套对象中的特定对象？
2. 如何获取嵌套在数组对象第三或第四层级的文件详情？随着文件夹结构加深，文档嵌套层级更复杂时，如何通过ID获取单个文件，以及如何获取或更新最末层级的文件详情？

示例文档结构 #

{
  "_id": { "$oid": "6368b3041bbaad24741c5e9e" },
  "folderName": "new folder",
  "folders": [
    {
      "_id": { "$oid": "6368b3181bbaad24741c5ea0" },
      "folderName": "new sub folder",
      "folders": [
        {
          "_id": { "$oid": "636a2e9a24ebee4bee48cd23" },
          "folderName": "new sub folder2",
          "folders": [],
          "files": [
            {
              "_id": { "$oid": "636a2f2624ebee4bee48cd24" },
              "folderName": "new sub folder2",
              "fileName": "test doc",
              "title": "title 2",
              "createdby": "maha",
              "status": "draft",
              "content": "<p>This is a sample document inside a sub folder</p>"
            }
          ]
        }
      ],
      "files": [
        {
          "_id": { "$oid": "6368b443926f6cdade511159" },
          "folderName": "new sub folder",
          "fileName": "test doc 1",
          "title": "title 1",
          "createdby": "maha",
          "status": "draft",
          "content": "<p>This is a sample document inside a sub folder</p>"
        }
      ]
    }
  ],
  "files": [
    {
      "_id": { "$oid": "6369f117ac08b48033788b2e" },
      "folderName": "new folder",
      "fileName": "test doc 1",
      "title": "title 2",
      "createdby": "maha",
      "status": "draft",
      "content": "<p>This is a sample <strong>doc 1</strong></p>"
    }
  ]
}

解决方案 #

一、未知嵌套深度下的对象获取与更新 #

针对单文档内多层嵌套的结构，普通查询无法直接穿透未知深度，需用递归逻辑处理，以下是具体实现：

1. 获取特定对象（按文件ID查找）

使用MongoDB 4.4+支持的$function编写递归函数，遍历所有层级的文件夹与文件：

db.collection.aggregate([
  // 匹配目标根文档（可选，若知道根ID可添加）
  { $match: { _id: ObjectId("6368b3041bbaad24741c5e9e") } },
  {
    $addFields: {
      targetFile: {
        $function: {
          body: function findFile(doc) {
            // 检查当前层级文件
            const found = doc.files?.find(f => f._id.toString() === "636a2f2624ebee4bee48cd24");
            if (found) return found;
            // 递归遍历子文件夹
            for (const folder of doc.folders || []) {
              const result = findFile(folder);
              if (result) return result;
            }
            return null;
          },
          args: ["$$ROOT"],
          lang: "js"
        }
      }
    }
  },
  { $match: { targetFile: { $ne: null } } },
  { $project: { targetFile: 1, _id: 0 } }
])

2. 更新特定对象（修改文件属性）

采用聚合更新结合递归函数，实现原子性更新：

db.collection.updateOne(
  { _id: ObjectId("6368b3041bbaad24741c5e9e") },
  [
    {
      $set: {
        root: {
          $function: {
            body: function updateFile(doc) {
              // 更新当前层级匹配的文件
              if (doc.files) {
                doc.files = doc.files.map(f => {
                  if (f._id.toString() === "636a2f2624ebee4bee48cd24") {
                    return { ...f, status: "published" };
                  }
                  return f;
                });
                // 检查是否已更新，避免无效递归
                const updated = doc.files.find(f => f._id.toString() === "636a2f2624ebee4bee48cd24" && f.status === "published");
                if (updated) return doc;
              }
              // 递归处理子文件夹
              if (doc.folders) {
                doc.folders = doc.folders.map(folder => updateFile(folder));
              }
              return doc;
            },
            args: ["$$ROOT"],
            lang: "js"
          }
        }
      }
    },
    { $replaceWith: "$root" }
  ]
)

若MongoDB版本低于4.4，可在应用层执行以下步骤：

• 查询完整根文档
• 用递归函数遍历并修改目标对象
• 调用replaceOne保存修改后的文档

二、指定文件ID查询与末层级文件操作 #

1. 通过ID获取单个文件

复用上述“获取特定对象”的聚合逻辑，无论文件处于第几层级，均可准确定位。

2. 获取最末层级文件详情

最末层级文件指所在文件夹无下级子文件夹（folders为空数组）的文件，用递归函数筛选：

db.collection.aggregate([
  { $match: { _id: ObjectId("6368b3041bbaad24741c5e9e") } },
  {
    $addFields: {
      leafFiles: {
        $function: {
          body: function collectLeafFiles(doc) {
            let files = [];
            // 收集末层级文件夹的文件
            if (doc.folders?.length === 0) {
              files = [...files, ...doc.files];
            }
            // 递归遍历子文件夹
            for (const folder of doc.folders || []) {
              files = [...files, ...collectLeafFiles(folder)];
            }
            // 收集根层级文件（若根文件夹无下级）
            if (!doc.folders || doc.folders.length === 0) {
              files = [...files, ...doc.files];
            }
            return files;
          },
          args: ["$$ROOT"],
          lang: "js"
        }
      }
    }
  },
  { $project: { leafFiles: 1, _id: 0 } }
])

3. 更新最末层级文件详情

在递归函数中判断文件夹是否为末层级，批量更新对应文件：

db.collection.updateOne(
  { _id: ObjectId("6368b3041bbaad24741c5e9e") },
  [
    {
      $set: {
        root: {
          $function: {
            body: function updateLeafFiles(doc) {
              // 更新末层级文件夹下的所有文件
              if (doc.folders?.length === 0) {
                doc.files = doc.files.map(f => ({ ...f, status: "archived" }));
              }
              // 递归处理子文件夹
              if (doc.folders) {
                doc.folders = doc.folders.map(folder => updateLeafFiles(folder));
              }
              return doc;
            },
            args: ["$$ROOT"],
            lang: "js"
          }
        }
      }
    },
    { $replaceWith: "$root" }
  ]
)

优化建议 #

• 递归操作的性能受嵌套深度和数据量影响，深度过大时建议改用扁平化数据结构：将每个文件夹、文件作为独立文档，用parentId关联上下级，更适配MongoDB的查询特性。
• 聚合更新为原子操作，适合高并发场景；应用层修改需注意并发冲突问题。

内容的提问来源于stack exchange，提问作者Mahalakshmi Sundaram