MongoDB能否实现条件式$lookup？或加速lookup终止？

当前Child集合通过parentId和parentType关联三个独立父集合，三次$lookup会执行大量无效查询（即使子文档不属于对应父类型），导致性能低下。以下是几个更优解决方案：

方案1：给$lookup添加parentType过滤条件，避免无效查询 #

针对现有三次$lookup结构，在每个lookup的pipeline中加入parentType匹配判断，仅当子文档的parentType对应当前父集合时，才执行_id匹配，否则直接返回空结果，大幅减少无意义的集合扫描。

修改后的lookup示例（以ParentType1为例）：

{
  "$lookup": {
    "from": "ParentType1",
    "as": "parentType1",
    "let": {
      "parentId": "$parentId",
      "parentType": "$parentType" // 传入子文档的parentType
    },
    "pipeline": [
      {
        "$match": {
          "$expr": {
            "$and": [
              { "$eq": ["$$parentType", "ParentType1"] }, // 先判断类型匹配
              { "$eq": ["$_id", "$$parentId"] }
            ]
          }
        }
      },
      { "$limit": 1 }
    ]
  }
}

优点：无需修改现有集合结构，快速落地；MongoDB会优化类型不匹配的情况，跳过实际集合扫描。
缺点：仍需三次lookup，但无效查询的开销大幅降低。

方案2：合并父集合为单一集合，单次$lookup关联 #

将三个父集合合并为一个Parents集合，每个文档新增type字段标记原集合类型（如"ParentType1"），仅需一次$lookup即可完成关联。

步骤1：数据迁移示例 #

// 迁移ParentType1到Parents集合
db.ParentType1.aggregate([
  { $addFields: { type: "ParentType1" } },
  { $out: "Parents" }
])
// 同理迁移ParentType2、ParentType3

步骤2：建立复合索引 #

在Parents集合上创建复合索引，加速查询：

db.Parents.createIndex({ _id: 1, type: 1 })

步骤3：单次$lookup关联 #

db.Child.aggregate([
  {
    "$lookup": {
      "from": "Parents",
      "as": "parent",
      "let": {
        "parentId": "$parentId",
        "parentType": "$parentType"
      },
      "pipeline": [
        {
          "$match": {
            "$expr": {
              "$and": [
                { "$eq": ["$_id", "$$parentId"] },
                { "$eq": ["$type", "$$parentType"] }
              ]
            }
          }
        },
        { "$limit": 1 }
      ]
    }
  },
  // 将数组转为单个父文档（可选）
  { $addFields: { parent: { $arrayElemAt: ["$parent", 0] } } }
])

优点：仅需一次lookup，复合索引大幅提升查询效率；后续维护更简单。
缺点：需要迁移遗留数据，若父集合数据量大，需分批执行迁移。

方案3：使用$unionWith预合并父集合，无需物理迁移 #

如果不想修改现有父集合结构，可通过$unionWith在聚合阶段临时合并三个父集合，再与Child关联，实现单次lookup的效果。

db.Child.aggregate([
  {
    "$lookup": {
      "from": {
        $unionWith: [
          { coll: "ParentType1", pipeline: [{ $addFields: { type: "ParentType1" } }] },
          { coll: "ParentType2", pipeline: [{ $addFields: { type: "ParentType2" } }] },
          { coll: "ParentType3", pipeline: [{ $addFields: { type: "ParentType3" } }] }
        ]
      },
      "as": "parent",
      "let": {
        "childParentId": "$parentId",
        "childParentType": "$parentType"
      },
      "pipeline": [
        {
          "$match": {
            "$expr": {
              "$and": [
                { "$eq": ["$_id", "$$childParentId"] },
                { "$eq": ["$type", "$$childParentType"] }
              ]
            }
          }
        },
        { "$limit": 1 }
      ]
    }
  },
  { $addFields: { parent: { $arrayElemAt: ["$parent", 0] } } }
])

优点：无需修改物理集合，保留原有数据结构。
缺点：每次聚合都会执行$unionWith合并操作，若父集合数据量大，性能不如物理合并方案。

方案4：应用层批量关联，减少数据库查询次数 #

在应用层先查询所有Child文档，按parentType分组收集parentId，再批量查询对应父集合，最后在内存中完成关联。

示例伪代码（以Node.js为例）：

// 1. 查询所有Child文档
const children = await db.Child.find().toArray();

// 2. 按parentType分组收集parentId
const parentGroups = {
  ParentType1: [],
  ParentType2: [],
  ParentType3: []
};
children.forEach(child => {
  if (parentGroups[child.parentType]) {
    parentGroups[child.parentType].push(child.parentId);
  }
});

// 3. 批量查询各父集合
const parentMaps = {};
for (const [type, ids] of Object.entries(parentGroups)) {
  if (ids.length === 0) continue;
  const parents = await db[type].find({ _id: { $in: ids } }).toArray();
  parentMaps[type] = new Map(parents.map(p => [p._id.toString(), p]));
}

// 4. 关联父文档到子文档
children.forEach(child => {
  const parentMap = parentMaps[child.parentType];
  child.parent = parentMap ? parentMap.get(child.parentId.toString()) : null;
});

优点：减少数据库聚合查询开销，批量查询效率更高；灵活控制关联逻辑。
缺点：需要应用层处理关联逻辑，若Child文档数量极大，需考虑分页查询避免内存溢出。

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