MongoDB: 索引基础与原理

// === 创建单字段索引 ===
db.products.createIndex({ sku: 1 });          // 升序
db.products.createIndex({ createdAt: -1 });   // 降序

// === 创建复合索引 ===
db.products.createIndex({ category: 1, price: -1 });

// === 创建唯一索引 ===
db.products.createIndex({ sku: 1 }, { unique: true });

// === 后台创建（不阻塞）===
db.products.createIndex({ tags: 1 }, { background: true });

// === 自定义索引名称 ===
db.products.createIndex({ title: 1 }, { name: 'idx_title' });

// ShopHub 电商：为商品集合创建关键索引，监控构建进度
db.products.createIndex({ category: 1, price: -1, rating: -1 }, { name: 'idx_category_price_rating', background: true });

// 查看索引构建进度
db.currentOp({
  $or: [
    { op: 'command', 'command.createIndexes': { $exists: true } },
    { op: 'none', ns: /shopdb\.products/ }
  ]
});

// 查看所有索引
db.products.getIndexes();
// [
//   { v: 2, key: { _id: 1 }, name: '_id_' },
//   { v: 2, key: { category: 1, price: -1, rating: -1 }, name: 'idx_category_price_rating' }
// ]

// 执行成功

// === 查看查询执行计划 ===
db.products.find({ category: 'Electronics' }).explain('executionStats');

// === 关键指标 ===
{
  queryPlanner: {
    winningPlan: {
      stage: 'IXSCAN',           // 索引扫描（✅）
      // stage: 'COLLSCAN',      // 全集合扫描（❌）
      inputStage: {
        stage: 'IXSCAN',
        indexName: 'category_1'
      }
    }
  },
  executionStats: {
    totalDocsExamined: 250,      // 扫描文档数
    totalKeysExamined: 250,      // 扫描索引键数
    nReturned: 250,              // 返回文档数
    executionTimeMillis: 5,      // 执行时间（毫秒）
    totalQueryPlanExecutionTime: 7
  }
}

// TechCorp 系统发现订单查询变慢，用 explain 诊断
// 索引前：COLLSCAN
db.orders.find({ status: 'paid', total: { $gte: 100 } }).explain('executionStats');
// stage: 'COLLSCAN', totalDocsExamined: 100000, executionTimeMillis: 450

// 创建复合索引
db.orders.createIndex({ status: 1, total: -1 });

// 索引后：IXSCAN
db.orders.find({ status: 'paid', total: { $gte: 100 } }).explain('executionStats');
// stage: 'IXSCAN', indexName: 'status_1_total_-1'
// totalDocsExamined: 5000, nReturned: 5000, executionTimeMillis: 8

// 效率评估：examined/returned = 1.0（理想值），性能提升 56 倍

// mongoose 操作成功执行
// 数据库查询/更新结果

// === 复合索引：{ category: 1, price: -1, rating: 1 } ===
db.products.createIndex({ category: 1, price: -1, rating: 1 });

// ✅ 使用索引的查询：
db.products.find({ category: 'Electronics' });                                    // 用 category
db.products.find({ category: 'Electronics', price: { $gte: 100 } });            // 用 category + price
db.products.find({ category: 'Electronics', price: { $gte: 100 }, rating: 5 }); // 用全部 3 字段

// ⚠️ 不使用索引的查询：
db.products.find({ price: { $gte: 100 } });                                      // 跳过 category
db.products.find({ rating: 5 });                                                 // 跳过 category, price
db.products.find({ category: 'Electronics', rating: 5 });                       // 跳过 price

// === 普通查询：需回表查文档 ===
db.products.find(
  { category: 'Electronics' },
  { sku: 1, title: 1, price: 1 }
);

// === 索引覆盖查询：直接从索引返回 ===
db.products.createIndex({ category: 1, sku: 1, title: 1, price: 1 });

