// 业务查询语句
db.t_orders.find({
    userId: 10086,                               // E: 等值
    status: "paid",                              // E: 等值
    createTime: { $gte: ISODate("2024-02-01") }  // R: 范围
}).sort({ amount: -1 })                          // S: 排序

// 错误：Range 在 Sort 之前，索引在 createTime 发散后无法支撑 amount 排序，触发内存排序
db.t_orders.createIndex(
    { userId: 1, status: 1, createTime: 1, amount: -1 },
    { background: true }
)

// 正确：ESR 顺序，等值过滤 → 索引排序 → 范围截断
db.t_orders.createIndex(
    { userId: 1, status: 1, amount: -1, createTime: 1 },
    { background: true }
)

 // 已有复合索引
db.t_orders.createIndex(
    { userId: 1, status: 1, createTime: 1 },
    { background: true }
)

// 正确：包含最左字段 userId，索引完全命中
db.t_orders.find({ userId: 10086, status: "paid" })

// 部分命中：包含最左字段 userId，但跳过 status，仅利用 userId 定位
db.t_orders.find({ userId: 10086, createTime: { $gte: ISODate("2024-01-01") } })

// 错误：缺失最左字段 userId，触发全表扫描
db.t_orders.find({ status: "pending" })

// 解决方案：为独立查询字段单独建立索引
db.t_orders.createIndex(
    { status: 1 },
    { background: true }
)

// 错误：未指定 background，可能阻塞所有操作
db.t_orders.createIndex({ customerId: 1 })

// 单个创建：开启 background 模式，避免阻塞业务
db.t_orders.createIndex(
    { customerId: 1, createTime: -1 },
    { background: true }
)

// 第一步：查看集合当前所有索引
db.t_orders.getIndexes()

// 第二步：通过 $indexStats 排查每个索引的实际使用情况
db.t_orders.aggregate([{ $indexStats: {} }]).forEach(function(idx) {
    print(
        "索引名称:", idx.name,
        "| 调用次数:", idx.accesses.ops,
        "| 最近使用:", idx.accesses.since
    )
})

// 第三步：查看索引与数据的存储占比
var stats = db.t_orders.stats()
print("数据大小:", (stats.size / 1024 / 1024).toFixed(2), "MB")
print("索引大小:", (stats.totalIndexSize / 1024 / 1024).toFixed(2), "MB")
print("索引/数据比:", (stats.totalIndexSize / stats.size * 100).toFixed(1), "%")

// 第四步：删除调用次数为 0 的冗余索引
// 操作前务必确认该索引确实无业务依赖
db.t_orders.dropIndex("idx_legacy_report_1")
db.t_orders.dropIndex("idx_legacy_report_2")

// 注意：禁止删除 _id 默认索引
// db.t_orders.dropIndex("_id")  // 此操作会报错，_id 索引不可删除

// 第一步：执行统计聚合，识别无用索引
db.t_orders.aggregate([{ $indexStats: {} }])
/* 输出示例分析：
{
    "name": "idx_old_field",
    "accesses": {
        "ops": NumberLong(0),    // 关键指标：调用次数为 0
        "since": ISODate("2024-01-01T00:00:00Z")
    }
}
*/

// 第二步：逻辑隐藏（支持快速回滚，MongoDB 4.4+）
db.t_orders.hideIndex("idx_old_field")

// 观察期：持续监控 1-7 天，若业务受损可立即执行 db.t_orders.unhideIndex("idx_old_field") 恢复。

// 第三步：物理删除（确认无损后执行）
db.t_orders.dropIndex("idx_old_field")

// 模式一：固定时长淘汰（例如：按 createTime 字段，30 天后过期）
db.t_sessions.createIndex(
    { createTime: 1 },
    { expireAfterSeconds: 2592000, background: true }
)

// 模式二：精准时间戳淘汰（推荐，由业务层动态决定存活时间）
// 将 expireAfterSeconds 设为 0，引擎将在 expireAt 时间点到达时进行清理
db.t_sessions.createIndex(
    { expireAt: 1 },
    { expireAfterSeconds: 0, background: true }
)

// 业务层插入时，直接指定具体的死亡时间
db.t_sessions.insertOne({
    sessionId: "sess_001",
    userId: "user_001",
    expireAt: new Date(Date.now() + 3600000)  // 动态指定 1 小时后过期
})

// 推荐：创建时序集合（传感器每 5 分钟上报一次）
db.createCollection("t_sensor_data", {
    timeseries: {
        timeField: "timestamp",        // 必选：时间戳字段
        metaField: "sensorId",         // 推荐：数据源标识
        granularity: "minutes"         // 粒度匹配采集频率（5 分钟 → minutes）
    }
})

