MongoDB深度嵌套数组元素高效计数：规避$unwind的优化方案

我正在为超大规模集合（1亿文档/1TB，MongoDB 4.4）编写高效聚合查询，目标是统计深度嵌套数组元素的数量。目前使用$unwind操作会导致任务执行极慢，想知道是否可以用$reduce/$filter或其他更高效的方案替代。

示例文档 #

{
  "_id": ObjectId("5c05984246a0201286d4b57a"),
  "f": "x",
  "_a": [
    { "_onlineStore": {} },
    {
      "_p": [
        {
          "pid": 1,
          "s": {
            "a": {
              "t": [
                { "id": 1, "dateP": "2020-09-20", "lang": "EN" },
                { "id": 2, "dateP": "2020-09-20", "lang": "En" }
              ]
            },
            "c": {
              "t": [
                { "id": 3, "lang": "en" },
                { "id": 4, "lang": "En" },
                { "id": 5, "dateP": "2030-09-23" }
              ]
            }
          },
          "h": "Some data"
        }
      ]
    }
  ]
}

需求说明 #

需要统计路径"_a[]._p[].s.c.t[]"中，lang字段属于["En","en","EN","eN"]的数组元素数量。
注意： "_a._p.s.a.t"或"_a._p.s.d.t"路径下的元素不计入统计。

预期结果 #

预期结果1（统计计数） #

{ "count": 2 }

预期结果2（匹配的元素列表） #

[
  { "id": 3, "lang": "en" },
  { "id": 4, "lang": "En" }
]

原实现问题 #

我之前用$unwind实现了需求，但对于大型集合性能开销极高。

高效替代方案 #

方案1：统计匹配元素总数 #

通过嵌套的$reduce遍历多层数组，结合$filter筛选目标元素并统计数量，完全避免$unwind的性能损耗：

db.collection.aggregate([
  {
    $project: {
      count: {
        $reduce: {
          input: "$_a",
          initialValue: 0,
          in: {
            $add: [
              "$$value",
              {
                $reduce: {
                  input: "$$this._p",
                  initialValue: 0,
                  in: {
                    $add: [
                      "$$value",
                      {
                        $size: {
                          $filter: {
                            input: "$$this.s.c.t",
                            cond: { $in: ["$$this.lang", ["En", "en", "EN", "eN"]] }
                          }
                        }
                      }
                    ]
                  }
                }
              }
            ]
          }
        }
      }
    }
  },
  {
    $group: {
      _id: null,
      totalCount: { $sum: "$count" }
    }
  },
  {
    $project: {
      _id: 0,
      count: "$totalCount"
    }
  }
])

方案2：获取所有匹配元素列表 #

如果需要提取具体匹配的元素而非仅计数，可调整管道如下：

db.collection.aggregate([
  {
    $project: {
      matchedElements: {
        $reduce: {
          input: "$_a",
          initialValue: [],
          in: {
            $concatArrays: [
              "$$value",
              {
                $reduce: {
                  input: "$$this._p",
                  initialValue: [],
                  in: {
                    $concatArrays: [
                      "$$value",
                      {
                        $filter: {
                          input: "$$this.s.c.t",
                          cond: { $in: ["$$this.lang", ["En", "en", "EN", "eN"]] }
                        }
                      }
                    ]
                  }
                }
              }
            ]
          }
        }
      }
    }
  },
  {
    $group: {
      _id: null,
      allMatched: { $concatArrays: ["$matchedElements"] }
    }
  },
  {
    $project: {
      _id: 0,
      matchedElements: "$allMatched"
    }
  }
])

性能优化说明 #

• 避免$unwind：$unwind会将数组元素拆分为独立文档，超大规模集合中会生成巨量中间数据，导致内存和IO开销暴增；而$reduce+$filter在单文档内完成嵌套遍历，中间数据量极小。
• 字段投影：仅保留需要处理的嵌套字段，减少数据传输和处理体积。
• 索引优化：如果需要先筛选特定文档（比如按f字段过滤），可创建复合索引或嵌套字段索引进一步提升性能。

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