MongoDB聚合管道中如何基于前序阶段结果实现高效自查找？

原始集合数据：

[
  {
    "_id": 1,
    "list": [{"a": 1}, {"a": 2}]
  },
  {
    "_id": 2,
    "list": [{"a": 3}, {"a": 4}]
  }
]

当前使用的聚合管道需要重复执行两次相同的预处理逻辑（过滤list中的子文档），导致效率低下：

[
  { // 第一次预处理：过滤list
    "$project": {
      "_id": true,
      "list": {
        "$filter": {
          "input": "$list",
          "as": "lst",
          "cond": {"$in": ["$$lst.a", [1, 2, 4]]}
        }
      }
    }
  },
  {"$unwind": "$list"},
  {
    "$lookup": {
      "from": "collection",
      "localField": "_id",
      "foreignField": "_id",
      "as": "results",
      "pipeline": [ // 第二次重复执行过滤逻辑
        {
          "$project": {
            "_id": true,
            "list": {
              "$filter": {
                "input": "$list",
                "as": "lst",
                "cond": {"$in": ["$$lst.a", [1, 2, 4]]}
              }
            }
          }
        },
        {"$unwind": "$list"}
      ]
    }
  },
  {"$unwind": "$results"},
  // 后续过滤、投影逻辑
]

需求：避免重复预处理，实现基于管道当前状态的自查找，最终完成同一_id下list子文档的笛卡尔积，用于子文档间的对比计算。

针对同一_id下子文档生成笛卡尔积的需求，完全不需要用$lookup自查找，直接在单文档内处理即可，仅需一次预处理：

[
  // 1. 仅执行一次过滤预处理，保留符合条件的子文档
  {
    "$addFields": {
      "filteredList": {
        "$filter": {
          "input": "$list",
          "as": "lst",
          "cond": {"$in": ["$$lst.a", [1, 2, 4]]}
        }
      }
    }
  },
  // 2. 展开第一个子文档列表
  {"$unwind": "$filteredList"},
  // 3. 复制过滤后的列表，用于生成笛卡尔积
  {
    "$addFields": {
      "pairList": "$filteredList"
    }
  },
  // 4. 展开复制后的列表，得到所有子文档的笛卡尔积
  {"$unwind": "$pairList"},
  // 5. 调整字段结构，匹配预期输出（可选）
  {
    "$project": {
      "_id": 1,
      "list": "$filteredList",
      "results": {
        "_id": "$_id",
        "list": "$pairList"
      }
    }
  },
  // 后续子文档对比计算逻辑可在此添加
]

方案优势 #

• 仅执行一次$filter预处理，避免重复计算开销
• 通过两次$unwind直接生成同一_id下子文档的笛卡尔积，比$lookup自查找效率提升显著
• 最终输出结构与预期结果完全一致

备选方案（若必须用$lookup） #

如果因特殊场景需要用$lookup，可先将预处理结果写入临时集合，再从临时集合查询：

// 第一步：生成预处理后的临时集合
[
  {
    "$project": {
      "_id": true,
      "list": {
        "$filter": {
          "input": "$list",
          "as": "lst",
          "cond": {"$in": ["$$lst.a", [1, 2, 4]]}
        }
      }
    }
  },
  {"$unwind": "$list"},
  {"$out": "temp_processed_collection"}
]

// 第二步：从临时集合做自查找
[
  {
    "$lookup": {
      "from": "temp_processed_collection",
      "localField": "_id",
      "foreignField": "_id",
      "as": "results"
    }
  },
  {"$unwind": "$results"},
  // 后续逻辑
]

但此方案需要额外的临时集合操作，效率不如第一种方法，仅推荐用于跨文档的自查找场景。

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