// 推荐：创建时序集合（系统监控每秒采集）
db.createCollection("t_metrics", {
    timeseries: {
        timeField: "ts",
        metaField: "metadata",         // metadata 可以是对象，如 { host: "web01", region: "bj" }
        granularity: "seconds"         // 粒度匹配采集频率（秒级 → seconds）
    }
})

// 插入时序数据
db.t_sensor_data.insertMany([
    { sensorId: "sensor_001", timestamp: new Date(), temperature: 23.5, humidity: 65 },
    { sensorId: "sensor_001", timestamp: new Date(), temperature: 23.6, humidity: 64 },
    { sensorId: "sensor_002", timestamp: new Date(), temperature: 18.2, humidity: 72 }
], { ordered: false })  // ordered: false 提升批量写入性能

// 错误：在普通集合上手动管理时序数据
db.createCollection("t_sensor_data_old")
db.t_sensor_data_old.createIndex({ sensorId: 1, timestamp: -1 })
// 需要自行处理数据归档、压缩、清理，维护成本高

// 查询最近 24 小时某设备的数据（自动利用时序索引）
db.t_sensor_data.find({
    sensorId: "sensor_001",
    timestamp: { $gte: new Date(Date.now() - 86400000) }
}).sort({ timestamp: -1 })

// 用 $group 聚合替代 distinct()（时序集合不支持高效 distinct）
db.t_sensor_data.aggregate([
    { $match: { timestamp: { $gte: new Date(Date.now() - 86400000) } } },
    { $group: { _id: "$sensorId" } }
])

// 错误：排序字段未建索引，可能触发内存排序
db.t_orders.find({ status: "paid" }).sort({ createTime: -1 })

// 正确：排序字段包含在索引中
db.t_orders.createIndex({ status: 1, createTime: -1 }, { background: true })
db.t_orders.find({ status: "paid" }).sort({ createTime: -1 })  // 索引排序，无内存限制

// 验证是否使用索引排序
db.t_orders.find({ status: "paid" }).sort({ createTime: -1 }).explain("executionStats")
// 检查是否有 SORT 阶段，无 SORT 表示使用了索引排序

// 低效：$ne 无法有效利用索引
db.t_orders.find({ status: { $ne: "cancelled" } })

// 优化：$in 列出所有有效状态
db.t_orders.find({ status: { $in: ["pending", "paid", "shipped", "completed"] } })

// 低效：无前缀正则，全表扫描
db.t_users.find({ name: /张/ })

// 优化：前缀锚定正则，可利用索引
db.t_users.find({ name: /^张/ })

db.t_orders.find({ status: "paid" }).explain("executionStats")

// 关键指标，接近 1：索引高效，扫描即命中
totalDocsExamined / nReturned ≈ 1   // 理想值

// 在 explain 结果中定位排序阶段
executionStats.executionStages.stage
// 或嵌套在 inputStage / inputStages 中

// 不符合 ESR：范围字段在前，排序字段在后
db.t_orders.createIndex({ createTime: 1, status: 1 })
db.t_orders.find({ createTime: { $gte: ISODate("2024-01-01") }, status: "paid" }).sort({ amount: -1 })

// 符合 ESR：等值 → 排序 → 范围
db.t_orders.createIndex({ status: 1, amount: -1, createTime: 1 })


// 多个单字段索引：MongoDB 尝试索引交集，效率不稳定
db.t_orders.createIndex({ status: 1 })
db.t_orders.createIndex({ userId: 1 })
db.t_orders.createIndex({ createTime: 1 })

// 复合索引：一个索引覆盖查询 + 排序，遵循 ESR 原则
db.t_orders.createIndex({ status: 1, userId: 1, createTime: -1 })

// 当查询模式不固定、字段组合多变时，单字段索引更灵活：
// 场景：运营后台的动态筛选，用户可能按任意字段组合查询，此时为每种组合建复合索引不现实，单字段索引 + 索引交集是合适的选择
db.t_orders.find({ status: "paid" })                    // 只按状态
db.t_orders.find({ userId: "u_10001" })                  // 只按用户
db.t_orders.find({ createTime: { $gte: ISODate("...") } }) // 只按时间
db.t_orders.find({ status: "paid", userId: "u_10001" })  // 状态 + 用户

sh.stopBalancer()

db.orders.createIndex({ userId: 1, createTime: -1 }, { background: true })

// 查看当前正在执行的索引构建任务
db.currentOp({ "command.createIndexes": { $exists: true } })