🏠 总目录📚 本教程 06 · 关系数据库 ← →

AI全栈 / 06

聊天记录放进数据库,怎样避免留下难补的坑?

先决定关系与键,再看索引、迁移、连接池和事务的等待边界。

能区分查询性能问题与数据一致性问题。

核对事务与模型等待

📑 本页目录(点开跳转)

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 学 SQL
c2 待聊
② 按会话编号匹配会话 id = 消息 conversation_id
③ 消息表c1 第 1 条,用户
c1 第 2 条,助手

主键(Primary Key)给每行一个唯一身份。外键(Foreign Key)要求消息引用已存在的会话。两条消息可以引用同一个会话,所以这是一对多关系。每条消息仍有自己的主键,会话内的 seq 另用来排序。SQLite 示例在每条连接上先执行 PRAGMA foreign_keys = ON,再开始事务,以启用外键检查。SQLite 外键文档。

内连接(INNER JOIN)

只交付匹配的行。得到 (c1, 1)、(c1, 2),共两行。

左连接(LEFT JOIN)

还保留左边的 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 和实际配置。

消息、记账等先按一致性、恢复、并发和持久性要求选择;“读多”本身不是改选 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),五个旋钮值得认识:

⭐ 先留其他连接的名额,再给应用进程分配。假设这个库的连接预算是 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 应用并提交 → 在能看到该提交的新读中可见。默认异步,源已提交、某副本已接收、该副本已应用是不同状态;启用半同步后,收到确认只证明相应副本已接收并持久化日志,不等于已应用,更不保证全部读副本同步。

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 数记在每条消息上;那一章讲为什么这几个字段是事后复现一次线上行为的唯一凭据

✅ 检查点

  1. 七类必存数据里,哪三类「事后补不回来」?为什么?
  2. 为什么把整段对话塞进一个 JSON 列,会在并发追加时出错?
  3. messages 为什么要有 seq 列,而不是按 created_at 排序?
  4. 索引把 ORDER BY 的列一起带上好在哪?实测那两个数字是多少?
  5. 迁移器为什么必须幂等?「跑过哪些」记在哪里?
  6. 线上要删掉一列,为什么不能直接 DROP COLUMN?五步法是哪五步?
  7. pool_size 怎么算?单机测好的值搬上线为什么会炸?
  8. 把 LLM 调用包在连接里,实测(池 5 / 并发 40 / LLM 1 秒)是多少对多少?
  9. 为什么左连接结果中有 (c2, NULL)?重写同一个序号失败后,为什么侧边栏的更新时间不会变成 140?
👀 答案
  1. 用量与成本、任务状态、审计日志。它们记的是事件发生那一瞬间的信息,事件过去后原始依据(那次请求的 token 数)就不存在了。
  2. 追加一条要整读 JSON → 改 → 整写回,两个请求读到同一份旧 JSON,后写的把先写的整段覆盖。按条筛选、连接和汇总时,还要使用数据库对 JSON 的支持,设计查询和索引。
  3. 同一秒插入的两条 created_at 可能相同,只按时间戳排就无法确定同秒的先后。seq 明确会话内顺序,UNIQUE (conversation_id, seq) 保证同一会话的序号不重复。业务重试另用操作标识。
  4. 数据库能直接按顺序读索引,不必再在内存里排序(无索引时计划里那句 USE TEMP B-TREE FOR ORDER BY 就消失了)。实测 200 次查询:3.802 秒 → 0.0019 秒。⚠️ 注意它不是 COVERING INDEX——这条查询要读 content,索引里没有,仍要回表;只取索引列(SELECT seq)才会覆盖,200 次 0.0009 秒。
  5. 部署脚本每次启动都调它,不幂等第二次就重复执行 DDL 报错。记在数据库自己的 schema_migrations 表里,否则回答不了「线上这个库跑到第几步」。
  6. 发布是滚动的,旧版本代码还在跑,它引用的列一消失就报错。五步:加新列 → 双写 → 回填 → 读切新列 → 几天后删,核心是每步都兼容新旧两版代码。
  7. 先从数据库连接预算减去其他用途的预留,再除以应用进程数。这里 (100 − 20) ÷ 8 = 10,每池的 pool_size + max_overflow 都算在这 10 个内。8 个进程各用 20 个,单应用就需要 160 个连接,已经超过预算。
  8. 8.15 秒 vs 1.15 秒。池 5、并发 40,包在池里时请求排成 8 批,每批空等一次完整的 1 秒 LLM 调用;挪出去后连接只在毫秒级读写期间被持有。
  9. 左连接保留了没有匹配消息的会话 c2,消息列填 NULL。更新到 140 和插入回复属于同一事务,插入失败后显式回滚,已经提交的值仍是 120。

本节回顾

⚡ 走神救援

⭐ 难点不在选型,在「哪些东西必须在请求发生那一刻写下来」。 用量与成本、任务状态、审计日志补不回来——原始响应体早没了。⭐ 判据:可推导的能晚存,不可推导的必须当场存。

对话按会话与消息拆表后,可以按键关联、按消息筛选和汇总。三个细节:用序号排序(同一秒的时间戳会撞)、模型名按条记(同一会话可换模型)、用唯一约束保护会话内序号。写回复和更新时间可以一起提交或一起回滚。

索引要覆盖热路径,并把排序的列一起带上才不用二次排序。实测同一条「点开会话」的路径,有没有索引差了三个数量级。⚠️ 但别指望覆盖索引——只要读了索引之外的列就仍然要回表。⭐ 看执行计划别猜,也别乱加索引——写入会变慢。

迁移必须有:有序脚本 + 记录表 + 幂等,十几行就能写。⭐ 跑过的迁移永远不回头改。

⚠️ 线上加字段的真风险是锁排队:它要一瞬排他锁,前面卡着长查询它就排队,后来的读写又排在它后面,整张表卡住——所以要设锁超时、抢不到就重试。删列改名走「加新列 → 双写 → 回填 → 切读 → 几天后删」。

💀 连接预算先扣除其他用途的预留,再分给所有进程。每个有限池的峰值要计入额外连接。模型调用放在事务之外,让数据库连接尽快回池。

下一节 👉 06b-列表接口与分页.md

打卡记录保存在你的浏览器里,首页能看到总进度