如何递归更新MongoDB文档中指定字段的值？

需求 #

递归替换MongoDB文档中所有字段名为itemKey且值等于指定旧值的内容，支持任意层级的嵌套结构（包括嵌套数组）。

示例文档 #

{
  "topLevel": {
    "level1": [
      {
        "itemKey": "N-99999",
        "level2": [
          {
            "itemKey": "N-99999",
            "level3": [
              {
                "itemKey": "N-99999"
              },
              {
                "itemKey": "a-4157-637"
              },
              {
                "itemKey": "t-3213-569"
              },
              {
                "itemKey": "s-3984-763"
              },
              {
                "itemKey": "n-5996-963"
              }
            ]
          }
        ]
      }
    ]
  }
}

现有问题代码（仅支持固定3层嵌套） #

func replaceItemKey(ctx context.Context, coll *mongo.Collection, old, new string) (*mongo.UpdateResult, error) {
    filter := bson.D{
        {Key: "toplevel.level1.itemKey", Value: old},
        {Key: "toplevel.level1.level2.itemKey", Value: old},
        {Key: "toplevel.level1.level2.level3.itemKey", Value: old},
    }
 
    update := bson.D{
        {Key: "$set", Value: bson.D{{Key: "toplevel.$[l1].level1.itemKey", Value: new}}},
        {Key: "$set", Value: bson.D{{Key: "toplevel.level1.$[].level2.$[l2].itemKey", Value: new}}},
        {Key: "$set", Value: bson.D{{Key: "toplevel.level1.$[].level2.$[].level3.$[l3].itemKey", Value: new}}},
    }
    
    opts := options.Update().SetArrayFilters(
        options.ArrayFilters{
            Filters: []interface{}{
                bson.D{{Key: "l1.itemKey", Value: bson.D{{Key: "$eq", Value: old}}}},
                bson.D{{Key: "l2.itemKey", Value: bson.D{{Key: "$eq", Value: old}}}},
                bson.D{{Key: "l3.itemKey", Value: bson.D{{Key: "$eq", Value: old}}}},
            },
        },
    )
    
    return coll.UpdateMany(ctx, filter, update, opts)
}

上述代码仅能处理固定3层嵌套的itemKey字段，无法应对任意深度的递归场景，且分层更新在处理数千条文档时会带来性能损耗。

单语句递归更新方案（MongoDB 4.4+） #

利用MongoDB的聚合管道更新功能，结合$function自定义递归函数，实现全文档范围内的itemKey值替换，单语句完成所有层级的更新操作。

Go语言代码实现 #

func replaceItemKeyRecursive(ctx context.Context, coll *mongo.Collection, oldVal, newVal string) (*mongo.UpdateResult, error) {
    // 定义递归替换的JavaScript函数
    recursiveReplaceFunc := `
        function traverseAndReplace(obj, targetKey, oldVal, newVal) {
            // 处理数组：递归遍历每个元素
            if (Array.isArray(obj)) {
                return obj.map(item => traverseAndReplace(item, targetKey, oldVal, newVal));
            }
            // 处理对象：遍历每个键值对
            if (obj && typeof obj === 'object') {
                const updatedObj = {...obj};
                for (const key in updatedObj) {
                    if (key === targetKey && updatedObj[key] === oldVal) {
                        updatedObj[key] = newVal;
                    } else {
                        updatedObj[key] = traverseAndReplace(updatedObj[key], targetKey, oldVal, newVal);
                    }
                }
                return updatedObj;
            }
            // 非对象/数组类型直接返回原值
            return obj;
        }
    `

    // 构建更新管道：递归替换后覆盖整个文档
    updatePipeline := bson.A{
        bson.D{
            {Key: "$set", Value: bson.D{
                {Key: "$$ROOT", Value: bson.D{
                    {Key: "$function", Value: bson.D{
                        {Key: "body", Value: recursiveReplaceFunc},
                        {Key: "args", Value: bson.A{"$$ROOT", "itemKey", oldVal, newVal}},
                        {Key: "lang", Value: "js"},
                    }},
                }},
            }},
        },
    }

    // 过滤条件：仅更新存在需要替换内容的文档
    filter := bson.D{
        {Key: "$expr", Value: bson.D{
            {Key: "$ne", Value: bson.A{
                bson.D{{Key: "$function", Value: bson.D{
                    {Key: "body", Value: recursiveReplaceFunc},
                    {Key: "args", Value: bson.A{"$$ROOT", "itemKey", oldVal, newVal}},
                    {Key: "lang", Value: "js"},
                }}},
                "$$ROOT",
            }},
        }},
    }

    opts := options.Update().SetBypassDocumentValidation(true)
    return coll.UpdateMany(ctx, filter, updatePipeline, opts)
}

方案说明 #

• 递归逻辑：通过$function定义的JavaScript函数，遍历文档所有层级的数组和对象，精准替换符合条件的itemKey值
• 性能优化：单语句完成全文档更新，避免多次分层查询/更新的开销，适合处理数千条文档的场景
• 精准过滤：仅对实际存在需要替换内容的文档执行更新，减少无意义操作

注意事项 #

1. 需使用MongoDB 4.4及以上版本（支持$function特性）
2. 确保MongoDB允许执行JavaScript代码（默认开启）
3. 对于超大规模文档，建议先做小范围性能测试，必要时添加索引加速过滤条件匹配

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