如何用单条更新查询清理MongoDB深度嵌套数组的无效对象

需求说明 #

批量更新集合中所有文档，移除深度嵌套数组（_a._p.s.a.t、_a._p.s.c.t、_a._p.s.d.t，这些字段为非必填，部分文档可能缺失）中缺少did、dst、den任意一个的对象，且不能在结果中生成原本不存在的null字段。

解决方案 #

使用MongoDB 4.2+支持的聚合管道式更新，通过updateMany结合聚合操作完成，核心是对嵌套数组做条件过滤，同时严格保留原字段结构：

db.yourCollection.updateMany(
  {},
  [
    {
      $set: {
        "_a": {
          $map: {
            input: "$_a",
            as: "aItem",
            in: {
              $cond: [
                "$$aItem._p", // 判断当前_a元素是否包含_p字段
                {
                  "_p": {
                    "s": {
                      $mergeObjects: [
                        // 保留s中原有的其他字段（如果有）
                        "$$aItem._p.s",
                        // 处理a.t数组（仅当a存在时）
                        {
                          $cond: [
                            "$$aItem._p.s.a",
                            {
                              "a": {
                                "t": {
                                  $filter: {
                                    input: "$$aItem._p.s.a.t",
                                    as: "tItem",
                                    cond: {
                                      $and: [
                                        { $exists: ["$$tItem.did", true] },
                                        { $exists: ["$$tItem.dst", true] },
                                        { $exists: ["$$tItem.den", true] }
                                      ]
                                    }
                                  }
                                }
                              }
                            },
                            {} // a不存在则不添加该字段
                          ]
                        },
                        // 处理c.t数组（仅当c存在时）
                        {
                          $cond: [
                            "$$aItem._p.s.c",
                            {
                              "c": {
                                "t": {
                                  $filter: {
                                    input: "$$aItem._p.s.c.t",
                                    as: "tItem",
                                    cond: {
                                      $and: [
                                        { $exists: ["$$tItem.did", true] },
                                        { $exists: ["$$tItem.dst", true] },
                                        { $exists: ["$$tItem.den", true] }
                                      ]
                                    }
                                  }
                                }
                              }
                            },
                            {} // c不存在则不添加该字段
                          ]
                        },
                        // 处理d.t数组（仅当d存在时）
                        {
                          $cond: [
                            "$$aItem._p.s.d",
                            {
                              "d": {
                                "t": {
                                  $filter: {
                                    input: "$$aItem._p.s.d.t",
                                    as: "tItem",
                                    cond: {
                                      $and: [
                                        { $exists: ["$$tItem.did", true] },
                                        { $exists: ["$$tItem.dst", true] },
                                        { $exists: ["$$tItem.den", true] }
                                      ]
                                    }
                                  }
                                }
                              }
                            },
                            {} // d不存在则不添加该字段
                          ]
                        }
                      ]
                    }
                  }
                },
                "$$aItem" // 没有_p字段的元素直接保留原样
              ]
            }
          }
        }
      }
    }
  ]
)

方案说明 #

1. $map遍历_a数组：对每个元素判断是否包含_p字段，区分处理逻辑；
2. $mergeObjects保留原有字段：确保s对象中原有的其他字段不会被覆盖；
3. 条件判断处理子对象：对a、c、d每个子对象都做存在性检查，仅当该子对象存在时才处理其t数组，彻底避免生成null字段；
4. $filter过滤无效对象：仅保留t数组中同时存在did、dst、den三个字段的元素。

效果验证 #

执行上述命令后，文档会按照预期保留有效对象，且不会生成原本不存在的null字段（例如原文档没有d字段，更新后依然不会出现d: null）。

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