投影、排序与分页

// 只要用户名和城市
db.users.find({}, { username: 1, "profile.city": 1 })

[
  { "_id": ObjectId("...201"), "username": "alice", "profile": { "city": "Beijing" } },
  { "_id": ObjectId("...202"), "username": "bob",   "profile": { "city": "Shanghai" } }
]

db.users.find({}, { username: 1, "profile.city": 1, _id: 0 })

[
  { "username": "alice", "profile": { "city": "Beijing" } },
  { "username": "bob",   "profile": { "city": "Shanghai" } }
]

db.users.find({}, { username: 1, email: 0 })

MongoServerError: Cannot do inclusion on field email in exclusion projection

不投影：磁盘/缓存读整个文档 → 序列化整个文档 → 网络传输整个文档
投影：  仍读整个文档（除非覆盖查询）→ 只序列化需要的字段 → 只传需要的字段

// 只返回前 3 条评论
db.posts.find({ _id: 100 }, { title: 1, comments: { $slice: 3 } })
 
// 只返回最后 3 条
db.posts.find({ _id: 100 }, { title: 1, comments: { $slice: -3 } })
 
// 跳过 10 条，取 5 条（数组内分页）
db.posts.find({ _id: 100 }, { title: 1, comments: { $slice: [10, 5] } })

db.posts.find(
  { _id: 100 },
  { title: 1, comments: { $elemMatch: { author: "alice" } } }
)

[
  {
    "_id": 100,
    "title": "MongoDB 数组更新",
    "comments": [ { "cid": 1, "author": "alice", "body": "好文", "likes": 3 } ]
  }
]

// 返回 filter 中匹配到的那一个元素
db.posts.find({ _id: 100, "comments.cid": 2 }, { "comments.$": 1 })

db.posts.aggregate([
  { $match: { _id: 100 } },
  { $project: {
      title: 1,
      hotComments: { $filter: {
        input: "$comments",
        as: "c",
        cond: { $gte: ["$$c.likes", 3] }
      } }
  } }
])

db.posts.find().sort({ views: -1 })                    // 降序
db.posts.find().sort({ views: -1, createdAt: 1 })      // 多字段
db.users.find().sort({ "profile.city": 1, age: -1 })   // 内嵌字段

MongoServerError: Executor error during find command :: caused by ::
Sort exceeded memory limit of 33554432 bytes, but did not opt in to external sorting.

// 方案一（推荐）：建索引，让排序走索引，零内存开销
db.posts.createIndex({ views: -1 })
 
// 方案二：聚合管道里允许落盘（慢，但不会失败）
db.posts.aggregate([ { $sort: { views: -1 } } ], { allowDiskUse: true })

db.posts.createIndex({ authorId: 1, createdAt: -1 })
 
// 能走索引排序
db.posts.find({ authorId: "alice" }).sort({ createdAt: -1 })   ✔
 
// 方向全部相反也可以（索引可以反向扫描）
db.posts.find({ authorId: "alice" }).sort({ createdAt: 1 })    ✔
 
// 方向不一致就不行
db.posts.find().sort({ authorId: -1, createdAt: -1 })          ✘ 需要内存排序

// 不稳定：如果有多篇帖子 views 都是 100
db.posts.find().sort({ views: -1 }).skip(20).limit(10)
 
// 稳定：加一个唯一字段做 tie-breaker
db.posts.find().sort({ views: -1, _id: 1 }).skip(20).limit(10)

const pageSize = 20
const page = 3
db.posts.find().sort({ createdAt: -1, _id: 1 })
  .skip((page - 1) * pageSize)
  .limit(pageSize)

请求第 5000 页（skip 99980, limit 20）：
 
  索引扫描 ──▶ 读取第 1 个文档 ──▶ 丢弃
             读取第 2 个文档 ──▶ 丢弃
                    ...
             读取第 99980 个 ──▶ 丢弃      ← 99980 次无用功
             读取第 99981 个 ──▶ 返回
                    ...
             读取第 100000 个 ─▶ 返回
 
  实际耗时与页码成正比，第 5000 页可能要几秒

// 第一页
const first = db.posts.find()
  .sort({ _id: -1 })
  .limit(20)
  .toArray()
 
const lastId = first[first.length - 1]._id
 
// 下一页：从 lastId 继续
db.posts.find({ _id: { $lt: lastId } })
  .sort({ _id: -1 })
  .limit(20)

  游标分页：
  索引 B 树 ──▶ 直接 seek 到 lastId ──▶ 顺序读 20 条 ──▶ 返回
                （O(log N)）              （O(20)）
 
  与页码无关，永远这么快

// 上一页最后一条：views = 300, _id = ObjectId("...abc")
db.posts.find({
  $or: [
    { views: { $lt: 300 } },
    { views: 300, _id: { $gt: ObjectId("665f1a2b3c4d5e6f708192ab") } }
  ]
})
.sort({ views: -1, _id: 1 })
.limit(20)

db.posts.createIndex({ views: -1, _id: 1 })

// 编码
const cursor = Buffer.from(JSON.stringify({ v: 300, i: lastId.toString() })).toString("base64")
 
// 前端下次请求带上 cursor，服务端解码后构造上面的 $or 查询

// 首页信息流：按发布时间倒序，游标分页，只取列表页需要的字段
function feed(beforeId, size = 20) {
  const filter = { status: "published" }
  if (beforeId) filter._id = { $lt: beforeId }
 
  return db.posts.find(filter, {
    title: 1,
    authorId: 1,
    "stats.likes": 1,
    "stats.comments": 1,
    coverUrl: 1,
    createdAt: 1,
    comments: { $slice: 2 }        // 预览两条热评
  })
  .sort({ _id: -1 })
  .limit(size)
  .toArray()
}

db.posts.createIndex({ status: 1, _id: -1 })