如何在Mongoose的$facet聚合中使用populate()？或替代方案

首先要明确一点：Mongoose的populate()方法无法直接作用于聚合操作的输出结果——因为聚合返回的是普通JSON对象，而非Mongoose Document实例，所以得换个思路来实现你的需求。下面给你两种可行方案，优先推荐第一种（性能最优）：

方案一：在$facet内部结合$lookup（最优方案） #

直接在聚合管道的$facet阶段中，给vehicleMake和vehicleModel的分组管道添加$lookup关联查询，然后提取关联集合的name字段替换原_id。这样所有操作都在数据库端完成，避免额外的客户端-数据库交互，性能最佳。

修改后的完整聚合代码： #

Vehicle.model.aggregate([
  { $match: { year: 2015 } },
  { $facet: {
    vehicleMake: [
      { $group: { _id: '$vehicleMake', count: { $sum: 1 }}},
      { $sort: { count: -1, _id: -1 }},
      // 关联vehicleMakes集合（替换为你的实际集合名）
      {
        $lookup: {
          from: 'vehicleMakes', 
          localField: '_id',
          foreignField: '_id',
          as: 'makeInfo'
        }
      },
      // 展开关联结果数组（每个_id对应一条记录）
      { $unwind: '$makeInfo' },
      // 重新投影，用name替换原_id
      {
        $project: {
          _id: '$makeInfo.name',
          count: 1
        }
      }
    ],
    vehicleModel: [
      { $group: { _id: '$vehicleModel', count: { $sum: 1 }}},
      { $sort: { count: -1, _id: -1 }},
      // 关联vehicleModels集合（替换为你的实际集合名）
      {
        $lookup: {
          from: 'vehicleModels', 
          localField: '_id',
          foreignField: '_id',
          as: 'modelInfo'
        }
      },
      { $unwind: '$modelInfo' },
      {
        $project: {
          _id: '$modelInfo.name',
          count: 1
        }
      }
    ],
    year: [
      { $group: { _id: '$year', count: { $sum: 1 }}},
      { $sort: { _id: -1 }} // 移除原代码中重复的_id排序规则
    ],
    yearRange: [ 
      { $bucketAuto: { groupBy: '$year', buckets: 5 } }
    ],
  } }
])

执行后，vehicleMake和vehicleModel的结果就会直接显示对应的名称，比如：

"vehicleMake": [ { "_id": "Audi", "count": 1 }, { "_id": "BMW", "count": 1 } ]

方案二：聚合后手动查询关联数据（次优，适合小数据量场景） #

如果因为某些原因无法修改聚合管道，可以先执行原聚合得到结果，再手动查询关联集合，将ObjectId映射为名称。这种方案需要多次查询数据库，仅适合数据量较小的场景。

示例代码（使用async/await）： #

// 1. 执行原聚合操作
const aggregationResult = await Vehicle.model.aggregate([
  { $match: { year: 2015 } },
  { $facet: {
    vehicleMake: [{ $group: { _id: '$vehicleMake', count: { $sum: 1 }}}, { $sort: { count: -1, _id: -1 }}],
    vehicleModel: [{ $group: { _id: '$vehicleModel', count: { $sum: 1 }}}, { $sort: { count: -1, _id: -1 }}],
    year: [{ $group: { _id: '$year', count: { $sum: 1 }}}, { $sort: { _id: -1 }}],
    yearRange: [ { $bucketAuto: { groupBy: '$year', buckets: 5 } }],
  } }
]);

// 2. 处理vehicleMake的ID到名称的映射
const makeIds = aggregationResult[0].vehicleMake.map(item => item._id);
const makes = await VehicleMake.model.find({ _id: { $in: makeIds } });
const makeMap = new Map(makes.map(make => [make._id.toString(), make.name]));

aggregationResult[0].vehicleMake = aggregationResult[0].vehicleMake.map(item => ({
  _id: makeMap.get(item._id.toString()),
  count: item.count
}));

// 3. 处理vehicleModel的ID到名称的映射
const modelIds = aggregationResult[0].vehicleModel.map(item => item._id);
const models = await VehicleModel.model.find({ _id: { $in: modelIds } });
const modelMap = new Map(models.map(model => [model._id.toString(), model.name]));

aggregationResult[0].vehicleModel = aggregationResult[0].vehicleModel.map(item => ({
  _id: modelMap.get(item._id.toString()),
  count: item.count
}));

console.log(aggregationResult);

总结 #

• 优先选择方案一：所有逻辑在数据库端完成，性能最优，是处理这类需求的标准做法。
• 方案二仅作为临时替代：适合数据量小、无法修改聚合管道的场景，但会增加数据库查询次数，性能不如方案一。

内容的提问来源于stack exchange，提问作者Klaudiusz Marszałek