MongoDB 索引类型#

// 创建单字段索引
db.users.createIndex({ age: 1 })  // 1 表示升序，-1 表示降序

// 等价的底层数据结构
// B-Tree:
//       [age: 18] ──┬── [age: 25]
//                  │
//                  └── [age: 20] ──┬── [age: 30]
//                                   │
//                                   └── [age: 35]
// 查找 age = 25：从根节点开始，二分查找定位到 [age: 25] 所在的叶子节点
// 时间复杂度：O(log n)，而不是 O(n) 的全表扫描

// 创建复合索引（Compound Index）
db.products.createIndex({ category: 1, price: -1, name: 1 })

// 查看索引
db.products.getIndexes()
// [
//   { "v": 2, "key": { "_id": 1 }, "name": "_id_" },
//   { "v": 2, "key": { "category": 1, "price": -1, "name": 1 }, "name": "category_1_price_-1_name_1" }
// ]

// 查看查询是否使用了索引
db.products.find({ category: "electronics" }).explain("executionStats")
// executionStats.executionStages.inputStage.stage: "IXSCAN" → 使用了索引
// executionStats.executionStages.stage: "COLLSCAN" → 全表扫描

// P5 级别：知道基本索引类型
"MongoDB 支持单字段索引、复合索引、多键索引、文本索引、地理位置索引等。
创建索引用 `createIndex`，查看用 `explain`。"

// P6 级别：能讲清楚复合索引字段顺序
"复合索引的字段顺序很重要，遵循最左前缀原则。
比如 `{ age: 1, name: 1 }` 的索引可以支持
`{ age: 25 }` 和 `{ age: 25, name: "张三" }` 的查询，
但不支持 `{ name: "张三" }` 的查询。
字段顺序的选择取决于实际查询中最常用的过滤条件。"

// P7 级别：能讲清楚索引覆盖和写放大
"理想的索引应该覆盖查询的所有字段（Covered Query），
这样查询可以直接在索引中返回结果，不需要回表查原始文档。
但覆盖索引会增加存储开销和写放大——每次更新文档时都要更新索引。
生产环境中需要权衡：读多写少的字段适合建覆盖索引，写多读少的字段要谨慎建索引。"

// 创建复合索引
db.users.createIndex({ age: 1, city: 1, signUpDate: 1 })

// 以下查询可以使用这个索引（遵循最左前缀）：
db.users.find({ age: 25 })                           // ✅ 使用索引前导字段
db.users.find({ age: 25, city: "北京" })             // ✅ 使用前两个字段
db.users.find({ age: 25, city: "北京", signUpDate: { $gte: new Date() } }) // ✅ 全匹配

// 以下查询不能使用完整索引：
db.users.find({ city: "北京" })                       // ❌ 跳过前导字段，无法使用
db.users.find({ signUpDate: { $gte: new Date() } })  // ❌ 跳过前两个字段
db.users.find({ city: "北京", signUpDate: { $gte: new Date() } }) // ❌ 跳过 age

// 选择性高的字段放前面
// 场景：筛选活跃用户
// { status: 1, age: 1, city: 1 }
// status 只有 3 个值（活跃/禁用/冻结），选择性低
// age 有 100+ 个值，选择性高
// 如果查询总是 { status: "active", age: 25 }，索引应该是 { status: 1, age: 1 }
// 如果查询是 { status: "active", city: "北京" }，索引应该是 { status: 1, city: 1 }

// 经验法则：
// 1. 等值条件字段（=）放前面
// 2. 排序字段放中间（如果排序是固定的）
// 3. 范围条件字段（$gte）放最后

// 文档
{
  _id: 1,
  name: "张三",
  tags: ["java", "mysql", "mongodb"]  // 数组字段
}

// tags 字段上的多键索引结构（B-Tree）：
// java     → [doc_1]
// mysql    → [doc_1]
// mongodb  → [doc_1]
// python   → [doc_2, doc_3]

// 查询
db.collection.find({ tags: "java" })
// 查找索引键 "java"，直接返回 [doc_1]
// 时间复杂度：O(log n)，而不是遍历所有文档的 O(n)

// ❌ 错误：会报错 "cannot create compound index with several array fields"
db.products.createIndex({ tags: 1, categories: 1 })

// 原因：多键索引的交叉乘积会导致索引爆炸
// tags: ["A", "B"] + categories: ["X", "Y"] → 索引条目: A+X, A+Y, B+X, B+Y

// ❌ 错误
db.collection.createIndex({ tags: 1 }, { unique: true })
// 报错：cannot create unique index on array field

// 因为数组去重后可能导致唯一性被破坏

// 创建文本索引
db.articles.createIndex({ title: "text", content: "text" })

// 查询：搜索包含关键词的文档
db.articles.find({ $text: { $search: "mongodb optimization" } })

// 给文本索引加权（title 的权重高于 content）
db.articles.createIndex(
  { title: "text", content: "text" },
  { weights: { title: 10, content: 1 } }
)

// 查看文本搜索的得分
db.articles.find(
  { $text: { $search: "mongodb" } },
  { score: { $meta: "textScore" } }
).sort({ score: { $meta: "textScore" } })

// 存储地理位置数据
db.stores.insertOne({
  name: "星巴克中关村店",
  location: {
    type: "Point",
    coordinates: [116.312345, 39.987654]  // [经度, 纬度]
  }
})

// 创建 2dsphere 索引
db.stores.createIndex({ location: "2dsphere" })

// 查询：附近 5 公里内的商家
db.stores.find({
  location: {
    $nearSphere: {
      $geometry: { type: "Point", coordinates: [116.3, 39.9] },
      $maxDistance: 5000  // 5公里，单位：米
    }
  }
})

// 范围查询（不需要 $nearSphere，只需要 $geoWithin）
db.stores.find({
  location: {
    $geoWithin: {
      $centerSphere: [[116.3, 39.9], 5 / 6378.1]  // [中心点, 距离（弧度）]
    }
  }
})

// 创建 TTL 索引：文档在 30 天后自动删除
db.sessions.createIndex({ createdAt: 1 }, { expireAfterSeconds: 30 * 24 * 60 * 60 })

// MongoDB 后台线程每 60 秒检查一次 TTL
// 适用于：会话数据、临时文件、日志

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

// 复合唯一索引（两个字段组合唯一）
db.userOrders.createIndex({ userId: 1, orderId: 1 }, { unique: true })

// 稀疏唯一索引（只对存在字段的值强制唯一，忽略 null）
db.profiles.createIndex({ phone: 1 }, { unique: true, sparse: true })
// 如果 phone 为 null 的文档有多条，sparse: true 不会报错
// 如果没有 sparse，插入多个 phone 为 null 的文档会报错

// 场景分析
// 1. 查询模式分析（通过慢查询日志）
db.getSiblingDB("admin").aggregate([
  { $currentOp: { allUsers: true, ops: true } },
  { $match: { op: "command", "command.aggregate": { $exists: true } } }
])

// 2. 查看当前索引的使用情况
db.collection.aggregate([
  { $indexStats: {} }
])
// 结果包含每个索引被访问的次数、命中次数、扫描次数

// 3. 识别未使用的索引
// 访问次数为 0 的索引应该删除
db.collection.dropIndex("未使用的索引名")