31. MongoDB 读写关注与一致性

// 三要素在连接串与操作中的位置
// 连接串：mongodb://host:27017/?replicaSet=rs0&readPreference=secondary&w=majority
db.orders.insertOne(
  { orderNo: "A-1", amount: 100 },
  { writeConcern: { w: "majority", j: true, wtimeout: 5000 } }
)

// 完整指定三要素的读取（路由到副节点 + 多数派已确认 + 因果时间）
db.orders.find(
  { customerId: "u_1001" },
  { readConcern: { level: "majority" } }
).readPref("secondaryPreferred")

// w: 0：异步发送，不等确认（丢失不可感知）
db.orders.insertOne({ orderNo: "L-0" }, { writeConcern: { w: 0 } })

// w: 1：默认，主节点写入即返回
db.orders.insertOne({ orderNo: "L-1" })

// w: "majority"：多数派确认，配合 j 落盘
db.orders.insertOne({ orderNo: "L-2" }, { writeConcern: { w: "majority", j: true } })

// w: N：显式指定确认节点数
db.orders.insertOne({ orderNo: "L-3" }, { writeConcern: { w: 3 } })

// wtimeout：避免写关注长期挂起
db.orders.insertOne(
  { orderNo: "T-1" },
  { writeConcern: { w: "majority", wtimeout: 3000 } }
)
// 3 秒内未获多数确认则抛 wtimeout，但写入本身可能已发生在主节点

// 错误一：UnsatisfiableWriteConcern（配置不可满足）
db.orders.insertOne(
  { orderNo: "E-1" },
  { writeConcern: { w: 5 } }   // 副本集只有 3 个成员
)
// 抛错：cannot use w: 5, 副本集成员数不足

// 错误二：WriteConcernError（等待超时或节点不可达）
db.orders.insertOne(
  { orderNo: "E-2" },
  { writeConcern: { w: "majority", wtimeout: 2000 } }
)
// 返回的 writeConcernError 表示确认超时，但写入可能已发生

// local：默认，读到节点本地最新数据
db.orders.find({ orderNo: "L-1" }).readConcern("local")

// majority：读到多数派已确认的数据
db.orders.find({ orderNo: "L-1" }).readConcern("majority")

// 聚合中使用
db.orders.aggregate(
  [{ $match: { status: "paid" } }, { $group: { _id: "$customerId", total: { $sum: "$amount" } } }],
  { readConcern: { level: "majority" } }
)

// linearizable 必须在主节点、单文档读取场景使用
db.accounts.find(
  { _id: "u_1001" },
  { readConcern: { level: "linearizable" } }
)

// 场景：主节点刚写入 order X，未同步到多数派
// 此时 majority 读取看不到 X，local 读取在主节点能看到 X
// 若主节点立即宕机，X 可能被回滚，majority 读取不会读到它

// 查看副本集当前提交点信息
db.adminCommand({ replSetGetStatus: 1 })
// lastCommittedOpTime 表示多数派提交点
// {
//   "lastCommittedOpTime": { "ts": Timestamp(1800000000, 5), "t": 7 },
//   ...
// }

// Node.js 驱动：开启因果一致性会话
const session = client.startSession({
  causalConsistency: true,
  defaultTransactionOptions: { readConcern: { level: "majority" } }
})

// 会话内先写后读：读操作携带 afterClusterTime，保证读到写入结果
session.withTransaction(async () => {
  await orders.insertOne({ orderNo: "C-1" }, { session })
  const doc = await orders.findOne({ orderNo: "C-1" }, { session })
  // doc 一定可见，即使被路由到副节点
})

// 跨会话传递因果时间戳
const result = await orders.insertOne({ orderNo: "C-2" })
const operationTime = result.operationTime

// 另一个会话读取时带上时间戳，保持因果
const session2 = client.startSession({ causalConsistency: true })
await orders.findOne({ orderNo: "C-2" }, {
  readConcern: { level: "majority", afterClusterTime: operationTime }
})

// 会话中先写后读，切换期间依然保持因果
const result = await orders.insertOne({ orderNo: "C-3" }, { session })
await sleep(50)          // 模拟主节点切换
const doc = await orders.findOne(
  { orderNo: "C-3" },
  { session, readConcern: { level: "majority" } }
)   // 即使切换，因果保证让读取等待到写入可见

// 等级一：日志埋点，w: 0 尽力而为
db.audit_log.insertOne({ event: "click", ts: new Date() }, { writeConcern: { w: 0 } })

// 等级二：普通业务，w: 1 默认，读 secondaryPreferred
db.orders.insertOne({ orderNo: "G-1" })
db.orders.find({ orderNo: "G-1" }).readPref("secondaryPreferred")

// 等级三：核心业务，w: majority + readConcern: majority
db.payments.insertOne(
  { payId: "P-1", amount: 100 },
  { writeConcern: { w: "majority", j: true } }
)
db.payments.find({ payId: "P-1" }, { readConcern: { level: "majority" } })

// 等级四：账务一致，使用事务 + snapshot
session.withTransaction(() => {
  db.accounts.updateOne({ _id: "u_1" }, { $inc: { balance: -100 } }, { session })
  db.accounts.updateOne({ _id: "u_2" }, { $inc: { balance: 100 } }, { session })
})