MongoDB多集合$lookup聚合查询无数据返回问题排查

我的数据库中有如下结构的文档：

{ listId: 2, itemType: 'book', itemId: 5364 },
{ listId: 2, itemType: 'car', itemId: 354 },
{ listId: 2, itemType: 'laptop', itemId: 228 }

需要根据itemType字段从对应的集合（books、cars、laptops）中获取每个条目的数据。我参考MongoDB文档及搜索结果，使用了带let和$expr的$lookup聚合查询，代码如下：

ListItemsModel.aggregate([
    { $match: { listId: 2 } },
    { $lookup:
       {
         from: 'books',
         localField: 'itemId',
         foreignField: '_id',
         let: { "itemType": "$itemType" },
         pipeline: [
            { $project: { _id: 1, title: 1 }},
            { $match: { $expr: { $eq: ["$$itemType", "book"] } }}
         ],
         as: 'data'
       }
     },
     { $lookup:
        {
          from: 'cars',
          localField: 'itemId',
          foreignField: '_id',
          let: { "itemType": "$itemType" },
          pipeline: [
             { $project: { _id: 1, title: 1 }},
             { $match: { $expr: { $eq: ["$$itemType", "car"] } }}
          ],
          as: 'data'
        }
      },
      { $lookup:
       {
         from: 'laptops',
         localField: 'itemId',
         foreignField: '_id',
         let: { "itemType": "$itemType" },
         pipeline: [
            { $project: { _id: 1, title: 1 }},
            { $match: { $expr: { $eq: ["$$itemType", "laptop"] } }}
         ],
         as: 'data'
       }
     }
    ]);

但查询结果中所有data字段均为空数组（data: []），语法看似正确，请问问题出在哪里？

你的查询存在两个核心问题：

1. 结果覆盖+关联逻辑缺失 #

连续三次$lookup都将结果写入data字段，后一次查询会直接覆盖前一次的结果。更关键的是，你没有在lookup的pipeline中关联主集合的itemId和目标集合的_id——仅判断itemType匹配，根本找不到对应ID的文档。另外，当$lookup同时指定localField/foreignField和pipeline时，localField/foreignField会被忽略，必须手动在pipeline里做ID关联。

2. 阶段顺序不合理 #

pipeline里先执行$project再执行$match虽然不影响变量使用，但逻辑上应该先过滤出匹配的文档，再做字段投影，效率更高。

修正后的查询代码 #

ListItemsModel.aggregate([
  { $match: { listId: 2 } },
  // 查询books集合，结果暂存到bookData
  { $lookup: {
      from: 'books',
      let: { targetId: "$itemId", type: "$itemType" },
      pipeline: [
        { $match: {
            $expr: {
              $and: [
                { $eq: ["$_id", "$$targetId"] },
                { $eq: ["$$type", "book"] }
              ]
            }
          }
        },
        { $project: { _id: 1, title: 1 } }
      ],
      as: 'bookData'
    }
  },
  // 查询cars集合，结果暂存到carData
  { $lookup: {
      from: 'cars',
      let: { targetId: "$itemId", type: "$itemType" },
      pipeline: [
        { $match: {
            $expr: {
              $and: [
                { $eq: ["$_id", "$$targetId"] },
                { $eq: ["$$type", "car"] }
              ]
            }
          }
        },
        { $project: { _id: 1, title: 1 } }
      ],
      as: 'carData'
    }
  },
  // 查询laptops集合，结果暂存到laptopData
  { $lookup: {
      from: 'laptops',
      let: { targetId: "$itemId", type: "$itemType" },
      pipeline: [
        { $match: {
            $expr: {
              $and: [
                { $eq: ["$_id", "$$targetId"] },
                { $eq: ["$$type", "laptop"] }
              ]
            }
          }
        },
        { $project: { _id: 1, title: 1 } }
      ],
      as: 'laptopData'
    }
  },
  // 合并非空结果到data字段
  { $addFields: {
      data: {
        $concatArrays: ["$bookData", "$carData", "$laptopData"]
      }
    }
  },
  // 清理临时字段
  { $project: { bookData: 0, carData: 0, laptopData: 0 } }
]);

核心优化点 #

• 每次$lookup使用独立的临时字段存储结果，避免覆盖
• 在pipeline的$match中同时校验ID和类型，确保只匹配对应文档
• 先过滤再投影，提升查询效率
• 最后合并临时字段结果为data，保持输出结构整洁

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