MongoDB任意深度递归更新实现方案咨询

方案一：使用更新管道 + $function（MongoDB 4.4+） #

MongoDB 4.4及以上支持在聚合管道中用$function定义自定义JS函数，可直接递归遍历任意深度的嵌套结构并修改目标字段，无需将数据导出到应用层处理：

db.collection.updateMany(
  {}, // 匹配所有文档，可按需添加过滤条件
  [
    {
      $set: {
        expressions: {
          $function: {
            body: function(expressions) {
              // 递归处理单个表达式对象
              const processExpr = (expr) => {
                // 将name为"a"的表达式重命名为"b"
                const newExpr = { ...expr, name: expr.name === "a" ? "b" : expr.name };
                // 处理参数数组中的嵌套表达式
                if (newExpr.arguments) {
                  newExpr.arguments = newExpr.arguments.map(arg => {
                    if (arg.expressions) {
                      return { ...arg, expressions: arg.expressions.map(processExpr) };
                    }
                    return arg;
                  });
                }
                return newExpr;
              };
              // 处理顶层expressions数组
              return expressions.map(processExpr);
            },
            args: ["$expressions"],
            lang: "js"
          }
        }
      }
    }
  ]
)

这个函数会递归遍历所有层级的expressions，自动处理arguments里嵌套的表达式结构，适配任意深度的需求。

方案二：纯聚合操作符递归（无自定义函数） #

如果限制使用JS函数，可通过原生聚合操作符实现递归，但这种方式仅适合已知最大嵌套深度的场景，无限深度会导致代码极度繁琐：

db.collection.updateMany(
  {},
  [
    {
      $set: {
        expressions: {
          $map: {
            input: "$expressions",
            as: "expr",
            in: {
              $mergeObjects: [
                "$$expr",
                { name: { $cond: [{ $eq: ["$$expr.name", "a"] }, "b", "$$expr.name"] } },
                {
                  arguments: {
                    $map: {
                      input: "$$expr.arguments",
                      as: "arg",
                      in: {
                        $mergeObjects: [
                          "$$arg",
                          {
                            expressions: {
                              $map: {
                                input: "$$arg.expressions",
                                as: "nestedExpr",
                                in: {
                                  $mergeObjects: [
                                    "$$nestedExpr",
                                    { name: { $cond: [{ $eq: ["$$nestedExpr.name", "a"] }, "b", "$$nestedExpr.name"] } },
                                    // 若有更深层级，需继续嵌套$map和$mergeObjects
                                    { arguments: "$$nestedExpr.arguments" }
                                  ]
                                }
                              }
                            }
                          }
                        ]
                      }
                    }
                  }
                }
              ]
            }
          }
        }
      }
    }
  ]
)

方案三：应用层处理（兼容旧版MongoDB） #

如果你的MongoDB版本低于4.4，无法使用$function，只能将数据导出到应用层（如Node.js、Python），递归修改后再写回数据库。示例（Node.js）：

const docs = await db.collection.find({}).toArray();
for (const doc of docs) {
  const processExpr = (expr) => {
    expr.name = expr.name === "a" ? "b" : expr.name;
    if (expr.arguments) {
      expr.arguments.forEach(arg => {
        if (arg.expressions) {
          arg.expressions.forEach(processExpr);
        }
      });
    }
    return expr;
  };
  doc.expressions.forEach(processExpr);
  await db.collection.updateOne({ _id: doc._id }, { $set: { expressions: doc.expressions } });
}

这种方式在数据量较大时会有性能损耗，不如数据库端处理高效。

总结 #

• MongoDB 4.4+优先选方案一，代码简洁且支持任意深度嵌套；
• 禁止使用JS函数且嵌套深度有限时，可选用方案二；
• 旧版本MongoDB只能用方案三，在应用层处理后回写。

内容的提问来源于stack exchange，提问作者János