MongoDB: 索引类型与高级特性

// === 创建唯一索引 ===
db.users.createIndex({ email: 1 }, { unique: true });
// email 字段值必须唯一

// === 复合唯一索引 ===
db.products.createIndex({ sku: 1, variant: 1 }, { unique: true });
// (sku, variant) 组合必须唯一

// === 唯一索引 + 部分字段 ===
db.users.createIndex(
  { email: 1 },
  { unique: true, partialFilterExpression: { email: { $exists: true } } }
);
// 只对存在 email 字段的文档应用唯一约束

// === 稀疏索引：跳过 null 字段 ===
db.products.createIndex({ discount: 1 }, { sparse: true });
// 仅索引有 discount 字段的文档

// === 稀疏索引 vs 普通索引 ===
// 普通索引：所有文档都建索引（包括 null）
// 稀疏索引：仅非 null 文档建索引

// === 创建 TTL 索引（30 天后自动删除）===
db.sessions.createIndex(
  { createdAt: 1 },
  { expireAfterSeconds: 30 * 24 * 60 * 60 }
);

// === 修改 TTL ===
db.runCommand({
  collMod: 'sessions',
  index: { keyPattern: { createdAt: 1 }, expireAfterSeconds: 7 * 24 * 60 * 60 }
});

// === 取消 TTL（设为 false）===
db.runCommand({
  collMod: 'sessions',
  index: { keyPattern: { createdAt: 1 }, expireAfterSeconds: -1 }
});

// === 部分索引：仅索引满足条件的文档 ===
db.products.createIndex(
  { category: 1, price: 1 },
  {
    partialFilterExpression: {
      isActive: true,
      stock: { $gt: 0 }
    }
  }
);
// 仅索引在售商品（isActive=true, stock>0）

// === 部分索引节省空间 ===
// 普通索引：1 万文档全部建索引
// 部分索引：仅 3000 个在售商品建索引（节省 70% 空间）

// ShopHub：仅索引在售且有库存的商品，节省 70% 索引空间
db.products.insertMany([
  { sku: 'A001', category: 'Electronics', price: 599, isActive: true, stock: 50 },
  { sku: 'A002', category: 'Electronics', price: 299, isActive: false, stock: 0 },
  { sku: 'A003', category: 'Books', price: 29, isActive: true, stock: 100 },
  { sku: 'A004', category: 'Books', price: 49, isActive: true, stock: 0 }
]);

// Partial 索引仅索引 isActive=true AND stock>0 的文档（A001, A003）
db.products.createIndex(
  { category: 1, price: 1 },
  { partialFilterExpression: { isActive: true, stock: { $gt: 0 } } }
);

// 查询必须包含 filter 条件才能命中
db.products.find({
  category: 'Electronics',
  isActive: true,
  stock: { $gt: 0 },
  price: { $gte: 100 }
}).explain();
// winningPlan.stage: IXSCAN ✅

// 缺少 filter 条件 → 不命中
db.products.find({ category: 'Electronics', price: { $gte: 100 } }).explain();
// winningPlan.stage: COLLSCAN（不使用 partial 索引）

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

// === 查询：等值过滤 + 排序 + 范围 ===
db.products.find({
  category: 'Electronics',          // Equality
  isActive: true                    // Equality
}).sort({ createdAt: -1 })          // Sort
  .limit(20);

// 价格范围
db.products.find({
  category: 'Electronics',
  createdAt: { $gte: new Date('2026-01-01') }  // Range
}).sort({ rating: -1 });

// === 最佳索引 ===
db.products.createIndex({
  category: 1,         // E - 等值
  isActive: 1,         // E - 等值
  createdAt: -1,       // S - 排序（索引方向匹配）
  rating: -1           // R - 范围（放最后）
});

// TechCorp 订单系统：对比 ESR 正确 vs 错误排列的执行计划
db.orders.insertMany([
  { userId: 'user_001', status: 'paid', createdAt: new Date('2026-07-01'), total: 100 },
  { userId: 'user_002', status: 'pending', createdAt: new Date('2026-07-02'), total: 200 },
  { userId: 'user_001', status: 'paid', createdAt: new Date('2026-07-03'), total: 50 }
]);

// ❌ 错误索引：Range 在 Sort 前
db.orders.createIndex({ userId: 1, total: 1, status: 1, createdAt: -1 }, { name: 'idx_wrong' });
db.orders.find({ userId: 'user_001', status: 'paid' })
  .sort({ createdAt: -1 }).explain('executionStats');
// 出现 SORT stage（内存排序），totalKeysExamined 远大于 nReturned

