03. MongoDB 索引类型与查询优化

// 单键索引
db.users.createIndex({ email: 1 });  // 1 = 升序, -1 = 降序

// 复合索引（最左前缀原则）
db.orders.createIndex({ status: 1, createdAt: -1 });

// 唯一索引
db.users.createIndex({ email: 1 }, { unique: true });

// 查看索引
db.users.getIndexes();
db.users.totalIndexSize();  // 索引占用空间

// 删除索引
db.users.dropIndex("email_1");
db.users.dropIndexes();

// 最基础的索引
db.users.createIndex({ age: 1 });

// 适用查询:
db.users.find({ age: 30 });
db.users.find({ age: { $gte: 18, $lte: 60 } }).sort({ age: 1 });

// 查询模式: WHERE status = ? AND createdAt > ? ORDER BY createdAt DESC
// 索引设计: { status: 1, createdAt: -1 }
db.orders.createIndex({ status: 1, createdAt: -1 });

// ✅ 有效使用:
db.orders.find({ status: "pending" });
db.orders.find({ status: "paid", createdAt: { $gt: yesterday } });
db.orders.find({ status: "pending" }).sort({ createdAt: -1 });

// ❌ 无法使用（缺少 status）:
db.orders.find({ createdAt: { $gt: yesterday } });
// ❌ 无法排序（排序方向不符）:
db.orders.find({ status: "pending" }).sort({ createdAt: 1 });

// 自动为数组字段创建多键索引
db.products.createIndex({ tags: 1 });

// 查询:
db.products.find({ tags: "electronics" });  // IXSCAN
db.products.find({ tags: { $all: ["electronics", "sale"] } });

// 限制: 复合索引中最多一个多键字段
db.orders.createIndex({ items: 1, status: 1 });  // ❌ 可能失败

// 全文搜索索引
db.articles.createIndex({
    title: "text",
    content: "text",
    tags: "text"
}, {
    weights: {
        title: 10,      // 标题匹配权重更高
        content: 5,
        tags: 3
    },
    default_language: "chinese"
});

// 全文查询
db.articles.find({ $text: { $search: "MongoDB indexing" } },
                 { score: { $meta: "textScore" } })
          .sort({ score: { $meta: "textScore" } });

// 短语搜索
db.articles.find({ $text: { $search: "\"exact phrase\"" } });

// 自动删除过期文档（适用于验证码、临时数据）
db.sessions.createIndex(
    { createdAt: 1 },
    { expireAfterSeconds: 3600 }  // 1小时过期
);

// TTL 后台线程每 60 秒运行一次，过期时间可能有延迟

// 稀疏索引: 只对存在该字段的文档建立索引
db.users.createIndex({ phone: 1 }, { sparse: true });

// 部分索引: 只对满足条件的文档建立索引（更有用）
db.orders.createIndex(
    { orderId: 1 },
    { partialFilterExpression: { status: { $eq: "pending" } } }
);
// 只为 pending 订单建立索引，大幅减少索引大小

db.orders.find({ status: "pending" }).explain("executionStats");

{
  "queryPlanner": {
    "winningPlan": {
      "stage": "FETCH",
      "inputStage": {
        "stage": "IXSCAN",
        "indexName": "status_1_createdAt_-1",
        "direction": "forward"
      }
    }
  },
  "executionStats": {
    "nReturned": 150,        // 返回文档数
    "totalDocsExamined": 150, // 扫描文档数
    "totalKeysExamined": 150, // 扫描索引键数
    "executionTimeMillis": 2,  // 执行时间
    "executionStages": {
      "stage": "IXSCAN",
      "works": 151,
      "advanced": 150,
      "isEOF": 1
    }
  }
}

// 索引 { _id: 1, status: 1 }
db.orders.find({ _id: 1 }, { status: 1, _id: 1 });
// Covered Query: 只从索引获取数据，不回表

