第4章 索引与性能优化 ​

// mongosh 对照（索引文档里的 1/-1 与 Java 的 Document 完全同形）
use yjoffer
db.t_order.createIndex({ userId: 1 }, { name: "idx_user" });
db.t_order.createIndex({ userId: 1, createTime: -1 });
db.t_order.createIndex({ orderNo: 1 }, { unique: true });

db.t_order.getIndexes();          // 查看（对照 SHOW INDEX）
db.t_order.dropIndex("idx_user"); // 删除

// mongosh 对照
db.products.createIndex({ tags: 1 });                       // 多键索引
db.products.find({ tags: "java" }, { title: 1 });           // ✅ 走索引
db.posts.createIndex({ "comments.author": 1 });             // 内嵌文档数组按 "数组.字段" 索引
db.posts.find({ "comments.author": "amy" });

db.products.insertOne({ title: "MongoDB 实战", tags: ["java", "mongodb"] });
db.products.createIndex({ tags: 1 });
db.products.getIndexes()
// 输出里出现 multikey 字段即证实（列出被「炸开索引」的数组路径）：
// { v: 2, key: { tags: 1 }, name: 'tags_1', multikey: { tags: 1 } }

// mongosh 对照
db.t_order.find({ userId: u });                                      // ✅ 用前缀
db.t_order.find({ userId: u, createTime: { $lt: d } });              // ✅ 全命中
db.t_order.find({ createTime: { $lt: d } });                         // ❌ 跳最左，集合扫或索引扫
db.t_order.find({ userId: u }).sort({ createTime: -1 });             // ✅ 等值+排序全吃

// 方式二：mongosh（日常排慢查最常用，输出结构同上）
db.t_order.find({ userId: ObjectId("...") }).explain("executionStats")

// mongosh 对照
db.sessions.createIndex({ createTime: 1 }, { expireAfterSeconds: 86400 });
// 注意：字段必须是 Date 类型；数组字段会按「元素中最小的日期」判定过期

// mongosh 对照
db.articles.createIndex({ title: "text", content: "text" });
db.articles.find({ $text: { $search: "索引 教程" } });            // 分词相关性打分
db.articles.find({ $text: { $search: "索引" } },
                 { score: { $meta: "textScore" } })
              .sort({ score: { $meta: "textScore" } });          // 按相关度排序

// mongosh 对照
db.coupons.createIndex({ code: 1 }, { partialFilterExpression: { used: false } });
// 稀疏索引（只索引含该字段的文档，历史用法，新库优先 partial）：
db.coupons.createIndex({ code: 1 }, { sparse: true });

// mongosh 对照：开关与查询
db.setProfilingLevel(1, { slowms: 100 });            // 记录 >100ms 的操作
db.getProfilingStatus();                              // 看当前级别
db.system.profile.find({ millis: { $gt: 100 } }).sort({ ts: -1 }).limit(20);  // 查慢日志
db.setProfilingLevel(0);                              // 关掉（默认级别 0 不记）

// mongosh 播种（orders 集合，分批 insertMany 比循环 insertOne 快一个量级）
let uids = [ObjectId(), ObjectId(), ObjectId()];
let batch = [];
for (let i = 0; i < 10000; i++) {
  batch.push({ userId: uids[i % 3], orderNo: "AB" + (100000 + i),
    status: i % 10 == 0 ? 0 : 1,                     // 10% 待处理
    createTime: new Date(Date.now() - i * 60000) });  // 每分钟一单，越新 i 越小
  if (batch.length == 2000) { db.orders.insertMany(batch); batch = []; }
}
if (batch.length) db.orders.insertMany(batch);

db.orders.createIndex({ userId: 1, createTime: -1 });              // ① 按用户查最近订单（分页）：等列+排序列全吃
 db.orders.createIndex({ orderNo: 1 }, { unique: true });           // ② 订单号精确查：唯一兼防重
 db.orders.createIndex({ status: 1, createTime: 1 });              // ③ 扫待处理：等值 status 在前，范围时间在后

db.orders.find({ userId: uids[0] }).sort({ createTime: -1 }).skip(0).limit(20).explain("executionStats")
// 预期输出关键行：
// winningPlan.stage: IXSCAN → FETCH
// executionStats.totalKeysExamined: 20, totalDocsExamined: 20, nReturned: 20   ← 1:1，索引精准
//（没建对时：totalDocsExamined: 10000 + COLLSCAN，一眼分得出差距）

db.orders.find({ orderNo: "AB100005" }).explain("executionStats")   // nReturned=1, docsExamined=1
db.orders.find({ status: 0, createTime: { $lt: new Date() } }).explain("executionStats")
// 走 idx③：keysExamined≈docsExamined≈1000（待处理全量），若想覆盖查询把需要的字段加进索引尾部

db.sms_codes.createIndex({ createTime: 1 }, { expireAfterSeconds: 60 });
db.sms_codes.insertOne({ phone: "137****", code: "8846", createTime: new Date() });
db.sms_codes.countDocuments();   // 1

// 60 秒后：db.sms_codes.countDocuments() → 可能还是 1（本轮未到）
// 120 秒后：→ 0，已被自动删除；无需任何定时任务代码

db.sms_codes.stats()
// nDocument 从 1 → 0；⚠️ totalSize/storageSize 不会立即回落——删除的空间留在集合里复用，
// 和 2.9 讲的「删数据不马上还磁盘」同一心智

db.orders.find().sort({ createTime: -1 }).skip(50000).limit(20).explain("executionStats")
// totalKeysExamined: 50020, totalDocsExamined: 50020, nReturned: 20, executionTimeMillis: ≈300
// ↑ 前 50000 条被「扫过又扔掉」——和 MySQL 大 OFFSET 同病（第 4 章迁移表倒数第 2 行）

db.orders.find({ createTime: { $lt: lastTime } }).sort({ createTime: -1 }).limit(20).explain("executionStats")
// totalKeysExamined: 20, totalDocsExamined: 20, executionTimeMillis: ≈1
// 代价不随页码增长：第 1 页和第 2500 页都是 20