// ✅ 正确索引：ESR 顺序
db.orders.dropIndex('idx_wrong');
db.orders.createIndex({ userId: 1, status: 1, createdAt: -1, total: 1 }, { name: 'idx_esr' });
db.orders.find({ userId: 'user_001', status: 'paid' })
  .sort({ createdAt: -1 }).explain('executionStats');
// 无 SORT stage，totalKeysExamined ≈ nReturned

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

// ✅ 推荐 1：单字段索引覆盖高频查询
db.products.createIndex({ sku: 1 });

// ✅ 推荐 2：复合索引遵循 ESR 原则
db.orders.createIndex({ userId: 1, status: 1, createdAt: -1 });

// ✅ 推荐 3：TTL 自动清理
db.logs.createIndex({ createdAt: 1 }, { expireAfterSeconds: 30 * 86400 });

// ✅ 推荐 4：部分索引节省空间
db.products.createIndex(
  { category: 1 },
  { partialFilterExpression: { isActive: true } }
);

// ✅ 推荐 5：唯一索引保证数据完整性
db.users.createIndex({ email: 1 }, { unique: true });

// ❌ 反模式 1：低选择性字段建索引
db.users.createIndex({ isActive: 1 });
// isActive 只有 true/false 两个值，索引效率低

// ❌ 反模式 2：过多索引
// 一个集合超过 20 个索引，写性能严重下降

// ❌ 反模式 3：复合索引字段顺序错误
db.products.createIndex({ price: 1, category: 1 });
// 错：price 应放 category 之后

// ❌ 反模式 4：不必要的索引
db.users.createIndex({ lastLoginAt: 1 });
// 如果很少按 lastLoginAt 查询，索引浪费

// === 慢查询分析 ===
db.setProfilingLevel(2, { slowms: 100 });
// 记录超过 100ms 的查询

// === 查看慢查询 ===
db.system.profile.find({ millis: { $gt: 100 } })
  .sort({ ts: -1 })
  .limit(10);

// === 查看索引使用统计 ===
db.products.aggregate([
  { $indexStats: {} }
]);
// 找出 unused index

// === 删除未使用的索引 ===
db.products.dropIndex('unused_index_name');

// 场景 1：TTL 索引自动清理会话（30 分钟过期）
db.sessions.insertMany([
  { userId: 'user_001', token: 'abc', createdAt: new Date() },
  { userId: 'user_002', token: 'xyz', createdAt: new Date(Date.now() - 31 * 60 * 1000) }  // 已过期
]);

db.sessions.createIndex(
  { createdAt: 1 },
  { expireAfterSeconds: 30 * 60 }  // 30 分钟
);

// 等待 60 秒后，过期文档被自动删除
// db.sessions.find() → 只剩 user_001 的会话

// 场景 2：部分索引 - 仅索引在售商品（节省 70% 空间）
db.products.createIndex(
  { category: 1, price: 1 },
  {
    partialFilterExpression: {
      isActive: true,
      stock: { $gt: 0 }
    }
  }
);

// 部分索引只在查询包含 filter 条件时使用
db.products.find({
  category: 'Electronics',
  isActive: true,    // 必须匹配 partialFilterExpression
  stock: { $gt: 0 }, // 必须匹配 partialFilterExpression
  price: { $gte: 100, $lte: 500 }
}).explain();
// winningPlan.inputStage.stage: IXSCAN（使用了部分索引）

// 场景 3：ESR 规则实战 - 订单查询
db.orders.insertMany([
  { userId: 'user_001', status: 'paid', createdAt: new Date('2026-07-01'), total: 100 },
  { userId: 'user_001', status: 'paid', createdAt: new Date('2026-07-02'), total: 200 },
  { userId: 'user_002', status: 'pending', createdAt: new Date('2026-07-03'), total: 50 }
]);

// ESR 最佳索引：Equality → Sort → Range
db.orders.createIndex({
  userId: 1,        // E - 等值过滤
  status: 1,        // E - 等值过滤
  createdAt: -1,    // S - 排序（方向匹配）
  total: 1          // R - 范围查询（放最后）
});

// 高效查询：用户已支付订单，按时间倒序，价格范围
db.orders.find({
  userId: 'user_001',                              // E
  status: 'paid',                                  // E
  total: { $gte: 50, $lte: 300 }                   // R
}).sort({ createdAt: -1 }).limit(20)               // S
.explain('executionStats');

// 输出：完全使用复合索引，无需额外排序
// totalKeysExamined: 2, totalDocsExamined: 2, nReturned: 2