// 执行计划中: "executionStats.totalDocsExamined" = 0

// 假设查询模式: WHERE status = ? AND category IN (?) AND createdAt > ? ORDER BY createdAt DESC
// ✅ ESR 顺序: Equality → Sort → Range
// Equality: status = "active"
// Sort: createdAt DESC
// Range: category IN [...]
db.orders.createIndex({ status: 1, createdAt: -1, category: 1 });

// ❌ 错误顺序: Range 在 Sort 前
db.orders.createIndex({ status: 1, category: 1, createdAt: -1 });
// 当 category IN 有多个值时，索引无法按 createdAt 有序返回

// 分析字段选择性
db.users.aggregate([
  { $group: { _id: "$gender", count: { $sum: 1 } } },
  { $sort: { count: -1 } }
])
// gender 只有两个值，选择性极低，单独索引无意义

db.users.aggregate([
  { $group: { _id: "$email", count: { $sum: 1 } } },
  { $count: "distinct_count" }
])
// email 几乎唯一，高选择性，适合单键索引

// 索引交集: { a: 1 } 和 { b: 1 } 可以联合服务 { a: 1, b: 1 }
// 但不保证有序，性能通常不如专用复合索引

// 查看冗余索引（MongoDB 4.4+）
db.orders.aggregate([
  { $indexStats: {} },
  {
    $project: {
      name: 1,
      key: 1,
      accesses: "$accesses.ops",
      since: "$accesses.since"
    }
  }
])

// 清理策略：
// 1. 前缀冗余: { a: 1, b: 1 } 已存在时，{ a: 1 } 通常冗余
// 2. 30天 0 访问的索引考虑删除
// 3. 用 db.currentOp() 观察索引构建对写入的影响

// 后台创建（不会阻塞读写，但耗时更长）
db.large_collection.createIndex(
  { createdAt: -1 },
  { background: true }
)

// 监控进度（MongoDB 4.2+）
db.adminCommand({
  "currentOp": true,
  "$or": [
    { "desc": "Indexer" },
    { "type": "op", "originatingCommand.createIndexes": { $exists: true } }
  ]
})

// 4.2+ 支持 hybrid 构建：开始前台，达到阈值后自动切换后台

// TTL 单字段索引
db.sessions.createIndex(
  { lastAccessed: 1 },
  { expireAfterSeconds: 3600 }
)

// 限制：
// 1. TTL 字段必须是 Date 类型
db.sessions.insertOne({ lastAccessed: Date.now() }) // ❌ 不是 Date

// 2. 无法在复合索引上直接设置 TTL
// 变通：使用部分索引 + 应用层清理
db.sessions.createIndex(
  { status: 1, createdAt: 1 },
  {
    partialFilterExpression: {
      status: { $eq: "pending" },
      createdAt: { $lt: new Date(Date.now() - 3600 * 1000) }
    }
  }
)

// 3. 删除延迟：TTL 线程每 60 秒运行一次
db.serverStatus().metrics.ttl.deletedDocuments

// 分片键前缀原则：分片键必须是索引前缀
// ✅ 正确：分片键 { userId: 1 }，索引 { userId: 1, createdAt: -1 }
sh.shardCollection("mydb.orders", { userId: 1 })

// 全局唯一索引必须包含分片键
// ❌ 错误：无法直接创建 { email: 1 } 唯一索引
// ✅ 变通：{ email: 1, userId: 1 } 唯一索引
db.orders.createIndex(
  { email: 1, userId: 1 },
  { unique: true }
)

//hashed 分片键（均匀分布）
sh.shardCollection("mydb.logs", { _id: "hashed" })

// 启用慢查询日志（>100ms）
db.setProfilingLevel(1, { slowms: 100 })
db.system.profile.find().sort({ ts: -1 }).limit(5)

// 强制清理计划缓存
// 升级到新版本后、删除索引后、大量数据导入后执行
db.orders.getPlanCache().clear()