db.products.find(
  { category: 'Electronics' },
  { sku: 1, title: 1, price: 1, _id: 0 }  // _id: 0 必须排除
);
// explain 中显示 stage: 'PROJECTION_COVERED' ✅

// === 查看集合所有索引 ===
db.products.getIndexes();

// === 删除索引 ===
db.products.dropIndex('sku_1');
db.products.dropIndex({ sku: 1 });

// === 删除所有索引（保留 _id）===
db.products.dropIndexes();

// === 重建索引 ===
db.products.reIndex();

// === 查看索引大小 ===
db.products.totalIndexSize();

// === 电商商品索引设计 ===
db.products.createIndex({ sku: 1 }, { unique: true });                    // 唯一索引
db.products.createIndex({ category: 1, price: -1 });                       // 分类页
db.products.createIndex({ category: 1, rating: -1 });                      // 分类+评分
db.products.createIndex({ isActive: 1, createdAt: -1 });                   // 上架时间
db.products.createIndex({ title: 'text', description: 'text' });          // 全文搜索
db.products.createIndex({ tags: 1 });                                      // 标签筛选

// === 分析慢查询 ===
db.products.find({
  category: 'Electronics',
  price: { $gte: 100, $lte: 1000 },
  isActive: true
}).sort({ createdAt: -1 }).limit(20);

// 查看是否使用索引
const explain = db.products.find({...}).explain('executionStats');
print('Stage:', explain.queryPlanner.winningPlan.stage);
print('Docs Examined:', explain.executionStats.totalDocsExamined);
print('Time:', explain.executionStats.executionTimeMillis, 'ms');

// 1. 创建测试集合（10 万条商品数据）
for (let i = 0; i < 100000; i++) {
  db.products.insertOne({
    sku: 'SKU-' + i.toString().padStart(6, '0'),
    title: 'Product ' + i,
    category: ['Electronics', 'Books', 'Clothing', 'Home'][i % 4],
    price: Math.random() * 1000,
    stock: Math.floor(Math.random() * 100),
    createdAt: new Date(Date.now() - Math.random() * 30 * 24 * 60 * 60 * 1000),
    isActive: true
  });
}

// 2. 创建索引
db.products.createIndex({ sku: 1 }, { unique: true });
db.products.createIndex({ category: 1, price: -1 });  // 复合索引
db.products.createIndex({ createdAt: -1 });

// 3. 对比：有索引 vs 无索引
console.time('无索引查询');
db.products.find({ category: 'Electronics', price: { $gte: 100, $lte: 500 } }).toArray();
console.timeEnd('无索引查询');  // ~500ms

// 创建索引后
db.products.createIndex({ category: 1, price: 1 });

console.time('有索引查询');
db.products.find({ category: 'Electronics', price: { $gte: 100, $lte: 500 } }).toArray();
console.timeEnd('有索引查询');  // ~5ms（性能 ↑100x）

// 4. explain() 分析执行计划
const explain = db.products.find({
  category: 'Electronics',
  price: { $gte: 100, $lte: 500 }
}).sort({ createdAt: -1 }).limit(20).explain('executionStats');

print('Stage:', explain.queryPlanner.winningPlan.stage);  // IXSCAN
print('Index:', explain.queryPlanner.winningPlan.inputStage?.indexName);  // category_1_price_1
print('Docs Examined:', explain.executionStats.totalDocsExamined);
print('Keys Examined:', explain.executionStats.totalKeysExamined);
print('Returned:', explain.executionStats.nReturned);
print('Time:', explain.executionStats.executionTimeMillis, 'ms');

// 5. 索引覆盖查询（无需回表）
db.products.createIndex({ category: 1, sku: 1, price: 1 });

db.products.find(
  { category: 'Electronics' },
  { sku: 1, price: 1, _id: 0 }  // 仅返回索引中已有的字段
).explain();

// Stage: PROJECTION_COVERED（无需查文档）