📑 本页目录(点开跳转)
06 · 关系数据库
⏱ 42 分钟 | ⭐ 「要存什么」比「用哪个数据库」重要一百倍
🎯 一句话
难点不在选型,在于「哪些东西必须在请求发生的那一刻就写下来」——错过了永远补不回来。 Postgres 还是 MySQL 五分钟能定;漏掉一列 token 数,三个月后你算不出这个功能挣不挣钱。
🧩 一、先把清单列全
| 存什么 | 干什么用 | 事后能补吗 |
|---|---|---|
| 用户 | 谁在用、配额多少 | 能 |
| 会话 conversations | 侧边栏那个列表 | 能 |
| 消息 messages | 对话正文,下一轮靠它拼上下文 | 能 |
| ⭐ 用量与成本 | 每条回复花了多少钱 | ❌ 不能 |
| 上传的文件 | 文件在对象存储,元数据在库里 | 半能 |
| 任务状态 | pending / running / done / failed | ❌ 不能 |
| ⭐ 审计日志 | 谁在什么时候调了哪个模型 | ❌ 不能 |
⚠️ 右边那一列才是重点。 会话标题忘了存,明天加一列就有了;token 数当时没记,那条请求的成本永远是未知数——原始响应体早就不在了。
⭐ 判据:可推导的能晚点存,不可推导的必须当场存。 用量、成本、状态变更、审计,都是「事件过去就消失」的东西。
🧩 二、对话为什么是两张表,不是一张 JSON
最省事的做法是把消息塞进一个 JSON 列。若应用先读整段、在内存追加、再写回,两个请求可能读到同一个旧版本,后写的覆盖先写的。把常用字段放到消息表后,查一条消息或按用户汇总用量,可以直接按列筛选、连接和求和。支持 JSON 的数据库也能查询其中的内容,代价取决于查询、更新方式和索引。
-- SQLite 专用建表例(原环境已实跑);迁移 PostgreSQL 需另改方言与数据语义
PRAGMA foreign_keys = ON;
CREATE TABLE conversations (
id TEXT PRIMARY KEY NOT NULL, user_id TEXT NOT NULL, title TEXT,
created_at INTEGER NOT NULL,
updated_at INTEGER NOT NULL); -- ⭐ 列表页按它倒序,不是 created_at
CREATE TABLE messages (
id INTEGER PRIMARY KEY AUTOINCREMENT,
conversation_id TEXT NOT NULL REFERENCES conversations(id),
seq INTEGER NOT NULL, -- ⭐ 会话内序号,别拿时间戳当顺序
role TEXT NOT NULL, content TEXT NOT NULL,
model TEXT, -- ⭐ 哪个模型生成的,按条记
input_tokens INTEGER, output_tokens INTEGER,
cost_usd REAL, -- ⭐ 当场算好,别指望以后回补
created_at INTEGER NOT NULL,
UNIQUE (conversation_id, seq)); -- ⭐ 同一会话内,一个序号只允许一条消息
两张关联表的逻辑设计可复用,建表 SQL 不能只换类型名就迁移。上例是 SQLite:INTEGER PRIMARY KEY AUTOINCREMENT 是 SQLite 的自增语法与历史 ROWID 策略;PostgreSQL 18 可按需求改用 BIGINT GENERATED BY DEFAULT AS IDENTITY PRIMARY KEY 等定义,语义并非逐字等价。若把 TEXT 会话键改为 uuid,还要迁移/校验实际键值;把 INTEGER 时间改为 timestamptz,也要明确原时间单位和时区转换。约束、默认值、已有数据与索引均须按目标方言单独验证。有了两表关系,「这个用户这个月花了多少」才适合用 SUM 加 JOIN 查询。
方言依据:SQLite AUTOINCREMENT、PostgreSQL 18 CREATE TABLE / IDENTITY。本轮核了文档语法与 SQLite 内存例,未运行 PostgreSQL 服务;不再宣称原脚本只改类型即可运行。
⭐ 三个容易漏的设计:用 seq 而不是靠时间戳排序(同一秒插两条,created_at 可能相同,顺序就随机了);model 记在消息上而不是会话上(用户中途换模型是常态,成本要按条算);UNIQUE (conversation_id, seq)——交给数据库禁止同一会话里出现两条同序号的消息。业务重试还需要稳定的操作标识,后面的事务练习会对照这两个职责。
💡 JSON 列适合装「你不打算查询的东西」:原始响应体、工具调用参数快照。判据是你会不会
WHERE它、SUM它,会就单独开列。
点开会话时,两张表怎样对上
侧边栏里有 c1「学 SQL」和 c2「待聊」。只有 c1 已经收到两条消息。现在要给消息显示所属会话,也要能列出暂时没有消息的会话。
c1 学 SQLc2 待聊id = 消息 conversation_idc1 第 1 条,用户c1 第 2 条,助手主键(Primary Key)给每行一个唯一身份。外键(Foreign Key)要求消息引用已存在的会话。两条消息可以引用同一个会话,所以这是一对多关系。每条消息仍有自己的主键,会话内的 seq 另用来排序。SQLite 示例在每条连接上先执行 PRAGMA foreign_keys = ON,再开始事务,以启用外键检查。SQLite 外键文档。
只交付匹配的行。得到 (c1, 1)、(c1, 2),共两行。
还保留左边的 c2,得到第三行 (c2, NULL)。NULL 表示这一行没有匹配到消息,消息表里没有新增记录。
连接条件写在 ON c.id = m.conversation_id。因为 c1 命中两条,结果里出现两次 c1。侧边栏若要求每个会话只显示一次,可以直接查会话表。两个结果都能在本章事务练习中跑出。更多连接规则见SQL 02 · JOIN 的几种语义。
可选深入:两张表之外,主键、金额与依赖怎么约定?
唯一标识与业务顺序分开
单库自增键不自动解决多节点发号。随机 UUIDv4 的碰撞概率可很低,但不是严格无碰撞证明,数据库仍用唯一约束兜底;UUIDv7 把毫秒时间放在高位,改善时间排序,仍不等于跨节点真实发生顺序。若用时间戳+节点号+序列,时钟回拨、同刻序列耗尽、节点号重用和重启后丢失状态都须有处理策略,不能默默重复发号。消息内的 seq 仍按会话原子分配并用唯一约束裁决;ID 不代替它。依据:RFC 9562 的状态、排序与唯一性边界。
cost_usd 的 REAL 是估算口径
原例 REAL 适合成本看板的近似估算,不应直接当结算账本。精确金额可用受支持的 DECIMAL(p,s),或约定币种和尺度的最小计量单位整数;USD 的细粒度模型成本未必适合只记“分”。还要约定单次/汇总何时舍入、舍入模式、税费/汇率与溢出上限。DECIMAL 也有精度和尺度限制,不能凭名字假定无限精度。
from decimal import Decimal, ROUND_HALF_UP
estimate = 0.1 + 0.2
exact = Decimal("0.1") + Decimal("0.2")
assert estimate != 0.3 and exact == Decimal("0.3")
amount = Decimal("0.0000015")
rounded = amount.quantize(Decimal("0.000001"), rounding=ROUND_HALF_UP)
units = int(rounded * 1_000_000) # teaching policy: USD, scale=6
assert units == 2
print("本例舍入后USD百万分之一单位:", units)
上例选定的六位小数与 HALF_UP 只是测试政策,不是任何币种/供应商结算规范。入库仍需核对驱动如何绑定 Decimal,不能先转 float 再声称保住十进制精度。依据:MySQL 8.4 精确 DECIMAL。
两张表怎样减少更新异常
在本例“会话只属于一个用户”的设计下,会话 id → user_id、title;消息 id(或唯一的 conversation_id+seq)→ role、content。1NF 要求关系模型所选域中的单值属性,不能把“用了 JSON”直接等同违反它。若在每条消息重复会话 title,复合候选键的一部分 conversation_id 就决定 title,是 2NF 要避免的部分依赖;若以单列消息 id 为键,再重复会话的 user_id,就出现经 conversation_id 的传递依赖,是 3NF 要避免的一类冗余。
拆成当前两表后,改会话标题只需改一处。为性能有意重复字段也可以,但要指定权威来源、更新事务与修复办法;范式不是“任何冗余都禁用”。这只解释现有键与更新动机,不作为任意业务模式已经达到全部范式的证明。参考:Microsoft 的范式与更新异常说明;以上函数依赖是对本例业务约定的分析,须由规则而不是数据巧合成立。
🧩 三、索引:哪两个查询会先慢
读请求高度集中在两条路径:打开侧边栏(这个用户的会话,按最近更新倒序取 20 条)、点开会话(这个会话的消息,按 seq 升序)。缺少合适的索引访问路径时可能要扫描;最终仍以计划为准。
实测(SQLite 内存库塞 40 万行消息、随机分给 2 万个会话,查的就是上面那条「点开会话」路径——SELECT role, content FROM messages WHERE conversation_id=? ORDER BY seq,重复 200 次;你的数值会不同,但量级差异是结构性的):
| 执行计划 | 200 次查询共 | |
|---|---|---|
| 无索引 | SCAN messages + USE TEMP B-TREE FOR ORDER BY |
3.802 秒 |
建 (conversation_id, seq) |
SEARCH … USING INDEX |
0.0019 秒 |
⭐ 索引要把 ORDER BY 的列也带上。只建 (conversation_id) 也能命中,但排序还得在内存里做——无索引那行计划里的 USE TEMP B-TREE FOR ORDER BY 就是它;两列一起建,数据库直接按顺序读出来,那句就没了。同理会话列表要的是 (user_id, updated_at DESC)。
💡
COVERING INDEX(连回表都省掉)是另一回事,别指望它:只有你要的列全在索引里时才会出现。上面这条查询要读content,索引里没有,所以仍要回表,计划是SEARCH … USING INDEX。把它换成SELECT seq FROM …(只取索引列)计划才变成SEARCH … USING COVERING INDEX,同样 200 次 0.0009 秒。⚠️ 别为了凑覆盖索引把content塞进索引——那等于把整张表再复制一遍。
⚠️ 看执行计划,别猜(SQLite EXPLAIN QUERY PLAN,Postgres EXPLAIN (ANALYZE, BUFFERS)),大表上出现 SCAN / Seq Scan 就是信号。也别把索引当免费——每个索引都让写入变慢、占空间,索引数量按实际查询负载、写入维护与空间预算决定,不靠固定“两三个”判断。
可选深入:这些索引为什么有效——结构、前缀与回表
先分清存储引擎:它是 MySQL 负责表数据存取的组件。这里只比较本章相关的三种;MySQL 8.4 默认是 InnoDB,实例可用引擎与当前默认仍看 SHOW ENGINES 和实际配置。
- InnoDB:支持事务、崩溃恢复与外键,行数据在聚簇索引中;记录级锁有利于并发,但不意味着任意语句只锁一行。
- MyISAM:不支持事务和外键,数据与索引分开存放,主要用表级锁;不能用它替代 InnoDB 的事务恢复保证。
- MEMORY:数据在内存、重启会丢,使用表级锁,可选 HASH/BTREE,不提供事务与外键。
消息、记账等先按一致性、恢复、并发和持久性要求选择;“读多”本身不是改选 MyISAM 的充分理由。依据:MySQL 8.4 存储引擎。
先把分类维度拆开
索引是帮助定位记录的额外访问结构,也会增加存储与写入维护。下面几类不是互斥选项:同一个索引可以同时是唯一、复合、二级、B+ 树。
| 维度 | 在回答什么 | 本章例子 |
|---|---|---|
| 约束 | 是否承担主键身份、是否拒绝重复键 | PRIMARY KEY(id)、UNIQUE(conversation_id, seq) |
| 键列 | 单列还是按多列组合定位 | (conversation_id, seq) 是复合键,列顺序有意义 |
| 数据组织 | 叶记录是整行还是指向整行的定位信息 | 下文限定 MySQL 8.4 / InnoDB 的聚簇与二级索引 |
| 访问结构 | 有序树还是哈希等结构 | InnoDB 普通索引使用 B+ 树;MEMORY 引擎才有可选 HASH / BTREE 的语境 |
同一个查询,三种结构各擅长什么?
以找 (c1,2)、取 c1 的 seq≥2、按 seq 顺序读为例:
| 结构 | 等值 | 范围 / 顺序 | 成本要看哪一层 |
|---|---|---|---|
| 哈希 | 可直接算桶,平均查找常说 O(1),冲突与负载会改变代价 | 桶不保键序,不能据此直接给范围或 ORDER BY | 哈希、冲突、取记录;平均复杂度不是固定一次磁盘读取 |
| B+ 树 | 按分隔键逐层选子页,到叶层定位键 | 定位起点后沿有序叶层继续读相邻键 | 一个页含多个分隔键、扇出大,层数约随 logFN 增长;缓存命中时不必每层都读盘 |
| 红黑树 | 平衡二叉树,最坏查找 O(log N) | 也能有序遍历和范围查找 | 二叉指针节点的内存访问与数据库页访问不是同一个成本模型;不能只比较 O(log N) 就断言谁更快 |
这里先解释 B+ 树为何适合页式存储:内部页提供路标,叶层保存索引记录;示意路径为“根分隔键 → 选中子页 → 叶层定位 (c1,2) → 继续读 c1 的后续 seq”。真实树高、扇出与 I/O 还受键宽、页大小、缓存和数据量影响。InnoDB 自适应哈希是引擎优化机制,不等于能把普通用户索引随意声明成 HASH。
三层容量只做模型手算:把根、内部、叶计为三层,假设前两层平均各有 F 个子页、每叶平均 L 条记录,则约为 F × F × L 条。取 F=1000、L=100,得 1 亿条;换 F=100、L=100,就只有 100 万条。F/L 来自页可用空间、键/指针或行宽与填充率,聚簇叶和二级叶不同;这不是 MySQL 固定容量,也不是 I/O、内存或吞吐保证。
缓存影响页成本,怎样观察?
MySQL 8.4 / InnoDB 的 buffer pool 缓存数据页和索引页;连接池复用的是连接。监控时在同一实例、同一时间窗取 Innodb_buffer_pool_read_requests(逻辑读)与 Innodb_buffer_pool_reads(未由池满足、需磁盘读取)的增量。
合法区间内,用 1 − Δ未命中 / Δ逻辑读 估算读命中率:100 次增量、2 次未命中 → 98%,只是手算。零分母、重启/重置、负增量或未命中大于请求等异常区间标为不可比,不报 100%。同时看 I/O 延迟、脏页/等待、预读及未访问即淘汰的页、代表查询;这个页读比率不是查询命中比例或总设备 I/O,高比率也不自动说明健康或应该扩内存。依据:官方计数定义。未采集真实实例。
叶记录里有什么,决定要不要再找整行
以下仅为 MySQL 8.4 / InnoDB 示意,不是把上面的 SQLite 实验换名:假设 messages 的主键为 id,另建 (conversation_id, seq)。
| 位置 | 符号化记录 | 读取路径 |
|---|---|---|
| 二级索引叶层 | (c1,1) → id=7;(c1,2) → id=11;(c2,1) → id=20 | 按复合键定位;二级记录也带主键值 |
| 主键聚簇叶层 | id=11 → 这一行的 role/content/… | 需要二级索引不含的列时,再按主键找整行,即这里说的回表 |
| 覆盖读取 | 只需 conversation_id、seq 或已包含的 id | 所需数据均可从该索引取得时,可以省去上述整行查找;覆盖是查询与索引的关系,不是另一种树 |
InnoDB 有显式主键时用它作聚簇索引;没有时会选择合适的非空唯一索引,再不满足才生成隐藏键。SQLite 普通 rowid 表、WITHOUT ROWID 表与 PostgreSQL 的行定位机制各有规则,不套用这张 InnoDB 表。
把层级接起来:一行 → 聚簇叶记录 → 索引页 → 表空间及其文件。二级叶保存索引键和主键定位信息,不是所有列的副本。InnoDB 索引页默认 16 KiB,实际由实例页大小配置决定;表空间可只放一张表,也可容纳多表,不能认定一表必一文件。这只是组织示意,未解析磁盘页。依据:索引物理组织、表空间。
最左前缀来自字典序,不是背口诀
(conversation_id, seq) 先按会话排,再在同一会话内排 seq。固定 c1 后取 seq≥2 是一段连续键;只给 seq=2,则会散落在不同会话段。下面只手算键序:
keys = [("c2", 1), ("c1", 3), ("c1", 1), ("c2", 2), ("c1", 2)]
ordered = sorted(keys)
assert ordered == [("c1", 1), ("c1", 2), ("c1", 3), ("c2", 1), ("c2", 2)]
assert [k for k in ordered if k[0] == "c1" and k[1] >= 2] == [("c1", 2), ("c1", 3)]
assert [k for k in ordered if k[1] == 2] == [("c1", 2), ("c2", 2)]
所以 WHERE conversation_id=? ORDER BY seq 有匹配的有序访问机会;若首列是跨多个会话的范围,结果就不自动按全局 seq 排序。缺首列条件也不等于引擎绝不能扫描这个索引或选择其他优化路径;是否选择、是否另排序仍看目标版本的成本与计划。等值前缀、后续范围、排序方向/规则要一起判断。
依据:MySQL 8.4 聚簇与二级索引、页与索引物理结构、B-tree / Hash、复合索引;红黑树的高度与操作界。这些结构说明和手算不构成 MySQL 实测。
🧩 四、Schema 演进:迁移不是可选项
AI 产品的字段是天天加的:今天加 reasoning_tokens,明天加 cache_read_tokens。所以第一天就得回答:线上那个库怎么知道自己该长什么样? 答案是把每次结构变更写成一个带名字的脚本,把「跑过哪些」记在数据库自己里:
import sqlite3
MIGRATIONS = [("001_init", "CREATE TABLE m (id INTEGER PRIMARY KEY, body TEXT)"),
("002_add_cost", "ALTER TABLE m ADD COLUMN cost_usd REAL")] # ⭐ 只往末尾追加
db = sqlite3.connect(":memory:")
db.execute("CREATE TABLE IF NOT EXISTS schema_migrations (name TEXT PRIMARY KEY)")
for _ in range(2): # ⭐ 连跑两遍:第二遍什么也不会发生,这就是幂等
done = {r[0] for r in db.execute("SELECT name FROM schema_migrations")}
for name, sql in MIGRATIONS:
if name in done: continue
db.execute(sql) # 改结构
db.execute("INSERT INTO schema_migrations VALUES (?)", (name,)) # ⭐ 同一步记账
db.commit(); print("applied", name)
print([r[1] for r in db.execute("PRAGMA table_info(m)")])
Alembic 之类的成品就是这个形状:有序脚本 + 一张记录表 + 幂等(部署脚本每次启动都调它,不幂等第二次就报错)。⚠️ 跑过的迁移永远不能回头改——别的库早就按旧版本执行完了。
💀 不用迁移的下场:有人本地手改了一列,没写进任何脚本。三个月后新同事按 README 建库,报
column does not exist;线上能跑只是因为那一台机器的库被手改过——此时谁也说不出线上库的真实结构。
⚠️ 上线中的表怎么加字段而不锁死
以下是 Postgres 行为(🗓️ 未实跑,需要真实 Postgres;细节随大版本变,动手前查你那版文档):
| 操作 | 危险在哪 | 怎么做 |
|---|---|---|
ADD COLUMN 可空 / 常量默认值 |
现代 Postgres 是元数据操作,不重写表 | ✅ 基本安全 |
| ⚠️ 锁排队 | 它仍要一瞬排他锁。前面卡着一个跑了 10 分钟的大查询,你的 ALTER 排队等,后来的读写又排在你后面,整张表不可用 | ⭐ SET lock_timeout='3s',抢不到就重试,别无限等 |
| 建索引 | 普通 CREATE INDEX 阻塞写入 |
CREATE INDEX CONCURRENTLY(⚠️ 不能在事务块里,失败会留下无效索引) |
| ⚠️ 删列 / 改列名 | 最危险:滚动发布期间旧代码还在跑,它引用的列没了 | ⭐ 扩展—收缩:①加新列 ②双写 ③回填 ④读切新列 ⑤几天后再删旧列 |
⭐ 通用规则:迁移和发布要能各自单独回滚,做法就是让每一步都同时兼容新旧两版代码——这是五步法存在的全部理由。
可选深入:扩展—收缩搬到 MySQL,哪些前提要重新核?
在线算法不等于零等待
上方是 PostgreSQL 场景,不能直接承诺 MySQL 无停机。MySQL 8.4 / InnoDB 要逐操作核对 INSTANT、INPLACE 或 COPY 的支持条件;列变更、索引、外键、表格式与版本可能改变可选算法。要求 ALGORITHM=INSTANT 可在不支持时失败,不能靠省略算法允许自动选择后再称“确认无重建”。LOCK=NONE 也只适用于允许的操作,不表示完全没有元数据锁。
先扩展兼容 schema → 发布能同时兼容新旧结构的代码 → 限速回填与核对 → 切读写 → 等旧代码退出后收缩。上线前在相同版本和表条件下测锁等待、长事务、磁盘空间与副本延迟,设置可控超时/回退;备份恢复也另验。“无停机”是服务层目标,不能由 SQLite 例或一条 ALTER 保证。依据:MySQL 8.4 Online DDL 限制。本轮没有执行 MySQL/PostgreSQL 在线迁移。
“索引重构”先问对象和原因:更新统计、重建二级索引、重建聚簇表是不同工作,ANALYZE TABLE 不等于物理重建。按“核对象/原因 → 同版本核备份恢复、空间和长事务 → 核算法与锁 → 受控执行 → 核定义、数据、计划与负载”走。MySQL 8.4 普通 InnoDB 的 OPTIMIZE TABLE 可映射为表重建,但 COPY、FULLTEXT 等条件会改变在线能力;不能套通用 REPAIR 或先删主键。源题若未指定引擎,其他实现仍另核。这里只文档核对,未执行维护命令。依据:重建方法、OPTIMIZE 条件。
回填一张已有表的部分行/列:下面仅为 MySQL 8.4 文档型写法。目标 target_rows 是 (1,旧A)、(2,旧B)、(3,旧C);源 source_rows 的 (id,label,apply_flag) 是 (1,新A,1)、(2,新B,0)、(4,新D,1)。两表 id 唯一,先用相同 JOIN/WHERE 做 SELECT 预览主键;只应更新 id=1,2 未通过筛选、3 未匹配。
UPDATE target_rows AS t JOIN source_rows AS s ON s.id=t.id
SET t.label=s.label
WHERE s.apply_flag=1 AND s.label IS NOT NULL
AND t.id>=1 AND t.id<4;本例明确跳过源 NULL,未匹配目标保持;源键重复先拒绝,不能任取一行。更新已有行与用 INSERT ... SELECT 新增行分开;生产回填在短事务中按有界主键区间分批,多表 UPDATE 不支持直接套 ORDER BY/LIMIT。这里只手核三行与语法文档,未运行 MySQL。
🧩 五、连接池:并发一上来就崩的那个配置
Postgres 每个连接是一个进程,几百个就能把内存吃光,所以应用侧要复用固定数量的连接。
以 SQLAlchemy 异步引擎为例(🗓️ 未实跑,需要 Postgres + asyncpg),五个旋钮值得认识:
pool_size:本例池中可保留的连接数上限,按需创建,不预建。max_overflow:峰值临时再开几个。- ⭐
pool_timeout:等不到就报错。无限等 = 请求全挂住,比报错难查得多。 pool_recycle:按连接创建以来的年龄,在超过阈值后的下次借出(checkout)时使其失效并替换;不是后台闲置计时器,也不收回已借出的连接。- ⭐
pool_pre_ping:借出前 ping 一下,别拿到已经死掉的连接。
⭐ 先留其他连接的名额,再给应用进程分配。假设这个库的连接预算是 100 个,后台任务、运维和预留空间合计 20 个。两台应用机器各有 4 个进程,共 2 × 4 = 8 个。若每个进程有一个相同的池,就给每池最多 (100 − 20) ÷ 8 = 10 个并发连接。SQLAlchemy 的有限池要把 pool_size 和 max_overflow 相加,例如 8 + 2 = 10。满载核算是 8 × 10 + 20 = 100 个。SQLAlchemy 连接池上限。
⚠️ 两个真实翻车点:忘了乘进程数(单机测试 pool_size=20 很舒服,上线开 8 个 worker 就可能用到 160 个连接,还没计额外连接,超过上述预算);以及 ⭐ 池小不是错,池小 + 占着不放才是错——真正的容量瓶颈几乎总是持有时长。
以上连接池复用通道,与前面的 InnoDB 页缓存不同;回收参数不保证永不断连或固定吞吐。依据:SQLAlchemy 2.0 回收机制。
连接复用不等于复制路由:写池 → 权威 source;允许陈旧结果的读池 → 健康 replica。复制先建立,由数据访问层或支持相应语义的代理路由,不按 SQL 首词盲分。事务和写后必须见新值的读留在权威节点,或先确认副本已应用所需提交;收到日志不等于已应用。监控延迟、摘除失效副本并重新发现节点,各读写池仍按所有 worker 合算连接预算。路由本身不提供自动复制、零延迟或高可用;未运行复制服务。依据:MySQL 读扩展。
路由之前的复制路径(MySQL 8.4):source binlog → replica receiver 接收并写 relay log → applier 应用并提交 → 在能看到该提交的新读中可见。默认异步,源已提交、某副本已接收、该副本已应用是不同状态;启用半同步后,收到确认只证明相应副本已接收并持久化日志,不等于已应用,更不保证全部读副本同步。
- 接收落后:查连接、receiver 状态/错误及接收进度,再定位网络或源端发送等原因。
- 已接收但应用落后:查 applier/worker 错误与应用进度,再看工作负载、大事务、锁等待及资源瓶颈,按原因处理。
Seconds_Behind_Source=0 不是所需提交已可见的充分证明。沿用上面的权威读,或核验所需提交已应用、在合适读视图中读取,并设置等待超时/降级;这会付出延迟、权威节点负载或可用性成本。摘除坏副本、改变读路由只是缓解旧读,不等于修好积压原因;不靠固定 sleep、一键调线程或跳错承诺零延迟。依据:复制线程、进度与状态、半同步确认。未运行复制服务。
🧩 六、事务边界:⚠️ 别把 LLM 调用包在事务里
事务先划一个本地提交/回滚单元:例如下面的“写 assistant 消息+记账+更新 updated_at”。原子性要求这组操作共同成功或撤回;一致性仍靠业务约束维护合法状态;隔离性按所选级别约束并发可见性;耐久性取决于引擎、提交配置与存储兑现。借着一个连接不等于已经开启事务,LLM 和对象存储调用也不自动加入它。
这是 AI 应用最常见也最贵的数据库错误。 写法非常自然:开事务 → 写用户消息 → 调 LLM → 写回复 → 提交,「要么都成功要么都失败,多干净」。问题是中间那步要三秒到三十秒,这整段时间里一个连接被占着什么也没干:
import asyncio, time
POOL, N, LLM, DB = 5, 40, 1.0, 0.005 # 真实世界一次 LLM 调用常是 3–30 秒
async def bad(sem):
async with sem: # ⚠️ 连接从头占到尾
await asyncio.sleep(DB + LLM + DB)
async def good(sem):
async with sem: await asyncio.sleep(DB) # ⭐ 读完立刻还回去
await asyncio.sleep(LLM) # ⭐ LLM 调用在池外
async with sem: await asyncio.sleep(DB) # ⭐ 写的时候再借一次
async def main():
for name, fn in (("包在池里", bad), ("池外调用", good)):
sem = asyncio.Semaphore(POOL); t = time.perf_counter() # 信号量当连接池
await asyncio.gather(*(fn(sem) for _ in range(N)))
print(f"{name}: {N} 个请求耗时 {time.perf_counter()-t:.2f}s")
asyncio.run(main())
实测输出:包在池里: 8.15s / 池外调用: 1.15s。池只有 5、并发 40,请求被迫排成 8 批,每批空等一次完整的 LLM 调用。池大小一个字没改,只是把外部调用挪出了持有区间。
⭐ 判据:事务里只放数据库自己的操作,而且必须是快操作。 任何网络调用(LLM、对象存储、第三方 API)都在事务之外。
用户消息可以先单独提交。模型调用失败时,按本次操作记录 failed,让用户能看见失败并决定是否重试。模型返回后,再用短事务一起保存助手回复、当前已知的用量和会话更新时间。
⚠️ 同源的坑:别在 SELECT ... FOR UPDATE 之后调外部服务——那不只占着连接,是攥着一把行锁,别的请求会卡死在那些行上。
回复写入失败后,侧边栏该显示什么
沿用上面的 c1。用户的第 1 条消息已经提交。模型在事务外生成回复,得到演示用量 5 个输出 token。应用准备把会话更新时间从第 100 秒改到第 120 秒,并保存第 2 条消息及用量。列表时间和回复应一起生效,否则列表可能显示刚更新过,点进去却没有新回复。
用 Python 3.11 或以上运行下例。它在内存 SQLite 里创建两张简化表。为聚焦事务,消息表省略上文独立的消息 id,保留 (conversation_id, seq) 的唯一约束。snapshot 按会话汇总 (更新时间, 消息条数, 输出 token 数)。? 是给数据库驱动绑定参数的占位符。时间、序号与用量是演示输入,例子不调用模型,也不结算真实费用。
import sqlite3
from contextlib import closing
def persist_reply(db, seq, updated_at):
db.execute("BEGIN")
try:
# 先更新列表时间,后插入回复。第二步失败时,第一步也要撤回。
db.execute("UPDATE conversations SET updated_at=? WHERE id=?", (updated_at, "c1"))
db.execute(
"INSERT INTO messages VALUES (?, ?, ?, ?, ?)",
("c1", seq, "assistant", "按会话编号连接", 5),
)
db.execute("COMMIT")
except sqlite3.Error:
if db.in_transaction:
db.execute("ROLLBACK")
raise
def snapshot(db):
return db.execute("""
SELECT c.updated_at, COUNT(m.seq), SUM(m.output_tokens)
FROM conversations AS c JOIN messages AS m ON c.id = m.conversation_id
WHERE c.id = ?
GROUP BY c.id, c.updated_at
""", ("c1",)).fetchone()
with closing(sqlite3.connect(":memory:", isolation_level=None)) as db:
db.executescript("""
PRAGMA foreign_keys = ON;
CREATE TABLE conversations (
id TEXT PRIMARY KEY NOT NULL, updated_at INTEGER NOT NULL
);
CREATE TABLE messages (
conversation_id TEXT NOT NULL REFERENCES conversations(id),
seq INTEGER NOT NULL,
role TEXT NOT NULL,
content TEXT NOT NULL,
output_tokens INTEGER NOT NULL,
UNIQUE (conversation_id, seq)
);
INSERT INTO conversations VALUES ('c1', 100), ('c2', 100);
INSERT INTO messages VALUES ('c1', 1, 'user', '怎样读会话?', 0);
""")
assert snapshot(db) == (100, 1, 0)
persist_reply(db, seq=2, updated_at=120)
committed = snapshot(db)
assert committed == (120, 2, 5)
print("提交后:", committed)
try:
persist_reply(db, seq=2, updated_at=140)
except sqlite3.IntegrityError as exc:
assert exc.sqlite_errorname == "SQLITE_CONSTRAINT_UNIQUE"
else:
raise AssertionError("重复序号应该被拒绝")
assert not db.in_transaction and snapshot(db) == committed
print("重复序号后:", snapshot(db))
try:
db.execute("INSERT INTO messages VALUES (?, 1, 'user', '测试', 0)", ("c3",))
except sqlite3.IntegrityError as exc:
assert exc.sqlite_errorname == "SQLITE_CONSTRAINT_FOREIGNKEY"
else:
raise AssertionError("缺少父会话的消息应该被拒绝")
print("缺少会话的消息: FOREIGN KEY 拒绝")
for kind in ("INNER", "LEFT"):
rows = db.execute(f"""
SELECT c.id, m.seq
FROM conversations AS c {kind} JOIN messages AS m
ON c.id = m.conversation_id
ORDER BY c.id, m.seq
""").fetchall()
expected = [("c1", 1), ("c1", 2)]
if kind == "LEFT":
expected.append(("c2", None))
assert rows == expected
print(f"{kind}:", rows)
先看 (100, 1, 0)。提交后,时间是 120,消息有 1 + 1 = 2 条,输出量是 0 + 5 = 5 个 token,所以结果为 (120, 2, 5)。再试着写相同的第 2 条,更新时间先改成 140,但消息写入触发唯一约束。代码回滚后还是 (120, 2, 5),原先提交的用户消息和回复仍在。
SQLite 对本例的唯一约束错误默认只撤销失败的语句,前面的更新仍在事务中,应用必须决定回滚。PostgreSQL 的事务块出错后,通常要回滚事务,或回滚到事先建立的保存点,才能继续处理。SQLite 冲突处理 · PostgreSQL 事务教程。
遇到重复序号,只能确认该会话的序号已占用。相同业务操作要靠稳定的请求号查结果,不能因为超时就重新分配序号或重新调模型。模型请求也可能在本地回滚之前就产生费用,应按第 12 章的尝试号和对账规则处理。需要在后台恢复、重试或补报状态时,接第 11 章 · 长任务与队列。
并发时:先辨异常与隔离,再看锁等待
下面是同一个 A 事务内的条件轨迹,不是两次分页请求,也不是已在所有引擎运行的结果:
| 现象 | 最短轨迹(实现/级别允许时) |
|---|---|
| 脏读 | B 写 120 尚未提交,A 读到 120,B 随后回滚 |
| 不可重复读 | A 读同一行得 100;B 改成 120 并提交;A 再读得 120 |
| 幻读 | A 按谓词得 2 行;B 插入匹配行并提交;A 重查同一集合变 3 行 |
| 业务读改写丢失更新 | A 要加 10、B 要加 20,却都先读 100;A 写 110 并提交,B 仍按旧值写 120 并提交,没得到预期 130。是否允许须按级别、锁或版本校验判断 |
标准级别规定最低禁用现象,实现可以更强:RU(读未提交)未禁止脏读;RC(读已提交)禁止脏读;RR(可重复读)再禁止不可重复读,但规范仍允许幻读;Serializable 要求成功事务效果等价某一串行次序,不是必须物理排队。丢失更新另看实际读改写方式,不能列成每个级别都必然发生。
MySQL 8.4 / InnoDB 默认 RR,其普通一致读复用事务快照,RC 则每次一致读取新快照;锁定读按访问路径和隔离条件加锁,不能混作一个幻读矩阵。PostgreSQL 18 默认 RC,RU 实际映射 RC,RR 也不允许幻读,但仍可能有序列化异常;默认与运行设置分清。依据:InnoDB 隔离、PostgreSQL 隔离。未运行这些双会话轨迹。
把普通一致读接到 undo:MySQL 8.4 / InnoDB 用 Read View 筛选版本可见性:视图前已提交的版本可见,当时活跃或后来事务的版本不会因随后提交就自动进入旧视图,自己的写入另有可见性规则。当前版本不可见时,可沿 undo 重构可见旧版本;Read View 是可见性边界,不是复制整库数据,也不是把事务 ID 与当前时钟简单比较。
同一行的文档型轨迹:x 已提交为 10;B 写 20 未提交时,A 首次普通一致读建视图,仍读 10。B 提交后,RR 中 A 复用旧视图再读仍为 10;若这条轨迹从开始就选 RC,A 下一次普通一致读的新视图可见 20。A 自己再写 30 后能读到 30,不意味着其他行也刷新到新快照。锁定读沿下方锁规则另看;没有 MVCC 仍可用锁等机制实现隔离,读写阻塞与并发代价不同,并非没有事务。依据:多版本与 undo、一致读。未运行双会话。
锁粒度回答范围,S/X 回答兼容:表级冲突面大;记录级可提高不同行并发,却有锁管理成本,也不等于任意语句只锁一行。以下只看 InnoDB 同一记录、不同事务的请求:
| 已持有 ↓ / 新请求 → | S 共享 | X 排它 |
|---|---|---|
| S | 可共享 | 等待 |
| X | 等待 | 等待 |
普通非锁定一致读可读版本,不因该 X 锁就一律阻塞;间隙锁、意向锁及其他数据库的元数据锁不能套这张表。依据:InnoDB 锁。
模式、对象范围与层级分开分类:记录锁落在索引记录,gap 锁保护索引间隙,next-key 是记录加其前间隙。以 InnoDB 表 t(k PRIMARY KEY) 已有 10、20、30 为文档型夹具:RR 中 A 按 k 做 WHERE k>10 AND k<30 FOR UPDATE,扫描范围的 gap/next-key 可让 B 插入 15 等待;完整唯一键 k=20 命中现有行时,只需相应记录锁,不锁其前间隙。后者不能套给部分复合唯一键或未命中;完整锁集合还要核语句、隔离级别与实际访问路径,不能只按 WHERE 字面推断。
这是锁定读对照,普通一致读不自动套 X 锁阻塞规则。RC 通常不为查询扫描加 gap 锁,外键/重复键检查仍有例外;gap 锁之间可以共存,不能套前面的记录 S/X 表。事务结束释放相应锁,与 RC 筛去不匹配记录可提前释放等语句级行为要分清;等待本身不会释放已持锁,异常回滚范围沿用下文说明。以上均未做真实锁测试。依据:锁范围、语句加锁边界。
表级 IS/IX 声明记录 S/X 需求,协调表与行的层级:IX 与 IX 可并存,整表 S 与 IX 冲突。表意向 IX 不等于 INSERT 的插入意向 gap 锁;DDL 的 MDL 元数据锁又是另一类。自增分配按官方模式边界另核,这里不展开完整内部锁名录。
死锁是等待成环:A 持有行 1 等行 2,B 持有行 2 又等行 1;只有一方等待长事务还不是这个环。统一访问顺序、缩短事务和合适索引可降低风险。InnoDB 死锁回滚整个事务,应用按幂等业务操作、有限次数与退避重试整个事务;锁等待超时默认只回滚当前语句,是否整事务回滚另核配置。未知提交结果仍先查账;这里未执行挂死或真实锁测试。依据:错误回滚范围、死锁处理。
可选深入:批量写入先少掉的是提交次数
同样 300 行,逐条提交与单事务比较
import sqlite3
from time import perf_counter
rows = [(i, "message") for i in range(300)]
results = []
for batched in (False, True):
db = sqlite3.connect(":memory:", isolation_level=None)
db.execute("CREATE TABLE m(id INTEGER PRIMARY KEY, content TEXT)")
statements = []
db.set_trace_callback(statements.append)
start = perf_counter()
if batched:
db.execute("BEGIN")
db.executemany("INSERT INTO m VALUES(?,?)", rows)
db.execute("COMMIT")
else:
for row in rows:
db.execute("BEGIN")
db.execute("INSERT INTO m VALUES(?,?)", row)
db.execute("COMMIT")
elapsed = perf_counter() - start
assert db.execute("SELECT * FROM m ORDER BY id").fetchall() == rows
commits = sum(sql == "COMMIT" for sql in statements)
assert commits == (1 if batched else len(rows))
results.append(("batch" if batched else "per-row", commits, elapsed))
db.close()
print("模式/提交次数/本次秒数:", results)
本地内存 SQLite 没有数据库网络往返,也没有本例磁盘同步成本;这里核对了相同结果与 300→1 次提交,耗时不设倍数断言。executemany 在 Python sqlite3 中是重复执行参数化 DML,不等于一条多行 INSERT,更不保证所有客户端都只需一次网络往返;远端效果要按驱动/协议测。
生产写入按行数/字节/耗时限定批次,避免一个无限事务占锁和撑大日志。中途失败按事务状态回滚,重试使用唯一业务键/幂等标识;网络超时可能是已提交但回复丢失,要查账确认,不能直接整批再插。依据:Python sqlite3 executemany / 事务。
提交成本背后的三个职责(MySQL 8.4 / InnoDB 文档说明):
| 日志 | 主要职责,不能互换 |
|---|---|
| redo | 记录数据页相关修改,供崩溃恢复重放 |
| undo | 提供回滚及一致读所需的旧信息 |
| server binlog | 变更事件供复制、备份后的时间点回放 |
WAL 的落盘偏序是对应 redo 持久化 → 该脏页写入数据文件;内存页先修改不违背它。写 log buffer、交给 OS 写文件、同步到可靠存储是不同阶段。提交确认后的耐久性还要核 innodb_flush_log_at_trx_commit、sync_binlog 与硬件同步保证。原 SQLite 内存例只核 300→1 次提交,不验证这些落盘过程或性能倍数。依据:MySQL redo、undo、binlog。
可选深入:把短事务应用到有限库存抽奖
概率、参与资格与库存是三道约束
场景约束明确为千万用户规模、每次合法参与抽样概率 1%、奖品库存 1000、每用户有参与次数上限 K。题目未给 K 的具体数字,这里保留为配置;小例取 K=2 只为验证边界。1% 是抽样规则,不保证有限批次恰好 1% 中,也不保证库存耗尽后仍能兑现每个命中;“未命中”和“命中但库存耗尽”分开返回。千万用户只是规模要求,下面没有作吞吐压测。
先从可信登录身份取得用户,不能让请求随意指定他人 uid。以“活动+请求号”记录幂等结果,并绑定用户与请求内容;每用户参与计数也按活动隔离。一个短事务内裁决资格/次数、条件扣库存、保存结果与唯一发奖意图。外部发奖留到提交后,禁止把远端调用塞进事务。下面只模拟单活动,SQLite BEGIN IMMEDIATE 串行化写事务;移到 MySQL/PostgreSQL 必须重新实现并验证并发条件。
import secrets, sqlite3
db = sqlite3.connect(":memory:", isolation_level=None)
db.executescript("""
CREATE TABLE stock(left_count INTEGER NOT NULL CHECK(left_count>=0));
INSERT INTO stock VALUES(1000);
CREATE TABLE usage(uid TEXT PRIMARY KEY, used INTEGER NOT NULL);
CREATE TABLE requests(req TEXT PRIMARY KEY, uid TEXT NOT NULL, result TEXT NOT NULL);
CREATE TABLE outbox(req TEXT PRIMARY KEY REFERENCES requests(req));
""")
K = 2 # test configuration, not an asserted question fact
def participate(uid, req, *, fixture_roll=None, fail=False):
db.execute("BEGIN IMMEDIATE")
try:
old = db.execute("SELECT uid,result FROM requests WHERE req=?", (req,)).fetchone()
if old:
if old[0] != uid:
raise ValueError("idempotency key belongs to another user")
db.execute("COMMIT")
return old[1]
db.execute("INSERT OR IGNORE INTO usage VALUES(?,0)", (uid,))
accepted = db.execute("UPDATE usage SET used=used+1 WHERE uid=? AND used<?", (uid,K)).rowcount
result = "limit"
if accepted:
roll = secrets.randbelow(100) if fixture_roll is None else fixture_roll
if not 0 <= roll < 100:
raise ValueError("roll out of range")
result = "lose"
if roll == 0:
changed = db.execute("UPDATE stock SET left_count=left_count-1 WHERE left_count>0").rowcount
result = "win" if changed else "empty"
db.execute("INSERT INTO requests VALUES(?,?,?)", (req,uid,result))
if result == "win":
db.execute("INSERT INTO outbox VALUES(?)", (req,))
if fail:
raise RuntimeError("before commit")
db.execute("COMMIT")
return result
except BaseException:
if db.in_transaction:
db.execute("ROLLBACK")
raise
assert participate("a","a1",fixture_roll=0) == "win"
assert participate("a","a1",fixture_roll=99) == "win" # no redraw
assert participate("a","a2",fixture_roll=99) == "lose"
assert participate("a","a3",fixture_roll=0) == "limit"
try:
participate("b","b1",fixture_roll=0,fail=True)
except RuntimeError:
pass
assert db.execute("SELECT used FROM usage WHERE uid='b'").fetchone() is None
assert db.execute("SELECT left_count FROM stock").fetchone() == (999,)
for i in range(1000): # forced-hit boundary test, not 1% probability evidence
participate(str(i),"req"+str(i),fixture_roll=0)
assert db.execute("SELECT left_count FROM stock").fetchone() == (0,)
assert db.execute("SELECT COUNT(*) FROM outbox").fetchone() == (1000,)
assert db.execute("SELECT COUNT(*) FROM requests WHERE result='empty'").fetchone() == (1,)
print("重复不重抽;限额生效;失败回滚;发奖意图1000、库存0")
db.close()
强制命中的测试输入只验证库存不为负、意图数不超过 1000,与随机抽样是否合格无关;真正抽样使用服务端随机源,结果和事务重试政策须固定。若提交响应超时,先按请求号查询已记录结果,再决定恢复,不能重新抽。发奖 worker 以请求号向支持幂等/查单的下游发放,保存状态并对失败重试或人工对账;队列可能重复投递,若下游不支持幂等或查单,就不能声称已解决未知结果下的恰好一次。流程接到 长任务与队列,不在此扩成活动平台。
跨进程与目标数据库的并发压力、身份系统、消息投递和真实发奖都未执行;这里验证的是本地事务状态轨迹。SQLite 事务依据:BEGIN IMMEDIATE / 事务。
🌐 换个栈怎么对应
| 概念 | Python(本板块) | Node | Go |
|---|---|---|---|
| 迁移工具 | Alembic | Prisma Migrate / Drizzle Kit / node-pg-migrate | golang-migrate / goose / Atlas |
| 查询层 | SQLAlchemy 2.0(async) | Prisma / Drizzle / Knex | pgx(+ sqlc 生成代码)/ GORM |
| 连接池 | create_async_engine(pool_size=…) |
pg 的 Pool({ max }) |
pgxpool 的 MaxConns |
| 事务 | async with session.begin(): |
prisma.$transaction([...]) |
tx, _ := pool.Begin(ctx) |
| 池默认值 | 5(+ overflow 10) | 10 | max(4, CPU 核数) |
⭐ 执行计划三家都是同一句 EXPLAIN ANALYZE —— 这是数据库的能力,跟语言无关。
⭐ 三个生态的迁移工具都长成「有序脚本 + 一张记录表」,连接池都有个「最大连接数」旋钮。换栈要重学的只有语法。(🗓️ 包名会变,用前先查。)
🔗 这一章连到哪里
| 去哪 | 为什么 |
|---|---|
| 07-向量检索落地.md | 下一章直接建在这一章的表上——向量不是另开一个系统,是给这张库再加一列。本章的 JOIN 和事务能力在那里会变成直接红利 |
| 11-长任务与队列.md | ⭐ 第一节清单里「任务状态」那一行到那一章才落成表:jobs 表 + 一条原子认领语句。那条语句能成立,靠的正是本章的事务 |
| 12-限流配额与成本护栏.md | ⭐ 本章逼你把 model / token 数 / cost_usd 按条记下来,那一章就是花这笔数据:配额扣减是「一个账本 + 一条带条件的 UPDATE」,成本归因要 user / feature / model 三个维度——当时没记,那里就查不出来 |
| 15-可观测性.md | 成本看板不是新建一套系统,就是把本章记的这几列按三个维度切开看。⭐ 那一章的口径是「记钱,不要只记 token」——所以本章的 cost_usd 要当场算好 |
| ⭐ 06b · 列表接口与分页 | 本章建了 messages 表、加了 seq 列、建好了 (conversation_id, seq) 索引 —— 正好差最后一步:这张表怎么往外分页。⚠️ OFFSET 有两个必死的坑(深翻页越翻越慢、翻页途中有插入会重复和漏项),而 AI 应用恰恰是「你翻着历史,新消息还在往里写」 |
| 数据这一关 19 · 隐私、脱敏与留存 | 你刚设计的 messages 存的是用户原话。存多久、能不能拿去训练、删除请求怎么落到行上——建表时就该定,不是出事后再补 |
| 模型上线之后 17 · 版本、回溯与可复现 | 本章让你把 model 和 token 数记在每条消息上;那一章讲为什么这几个字段是事后复现一次线上行为的唯一凭据 |
✅ 检查点
- 七类必存数据里,哪三类「事后补不回来」?为什么?
- 为什么把整段对话塞进一个 JSON 列,会在并发追加时出错?
messages为什么要有seq列,而不是按created_at排序?- 索引把
ORDER BY的列一起带上好在哪?实测那两个数字是多少? - 迁移器为什么必须幂等?「跑过哪些」记在哪里?
- 线上要删掉一列,为什么不能直接
DROP COLUMN?五步法是哪五步? pool_size怎么算?单机测好的值搬上线为什么会炸?- 把 LLM 调用包在连接里,实测(池 5 / 并发 40 / LLM 1 秒)是多少对多少?
- 为什么左连接结果中有
(c2, NULL)?重写同一个序号失败后,为什么侧边栏的更新时间不会变成 140?
👀 答案
- 用量与成本、任务状态、审计日志。它们记的是事件发生那一瞬间的信息,事件过去后原始依据(那次请求的 token 数)就不存在了。
- 追加一条要整读 JSON → 改 → 整写回,两个请求读到同一份旧 JSON,后写的把先写的整段覆盖。按条筛选、连接和汇总时,还要使用数据库对 JSON 的支持,设计查询和索引。
- 同一秒插入的两条
created_at可能相同,只按时间戳排就无法确定同秒的先后。seq明确会话内顺序,UNIQUE (conversation_id, seq)保证同一会话的序号不重复。业务重试另用操作标识。 - 数据库能直接按顺序读索引,不必再在内存里排序(无索引时计划里那句
USE TEMP B-TREE FOR ORDER BY就消失了)。实测 200 次查询:3.802 秒 → 0.0019 秒。⚠️ 注意它不是COVERING INDEX——这条查询要读content,索引里没有,仍要回表;只取索引列(SELECT seq)才会覆盖,200 次 0.0009 秒。 - 部署脚本每次启动都调它,不幂等第二次就重复执行 DDL 报错。记在数据库自己的
schema_migrations表里,否则回答不了「线上这个库跑到第几步」。 - 发布是滚动的,旧版本代码还在跑,它引用的列一消失就报错。五步:加新列 → 双写 → 回填 → 读切新列 → 几天后删,核心是每步都兼容新旧两版代码。
- 先从数据库连接预算减去其他用途的预留,再除以应用进程数。这里
(100 − 20) ÷ 8 = 10,每池的pool_size + max_overflow都算在这 10 个内。8 个进程各用 20 个,单应用就需要 160 个连接,已经超过预算。 - 8.15 秒 vs 1.15 秒。池 5、并发 40,包在池里时请求排成 8 批,每批空等一次完整的 1 秒 LLM 调用;挪出去后连接只在毫秒级读写期间被持有。
- 左连接保留了没有匹配消息的会话
c2,消息列填NULL。更新到 140 和插入回复属于同一事务,插入失败后显式回滚,已经提交的值仍是 120。
本节回顾
⚡ 走神救援
⭐ 难点不在选型,在「哪些东西必须在请求发生那一刻写下来」。 用量与成本、任务状态、审计日志补不回来——原始响应体早没了。⭐ 判据:可推导的能晚存,不可推导的必须当场存。
对话按会话与消息拆表后,可以按键关联、按消息筛选和汇总。三个细节:用序号排序(同一秒的时间戳会撞)、模型名按条记(同一会话可换模型)、用唯一约束保护会话内序号。写回复和更新时间可以一起提交或一起回滚。
索引要覆盖热路径,并把排序的列一起带上才不用二次排序。实测同一条「点开会话」的路径,有没有索引差了三个数量级。⚠️ 但别指望覆盖索引——只要读了索引之外的列就仍然要回表。⭐ 看执行计划别猜,也别乱加索引——写入会变慢。
迁移必须有:有序脚本 + 记录表 + 幂等,十几行就能写。⭐ 跑过的迁移永远不回头改。
⚠️ 线上加字段的真风险是锁排队:它要一瞬排他锁,前面卡着长查询它就排队,后来的读写又排在它后面,整张表卡住——所以要设锁超时、抢不到就重试。删列改名走「加新列 → 双写 → 回填 → 切读 → 几天后删」。
💀 连接预算先扣除其他用途的预留,再分给所有进程。每个有限池的峰值要计入额外连接。模型调用放在事务之外,让数据库连接尽快回池。
下一节 👉 06b-列表接口与分页.md