复杂查询的性能优化

理解复杂查询的性能瓶颈

Mongoose在处理复杂查询时容易出现性能问题，特别是在数据量大的情况下。典型的性能瓶颈包括：过多的数据库往返、不合理的索引使用、内存中的大量数据处理以及N+1查询问题。例如，一个常见的场景是需要从用户集合中查找所有活跃用户，然后获取每个用户的订单信息：

const users = await User.find({ active: true });
const usersWithOrders = await Promise.all(
  users.map(async user => {
    const orders = await Order.find({ userId: user._id });
    return { ...user.toObject(), orders };
  })
);

这种写法会导致N+1查询问题，对数据库造成巨大压力。

查询优化基础策略

最基本的优化方法是合理使用投影(projection)只获取必要字段。Mongoose的select方法可以精确控制返回字段：

// 只获取name和email字段
const users = await User.find({ active: true }).select('name email');

另一个重要策略是使用lean()查询，跳过Mongoose文档实例化过程，直接返回纯JavaScript对象：

const users = await User.find({ active: true }).lean();

对于分页场景，应该使用cursor-based分页而非offset-based分页：

// 使用cursor分页
const users = await User.find({ _id: { $gt: lastId } })
  .limit(10)
  .sort({ _id: 1 });

高级查询优化技术

聚合管道优化

Mongoose的aggregate()方法提供了强大的数据处理能力，但需要特别注意性能：

const result = await Order.aggregate([
  { $match: { status: 'completed' } },
  { $group: { 
    _id: '$userId', 
    total: { $sum: '$amount' } 
  }},
  { $sort: { total: -1 } },
  { $limit: 10 }
]);

关键优化点包括：

1. 尽早使用$match减少处理文档数
2. 合理使用$project减少字段
3. 在内存密集型阶段前使用$limit

批量操作与批量获取

使用populate时，Mongoose默认会为每个引用文档执行单独查询。可以通过设置options优化：

const users = await User.find()
  .populate({
    path: 'orders',
    options: { batchSize: 100 }  // 控制批量大小
  });

对于复杂关联，可以考虑手动实现批量获取：

const users = await User.find().lean();
const userIds = users.map(u => u._id);
const orders = await Order.find({ userId: { $in: userIds } });

const usersWithOrders = users.map(user => {
  const userOrders = orders.filter(o => o.userId.equals(user._id));
  return { ...user, orders: userOrders };
});

索引策略与查询分析

正确的索引设计对查询性能至关重要。使用explain()分析查询执行计划：

const explanation = await User.find({ email: /@example\.com$/ })
  .explain('executionStats');

常见索引策略包括：

1. 为高频查询字段创建索引
2. 使用复合索引时注意字段顺序
3. 对文本搜索使用全文索引

// 创建复合索引
User.schema.index({ active: 1, createdAt: -1 });

// 文本索引
User.schema.index({ name: 'text', bio: 'text' });

缓存与读写分离

对于频繁访问但更新不频繁的数据，可以考虑添加缓存层：

async function getTopUsers() {
  const cacheKey = 'top:users';
  const cached = await redis.get(cacheKey);
  if (cached) return JSON.parse(cached);
  
  const users = await User.find().sort({ score: -1 }).limit(10);
  await redis.setex(cacheKey, 3600, JSON.stringify(users));
  return users;
}

对于读多写少的场景，可以考虑读写分离：

// 使用secondary节点处理读请求
const users = await User.find().read('secondary');

复杂条件查询的优化

处理多条件查询时，需要注意条件的顺序和组合方式：

// 不推荐的写法 - 条件顺序不合理
const users = await User.find({
  $or: [
    { status: 'vip', lastLogin: { $gt: weekAgo } },
    { points: { $gt: 1000 } }
  ]
});

// 优化后的写法 - 将选择性高的条件前置
const users = await User.find({
  $or: [
    { lastLogin: { $gt: weekAgo }, status: 'vip' },
    { points: { $gt: 1000 } }
  ]
});

对于地理空间查询，确保有相应的地理索引：

// 创建2dsphere索引
User.schema.index({ location: '2dsphere' });

// 使用地理查询
const nearbyUsers = await User.find({
  location: {
    $near: {
      $geometry: { type: 'Point', coordinates: [longitude, latitude] },
      $maxDistance: 1000
    }
  }
});

事务与批量写入优化

Mongoose支持事务操作，但需要注意性能影响：

const session = await mongoose.startSession();
try {
  session.startTransaction();
  
  await User.updateOne(
    { _id: userId },
    { $inc: { balance: -amount } },
    { session }
  );
  
  await Order.create(
    [{ userId, amount, product }],
    { session }
  );
  
  await session.commitTransaction();
} catch (error) {
  await session.abortTransaction();
  throw error;
} finally {
  session.endSession();
}

批量写入操作应优先使用bulkWrite：

await User.bulkWrite([
  { updateOne: {
    filter: { _id: user1Id },
    update: { $inc: { score: 10 } }
  }},
  { updateOne: {
    filter: { _id: user2Id },
    update: { $inc: { score: 5 } }
  }},
  { insertOne: {
    document: { name: 'New User', email: 'new@example.com' }
  }}
]);

监控与持续优化

建立查询性能监控机制非常重要。可以使用Mongoose的调试功能和慢查询日志：

// 启用Mongoose查询日志
mongoose.set('debug', function(collectionName, method, query, doc) {
  logger.debug(`${collectionName}.${method}`, JSON.stringify(query));
});

// 设置慢查询阈值(毫秒)
mongoose.set('slowQueryThreshold', 200);

定期分析查询模式并调整索引：

// 获取集合索引信息
const indexes = await User.collection.getIndexes();

// 删除不再需要的索引
await User.collection.dropIndex('old_index_name');