# 术语表

> 本书常用术语，每条用一到三句话解释，并附上讲解该概念的小节链接。

---

LLMS 索引： [llms.txt](/llms.txt)

---

<span id="basics-chapter-43"></span>

Postgres 的大多数术语都有具体实物所指：页上的一个槽位、元组头里的一个计数器，或表旁边的一个文件。这里的每个词条都链接到用真实输出展示该事物的小节，你可以前去亲眼看看它如何运作。

词头采用统一约定：SQL 命令和关键字用大写（`VACUUM`、`NOT VALID`），配置项、函数及其他标识符保留实际输入时的写法（`work_mem`、`ctid`），其余英文词头仅首词首字母大写。词条按英文字母逐字排序，忽略大小写和标点。

## A {#a}

### ACID {#acid}

事务给出的四项承诺：原子性、一致性、隔离性和持久性。在 Postgres 中，每一项都对应一种可以观察到的具体机制，从提交记录到 fsync。参见[四项承诺，四种机制](/09-acid/#four-promises-four-mechanisms)。

### 咨询锁（Advisory lock） {#advisory-lock}

加在整数键上的锁，键的含义由应用自行定义，用于对行以外的事物实现互斥（例如“每次只运行一个夜间汇总任务”）。优先使用事务级咨询锁，提交时会自动释放。参见[按事务取得咨询锁，而不是按会话取得](/25-concurrency/#take-advisory-locks-per-transaction-not-per-session)。

### ANALYZE {#analyze}

对表进行采样并保存统计信息的命令，规划器据此估算。足够多的行发生变化后，自动清理会运行该命令。参见[ANALYZE 读取样本，而不是整张表](/20-planner/#analyze-reads-a-sample-not-the-table)。

### 异常（Anomaly） {#anomaly}

一种无法由事务按任何先后顺序逐个执行而产生的结果，例如丢失更新或写偏差。隔离级别以其允许哪些异常来定义。参见[只有可串行化能排除所有异常](/09-acid/#only-serializable-rules-out-every-anomaly)。

### 自动清理（Autovacuum） {#autovacuum}

当表的死元组数、插入行数或事务 ID 年龄超过阈值时，对表执行清理和分析的后台工作进程。阈值随表大小增加，因此默认值对大表来说过于迟钝。即使关闭自动清理，它在事务年龄达到 2 亿时强制触发的防回卷清理仍会运行。参见[自动清理会因死行、插入或年龄而触发](/10-vacuum/#autovacuum-fires-on-dead-rows-inserts-or-age)。

## B {#b}

### 后端进程（Backend） {#backend}

Postgres 为每个连接启动的操作系统进程。它解析、规划并执行该会话的查询，保存其状态，不为其他会话服务。参见[每个连接都是一个进程](/28-connections/#every-connection-is-a-process)。

### 基础备份（Base backup） {#base-backup}

通过 `pg_basebackup` 或备份工具，在服务器运行时复制整个数据目录得到的物理副本。还原这一副本，再从备份开始的位置重放归档 WAL，就是物理恢复和时间点恢复的工作方式。参见[数据量大时，只有物理备份恢复得快](/32-backups/#at-size-only-a-physical-backup-restores-fast)。

### 位图扫描（Bitmap scan） {#bitmap-scan}

先从索引收集所有匹配行的地址，再按物理顺序访问堆页、每页只访问一次的扫描方式。超过 `work_mem` 后，位图会变为有损形式，只记录页，不再记录行。参见[索引能帮多少忙，取决于匹配行有多集中](/17-btree/#an-index-helps-only-as-much-as-its-rows-sit-together)。

### 膨胀（Bloat） {#bloat}

表或索引中既不存放存活数据、近期也不会复用的空间，由两次清理之间积累的死元组留下。如果表占用的空间是存活数据大小的五倍，每次扫描就得读取五倍的页。参见[清理释放表内空间，而不是磁盘空间](/06-mvcc/#vacuum-frees-space-inside-the-table-not-on-disk)。

### BM25 {#bm25}

一种相关度评分，将词在文档中的出现频率与其在整个语料库中的稀有程度结合起来衡量。内置排名不具备这一能力；较新的搜索扩展会在索引中保存所需统计信息。参见[搜索扩展把 BM25 放进索引](/23-search/#search-extensions-put-bm25-in-the-index)。

### BRIN {#brin}

块范围索引（Block Range INdex）：为每一段页记录最小值和最大值，就像搬家纸箱上的标签。体积很小；当物理顺序与该列的顺序一致时，效果几乎与 B-树一样好，不一致时则毫无用处。参见[BRIN 为每个页范围保留一份汇总](/18-more-indexes/#brin-keeps-one-summary-per-range-of-pages)。

### B-树（B-tree） {#b-tree}

默认索引：由 8 KB 页组成的浅层有序树，叶子按顺序保存每个键及其行地址。读取三四个页，就能从几百万行中找到一行。参见[B-树是一棵由页组成的浅树](/17-btree/#a-b-tree-is-a-shallow-tree-of-pages)。

### 缓冲区（Buffer） {#buffer}

共享内存中的一个 8 KB 槽位，容纳一个页。每个进程都通过缓冲区读写页，从不直接从文件中读写。参见[shared_buffers 是一个页数组](/05-buffers/#shared_buffers-is-an-array-of-pages)。

### 环形缓冲区（Buffer ring） {#buffer-ring}

大型扫描、清理和批量写入会循环使用的一小组专用缓冲区，让这些操作淘汰自己的页，而不是你的页。在 PostgreSQL 18 中，大型顺序扫描的环形缓冲区大小为 2,304 KB。参见[大型操作会使用环](/05-buffers/#big-operations-get-a-ring)。

### Buffers（执行计划中的字段） {#buffers-in-a-plan}

`explain (analyze)` 中统计节点访问页数的一行：`hit` 表示在共享缓冲区中命中，`read` 表示从下一层读取，此外还有 `dirtied` 和 `written`。与耗时不同，这些计数不会随负载变化，因此是本书的主要证据。参见[缓冲区才是证据](/19-explain/#buffers-are-the-evidence)。

## C {#c}

### 检查点（Checkpoint） {#checkpoint}

定期将所有脏缓冲区写入数据文件并执行 fsync，让崩溃恢复可以从这里开始，而不必从最初的历史开始。参见[检查点为恢复设定上限](/08-wal/#checkpoints-put-a-limit-on-recovery)。

### 检查点进程（Checkpointer） {#checkpointer}

执行检查点的后台进程，将脏缓冲区的写入分散到检查点间隔的大部分时间里（由 `checkpoint_completion_target` 控制，默认值为 0.9）。与它配合的**后台写进程**会赶在时钟扫描之前写出脏缓冲区，因此后端进程很少需要自己写出脏缓冲区。参见[你的查询不该负责写出脏页](/05-buffers/#your-query-shouldnt-be-the-one-writing-dirty-pages)。

### Citus {#citus}

一个开源扩展（AGPL-3.0），将一组 Postgres 服务器组成一个分布式数据库：你连接协调节点，工作节点保存分片，而路由、合并和两阶段提交都在 Postgres 内部处理。参见[Citus 在 PostgreSQL 内部路由与合并](/40-sharding/#citus-routes-and-merges-inside-postgres)。

### 时钟扫描（Clock sweep） {#clock-sweep}

Postgres 选择要淘汰的缓冲区所用的算法：指针循环扫过缓冲区，跳过被钉住的缓冲区，将遇到的使用计数减一，并淘汰遇到的第一个使用计数为零的缓冲区。冷数据的一次扫描无法挤掉热点页。参见[时钟扫描挑选受害者](/05-buffers/#the-clock-sweep-picks-the-victim)。

### 排序规则（Collation） {#collation}

比较和排序文本的规则：`'a'` 是否排在 `'B'` 前面，两种拼写是否相等。每个文本索引都依据某种排序规则建立；如果操作系统升级改变了规则，索引就可能损坏。参见[排序规则决定什么算相等](/12-types/#collations-decide-what-equal-means)。

### 共置（Colocation） {#colocation}

一种分片布局，按相同的键拆分相关表，让同一租户在所有这些表中的行落在同一分片，并就地连接。所有租户都会读取的小表则作为引用表复制到每个节点。参见[分片键就是整个设计的核心](/40-sharding/#the-shard-key-is-the-whole-design)。

### 列式存储（Column store） {#column-store}

将每一列保存在各自的压缩文件中、只读取查询指定列的数据库。它擅长扫描数十亿行，在点查和更新上则处于劣势。参见[行式存储为了用两列，必须读取所有列](/41-limits/#a-row-store-reads-every-column-to-use-two)。

### 协调遗漏（Coordinated omission） {#coordinated-omission}

一种基准测试错误：负载生成器等到缓慢的响应返回后才继续发送请求，因此从未测量那些被停顿延迟的请求。闭环测试天生就有这一问题。参见[闭环会隐藏停顿](/29-benchmarking/#closed-loops-hide-the-stalls)。

### COPY {#copy}

批量加载通道：一条语句以流的方式传送许多行，每行开销远低于逐行插入。其 `freeze` 选项能将已冻结的行写入在同一事务中创建或截断的表。参见[COPY 是批量加载路径](/27-loading/#copy-is-the-bulk-path)。

### 相关性（Correlation） {#correlation}

取值范围为 -1 到 1 的统计量，衡量列值顺序与行的物理顺序有多接近。规划器使用它的平方来估算索引扫描的代价。参见[相关性决定索引扫描的代价](/21-plans/#correlation-prices-the-index-scan)。

### 代价（Cost） {#cost}

规划器对执行计划的估价，使用以顺序读取一个页为基准的自定义单位（`seq_page_cost = 1.0`）。它根据估计行数推算而来，并非耗时。参见[代价是用虚构单位做出的猜测](/19-explain/#cost-is-a-guess-in-made-up-units)。

### 覆盖索引（Covering index） {#covering-index}

包含查询所需全部列的索引，常借助 `include` 实现，从而可以用仅索引扫描完成查询。应覆盖热点查询，而不是所有查询。参见[覆盖索引：覆盖热点查询，而不是每个查询](/17-btree/#covering-indexes-cover-the-hot-query-not-every-query)。

### CREATE INDEX CONCURRENTLY {#create-index-concurrently}

一种不阻塞写入的索引构建方式，代价是两次全表扫描，并等待较早的事务结束。构建失败会留下一个 `INVALID` 索引，查询会忽略它；删除后重试即可。参见[选择与表流量匹配的索引构建方式](/26-migrations/#pick-the-index-build-that-matches-the-tables-traffic)。

### 公用表表达式（CTE） {#cte}

公用表表达式，即 `with` 子句。自 PostgreSQL 12 起，只引用一次的 CTE 会被内联；`materialized` 会强制它单独执行，这可能让外层查询无法利用你的索引。参见[只使用一次的 CTE 会被内联，而不是设栅栏](/22-queries/#a-cte-used-once-is-inlined-not-fenced)。

### ctid {#ctid}

行版本的物理地址，由页号和行指针号组成，例如 `(0,3)`。每张表都有这个隐藏列，每个索引都指向它。参见[行指针让元组移动而不改变地址](/04-storage/#a-line-pointer-lets-a-tuple-move-without-changing-its-address)。

## D {#d}

### 数据校验和（Data checksums） {#data-checksums}

每个数据页上的校验和，让磁盘上的位翻转触发错误，而不是悄悄返回错误的行。自 PostgreSQL 18 起，`initdb` 默认启用。参见[启用校验和后，连读取也会写 WAL](/08-wal/#with-checksums-even-a-read-writes-wal)。

### 死锁（Deadlock） {#deadlock}

两个事务各自等待对方所持有锁的僵局。经过 `deadlock_timeout` 指定的时间后，Postgres 会检测到死锁并中止其中一个事务；解决办法是按一致的顺序获取锁。参见[死锁是顺序错误](/25-concurrency/#deadlocks-are-an-ordering-bug)。

### 死元组（Dead tuple） {#dead-tuple}

任何事务都不可能再看到的行版本：它已被删除或替换，而且早于所有仍在使用的快照。页内剪枝和清理会回收它的空间；在此之前，它仍占用页。参见[只有没有快照能看到的版本才是死版本](/06-mvcc/#a-version-is-dead-only-when-no-snapshot-can-see-it)。

### 去重（Deduplication） {#deduplication}

B-树在 PostgreSQL 13+ 中采用的存储方式：重复键只保存一份，后面跟上拥有该键的各行的倒排列表。它能让外键和状态列上的索引缩小到原来的约三分之一。参见[去重：重复的键只存一次（PostgreSQL 13+）](/17-btree/#deduplication-repeated-keys-are-stored-once-postgresql-13)。

### 脏缓冲区（Dirty buffer） {#dirty-buffer}

在内存中已被修改、尚未写入文件的页。修改已经安全地保存在 WAL 中；检查点进程、后台写进程或需要该缓冲区的后端进程稍后会把它写出。参见[你的查询不该负责写出脏页](/05-buffers/#your-query-shouldnt-be-the-one-writing-dirty-pages)。

### 计算与存储分离（Disaggregated storage） {#disaggregated-storage}

一种托管数据库设计（Aurora、AlloyDB、Neon）：让 Postgres 运行在缓冲区缓存之上，并用根据传来的 WAL 构建页的存储服务替代磁盘。在这些系统中，检查点调优和副本行为都会发生变化。参见[分离式存储改变了部分规则](/34-managed/#disaggregated-storage-changes-some-rules)。

## E {#e}

### 排他约束（Exclusion constraint） {#exclusion-constraint}

唯一约束的推广：不允许任意两行同时满足一组操作符条件，例如“同一房间的任意两条预订时间都不得重叠”。它通过 GiST 索引强制执行。参见[排他约束让重叠变得不可能](/14-relationships/#an-exclusion-constraint-makes-overlaps-impossible)。

### 扩展与收缩（Expand and contract） {#expand-and-contract}

分步发布不兼容模式变更的方法，让新旧代码都能正常运行：先添加新结构，部署使用它的代码，回填数据，再在后续部署中删除旧结构。参见[重命名要用扩展与收缩发布](/26-migrations/#renames-ship-as-expand-and-contract)。

### EXPLAIN {#explain}

显示 Postgres 所选执行计划的命令。单独的 `explain` 只做估算；`explain analyze` 会执行查询，并将实际结果与预测并列显示，因此对写操作应使用事务包裹，并在之后回滚。参见[EXPLAIN 负责猜测；EXPLAIN ANALYZE 负责运行](/19-explain/#explain-guesses-explain-analyze-runs-it)。

### 表达式索引（Expression index） {#expression-index}

基于表达式结果建立的索引，例如 `lower(email)`，为使用完全相同表达式的查询服务。`ANALYZE` 还会收集其统计信息，以修正估算。参见[索引只存储你交给它的值](/17-btree/#an-index-stores-exactly-what-you-gave-it)。

### 扩展统计信息（Extended statistics） {#extended-statistics}

通过 `create statistics` 创建的跨列统计信息，用于规划器“各列相互独立”的假设不成立时。`ndistinct` 修正分组数估算，`mcv` 修正相关列过滤条件的估算。参见[扩展统计信息联合测量多列](/20-planner/#extended-statistics-measure-columns-together)。

### 扩展（Extension） {#extension}

由类型、函数和索引方法组成的包，通过 `create extension` 安装，按版本跟踪管理。托管服务只允许安装其允许列表中的扩展。参见[扩展是数据库跟踪的一个软件包](/16-extensions/#an-extension-is-a-package-the-database-tracks)。

## F {#f}

### 故障切换（Failover） {#failover}

主库故障时，将副本提升为主库。难点在于确认原主库确实已故障，并将其隔离；任何一步没做好，都可能让两台服务器同时接受写入（脑裂），而没有机制能合并两边的数据。应使用专门的工具，不要自行写脚本。参见[一次调用提升副本，开启新时间线](/38-replication/#promotion-takes-one-call-and-starts-a-new-timeline)。

### 填充因子（Fillfactor） {#fillfactor}

一个存储参数，让插入操作在页填满前就停下来，留出空间；对表而言，默认值为 100%。预留空间供更新使用：新版本如果能放在同一页中，就可能实现 HOT 更新。参见[填充因子为更新留下空间](/04-storage/#fillfactor-leaves-room-for-updates)。

### 外键（Foreign key） {#foreign-key}

要求某个值必须存在于另一张表的键中的约束。插入子表记录时，检查父表的代价很低；删除父表记录时，则会扫描子表，除非你自行在引用列上建立索引。参见[外键要从两个方向检查，代价各不相同](/14-relationships/#a-foreign-key-is-checked-both-ways-at-different-prices)。

### 分支文件（Fork） {#fork}

构成一张表的文件之一：`main` 保存行，`_fsm` 保存空闲空间映射，`_vm` 保存可见性映射，不记日志表还会有一个空的 `_init`。参见[表不只有主文件](/04-storage/#a-table-is-more-than-its-main-file)。

### 空闲空间映射（Free space map） {#free-space-map}

一个小型分支文件，粗略记录每个页还有多少空间，让插入和更新可以填充已有页，而不是扩展文件。清理会保持其信息更新。参见[插入无需扫描表也能找到空间](/04-storage/#inserts-find-room-without-scanning-the-table)。

### 冻结（Freezing） {#freezing}

清理过程中的一个步骤：当插入事务足够老时，将元组标记为永久对所有事务可见，使其能跨越事务 ID 回卷。全冻结页以后无需再为冻结而访问。参见[旧行必须在 XID 计数器回卷前被冻结](/06-mvcc/#old-rows-must-be-frozen-before-the-xid-counter-wraps)。

### fsync {#fsync}

强制将已写入的数据落到持久化存储上的系统调用。每次提交都要等待对 WAL 的一次 fsync，因此磁盘的 fsync 延迟决定了提交速率。参见[每次提交都要等待磁盘](/03-latency/#every-commit-waits-for-the-disk)。

### 整页写入（Full-page write） {#full-page-write}

每次检查点之后，页首次修改时记入日志的 8 KB 页镜像，让恢复过程能修复撕裂页（断电时只写了一半的页）。这就是检查点之后 WAL 量会骤增的原因。参见[检查点后的第一次变化会记录整页](/08-wal/#the-first-change-after-a-checkpoint-logs-the-whole-page)。

## G {#g}

### 通用计划（Generic plan） {#generic-plan}

在不知道参数值的情况下，为预备语句生成的执行计划。从第六次执行起，如果它看起来不比定制计划更昂贵，Postgres 就会一直改用它，这可能让原本很快的查询变慢。参见[预备语句运行五次后切换计划](/20-planner/#prepared-statements-switch-plans-after-five-runs)。

### 遗传查询优化器（GEQO） {#geqo}

遗传查询优化器：从连接 12 张表开始（`geqo_threshold`），以随机搜索替代穷举来寻找连接顺序。规划仍然很快；计划追求足够好，而不保证最优。参见[连接顺序是一场搜索，而且搜索会变得昂贵](/21-plans/#join-order-is-a-search-and-searches-get-expensive)。

### GIN {#gin}

通用倒排索引（Generalized Inverted iNdex）：每个不同的元素（`jsonb` 的键、数组标签或词）对应一个条目，记录包含该元素的行，就像书末的索引。参见[GIN 搜索很快，更新很贵](/18-more-indexes/#gin-is-fast-to-search-and-expensive-to-update)。

### GiST {#gist}

通用搜索树（Generalized Search Tree），其条目保存一个边界值，覆盖下层所有内容。它索引的是重叠关系和距离，可用于范围、几何数据、三字符组相似度以及排他约束。参见[GiST 为没有顺序的数据建立索引](/18-more-indexes/#gist-indexes-values-that-have-no-order)。

### 组提交（Group commit） {#group-commit}

一次 WAL 刷新涵盖多个几乎同时提交的事务。Postgres 会自动完成这一点，这也是吞吐量可以超过“每次 fsync 提交一个事务”的原因。参见[许多提交可以共享一次刷新](/08-wal/#many-commits-share-one-flush)。

## H {#h}

### 哈希索引（Hash index） {#hash-index}

保存 32 位哈希码的索引，只支持一个操作符 `=`，大小不取决于键的宽度。对令牌之类的长随机值做等值查询时值得使用；其他情况都用 B-树。参见[哈希索引只有在长键等值查询上才占优](/18-more-indexes/#a-hash-index-wins-only-on-equality-over-long-keys)。

### 哈希连接（Hash join） {#hash-join}

先将内侧输入加载到哈希表，再以流式方式逐条处理外侧输入的连接方式。它是大型无序输入的主力；超过 `work_mem` 乘以 `hash_mem_multiplier` 的内存限额后，会拆成多个批次落盘处理。参见[每种连接方法只适合某些行数](/19-explain/#each-join-method-is-right-only-for-some-row-counts)。

### 堆（Heap） {#heap}

Postgres 的表：一堆无序的页，哪里有空间，行就放在哪里。每个索引，包括主键索引，都通过 ctid 指向堆中的行。参见[行指针让元组移动而不改变地址](/04-storage/#a-line-pointer-lets-a-tuple-move-without-changing-its-address)。

### 提示位（Hint bits） {#hint-bits}

元组上的标志位，缓存相关事务是否已提交，由第一个检查提交日志（`pg_xact`）的读取者设置。设置提示位会弄脏页，因此 `select` 也可能产生写入。参见[读取也可能写入](/06-mvcc/#a-read-can-write)。

### 直方图（Histogram） {#histogram}

即 `histogram_bounds` 统计信息：将列中不属于高频值列表的值分成约 100 个行数相等的桶。规划器据此估算范围过滤条件。参见[pg_stats 是规划器看到的全部信息](/20-planner/#pg_stats-is-the-planners-entire-picture)。

### HNSW {#hnsw}

分层可导航小世界（Hierarchical Navigable Small World），一种近似向量索引：它是分层图，每个向量都与近邻相连，少数向量还位于更稀疏的上层，如同快车停靠站；搜索时以贪心方式沿图行进。参见[HNSW 会贪心地遍历图，也可能漏掉结果](/23-search/#hnsw-walks-a-graph-greedily-and-can-miss)。

### HOT 链（HOT chain） {#hot-chain}

同一行的多个版本，由 HOT 更新通过元组头链接起来，全部位于同一页。索引指向链的第一个槽位；页内剪枝随后会将链头变为重定向行指针。参见[HOT 查找会沿着版本链走，不离开所在页](/07-hot/#a-hot-lookup-follows-the-chain-without-leaving-the-page)。

### HOT 更新（HOT update） {#hot-update}

堆内元组（heap-only tuple）更新：不改动索引列，且新版本能放在同一页中，因此无需通知任何索引。非 HOT 更新（冷更新）则会向每个索引写入一个条目。参见[HOT 需要一次未被索引覆盖的变化，以及页上的空间](/07-hot/#hot-needs-an-unindexed-change-and-room-on-the-page)。

## I {#i}

### 标识列（Identity column） {#identity-column}

由序列填充的整数键，写作 `generated always as identity`，用来替代 `serial`。序列从不回滚，因此出现空号很正常。参见[让数据库为行编号，永远不要相信顺序](/13-keys/#let-the-database-number-rows-and-never-trust-the-order)。

### 事务中空闲（Idle in transaction） {#idle-in-transaction}

开启事务后便不再发出请求的会话，常见于应用等待网络调用时。它仍持有锁和快照，因此清理无法回收被它拖住的旧版本。参见[idle_in_transaction_session_timeout 最重要](/28-connections/#idle_in_transaction_session_timeout-matters-most)。

### 不安全的直接对象引用（IDOR） {#idor}

不安全的直接对象引用（insecure direct object reference）：接口收到什么 ID 就加载什么对象，却不检查调用者是否有权查看。连续递增的 ID 会让这种漏洞轻易遭到利用。参见[计数器是在邀请攻击](/13-keys/#a-counter-is-an-invitation)。

### 仅索引扫描（Index-only scan） {#index-only-scan}

只从索引获取查询所需内容的扫描方式；对可见性映射标记为全可见的每个页，都会跳过堆访问。计划中的 `Heap Fetches` 统计仍然不得不回堆检查的行数。参见[最好的堆页，是你永远不会读到的](/17-btree/#the-best-heap-page-is-the-one-you-never-read)。

### 索引扫描（Index scan） {#index-scan}

读取索引并随即从堆中取出每个匹配行的扫描方式，因此行按索引顺序输出。只取少量行时代价很低；匹配行散布在很多页上时则很昂贵。参见[索引能帮多少忙，取决于匹配行有多集中](/17-btree/#an-index-helps-only-as-much-as-its-rows-sit-together)。

### IOPS {#iops}

每秒 I/O 操作数，与延迟和吞吐量一起作为存储服务的指标出售。预置 IOPS 只是上限：实际能获得的是这个上限与“在途 I/O 数除以延迟”两者中的较小值。参见[IOPS 受在途读取限制，而不是由你付费购买的数量决定](/03-latency/#iops-are-capped-by-reads-in-flight-not-by-what-you-paid)。

### 隔离级别（Isolation level） {#isolation-level}

决定事务能看到其他事务多少工作的设置。读已提交（默认级别）每条语句获取一次快照，可重复读每个事务获取一次快照，可串行化还保证结果等价于某种逐个执行事务的顺序。参见[有目的地选择隔离级别](/25-concurrency/#pick-an-isolation-level-on-purpose)。

### IVFFlat {#ivfflat}

一种近似向量索引，将向量聚成 `lists` 个簇，只搜索离查询向量最近的 `probes` 个簇。默认只探测一个簇是个陷阱：在我们的测试中，recall@10 为 0.636，探测五个簇时则为 1.000。参见[IVFFlat 的默认一次探测是陷阱](/23-search/#ivfflats-default-of-one-probe-is-a-trap)。

## J {#j}

### 即时编译（JIT） {#jit}

将查询表达式即时编译为机器码的机制，在估算代价超过 `jit_above_cost` 时触发。这是基于估算的一次押注：长时间的分析扫描可以获益，短查询则会吃亏。参见[JIT 是规划器根据自身估算下的一次赌注](/21-plans/#jit-is-a-bet-the-planner-places-on-its-own-estimate)。

## K {#k}

### 键集分页（Keyset pagination） {#keyset-pagination}

记住上一页结束位置的分页方式（`where (created_at, id) < ($1, $2)`）。每一页的代价都一样；`offset` 则会读取它跳过的每一行。参见[OFFSET 会读取它跳过的每一行](/22-queries/#offset-reads-every-row-it-skips)。

## L {#l}

### 词素（Lexeme） {#lexeme}

全文搜索所存储的规范化单词：转为小写、提取词干、去除停用词，并保留位置。“The deploys failed” 会变成 `'deploy'` 和 `'fail'`。参见[文本会变成词素](/23-search/#text-becomes-lexemes)。

### 行指针（Line pointer） {#line-pointer}

位于页头部的 4 字节槽位，指向页内更靠后的一个元组。索引指向行指针，因此元组可以在页内移动而不改变地址。参见[行指针让元组移动而不改变地址](/04-storage/#a-line-pointer-lets-a-tuple-move-without-changing-its-address)。

### 锁模式（Lock modes） {#lock-modes}

八种表锁级别，从 `ACCESS SHARE`（每条 `select` 都会获取）到 `ACCESS EXCLUSIVE`（大多数 `alter table` 形式都会获取，连读取也会阻塞）。每条语句都会获取某种锁，因此要问清楚是什么锁、持有多久。参见[八种模式、冲突矩阵，以及每种 DDL 取得了什么锁](/25-concurrency/#basics-25-the-eight-modes-the-conflict-matrix-and-what-each-ddl-took)。

### 锁队列（Lock queue） {#lock-queue}

等待锁的会话队列。如果某个请求与已在等待的请求冲突，就会排到后者后面。因此，一条等待长查询结束的 `alter table` 会阻塞排在它后面的所有查询。参见[一个等待中的锁会阻塞后面的所有人](/25-concurrency/#a-waiting-lock-blocks-everyone-behind-it)。

### lock_timeout {#lock_timeout}

控制语句等待锁多久后报错的设置。设为几秒并配合重试，就能把迁移引起的锁队列停机变成一个无害的错误。参见[规则一：lock_timeout 和重试](/26-migrations/#rule-one-lock_timeout-and-retry)。

### 逻辑解码（Logical decoding） {#logical-decoding}

将 WAL 转换为行变更流的机制，通过逻辑复制槽和输出插件读取。逻辑复制建立在它之上，变更数据捕获工具也是如此。参见[逻辑复制拷贝行，不拷贝页面](/38-replication/#logical-replication-copies-rows-not-pages)。

### 逻辑复制（Logical replication） {#logical-replication}

复制行变更而非页的复制方式：发布端将 WAL 解码为行的插入和更新，由可写的订阅端应用。用于升级、选择性同步以及迁出服务商。参见[逻辑复制拷贝行，不拷贝页面](/38-replication/#logical-replication-copies-rows-not-pages)。

### 丢失更新（Lost update） {#lost-update}

两个事务读取同一个值、各自计算出新值，而第二次写入悄悄覆盖第一次写入的异常。应在 `update` 内完成运算，或先锁住该行。参见[Read committed 会丢失在应用中计算的更新](/25-concurrency/#read-committed-loses-updates-computed-in-the-app)。

### 日志序列号（LSN） {#lsn}

日志序列号（log sequence number）：无限延伸的 WAL 流中的字节偏移，写作 `2/8BE4C8B0` 这样的形式。两个 LSN 相减，就是它们之间的 WAL 字节数。参见[LSN 是字节偏移量](/08-wal/#lsns-are-byte-offsets)。

### 轻量级锁（LWLock） {#lwlock}

保护共享内存、持有时间以微秒计的轻量级锁。大量 `LWLock` 等待意味着太多会话在做同一种内部操作，而不是有人锁住了你的行。参见[解决 LWLock 等待要调整负载，而不是查询](/25-concurrency/#lwlock-waits-are-fixed-in-the-workload-not-the-query)。

## M {#m}

### 物化视图（Materialized view） {#materialized-view}

以表的形式保存的查询结果。普通 `refresh` 执行期间会阻塞读取；`refresh ... concurrently` 不会，但需要唯一索引。两种方式都要重新计算全部结果，因此对持续增长的数据应使用汇总表。参见[物化视图会全部重算](/37-scale/#a-materialized-view-recomputes-everything)。

### 高频值列表（MCV list） {#mcv-list}

列中最常见的值及各自的出现频率（`most_common_vals` 和 `most_common_freqs`）。对于这些值的等值过滤，规划器直接依据列表估算。参见[pg_stats 是规划器看到的全部信息](/20-planner/#pg_stats-is-the-planners-entire-picture)。

### Memoize {#memoize}

一种执行计划节点（PostgreSQL 14+），按连接值缓存嵌套循环的内侧结果，相当于带记忆的嵌套循环。`Hits` 是它省下的查找次数。参见[交叉点、归并连接和 Memoize](/21-plans/#basics-21-the-crossover-the-merge-join-and-the-memoize)。

### 归并连接（Merge join） {#merge-join}

按连接键顺序同时遍历两侧输入的连接方式，就像合并两个有序列表。当两侧通过索引输出、已经有序时，代价很低。参见[每种连接方法只适合某些行数](/19-explain/#each-join-method-is-right-only-for-some-row-counts)。

### 多事务 ID（Multixact） {#multixact}

多个事务同时锁住一行时，写入该行 `xmax` 的 ID，指向持锁者列表。对同一条父表记录并发检查外键，会迅速产生大量多事务 ID；它们也有自己的回卷限制。参见[共享行锁会产生 multixact，而 multixact 也会回卷](/25-concurrency/#shared-row-locks-make-multixacts-and-multixacts-wrap-too)。

### 多版本并发控制（MVCC） {#mvcc}

多版本并发控制（multiversion concurrency control）：在这种设计下，Postgres 从不原地覆盖行，因此读取者无需等待写入者。更新就是插入，膨胀和清理也由此而来。参见[更新就是插入](/06-mvcc/#basics-chapter-6)。

## N {#n}

### N+1 查询（N+1 queries） {#n1-queries}

先用一次查询取列表，再对每个条目分别查询一次的模式，通常藏在 ORM 的循环里。每次查询都很快，但往返开销会累积。用连接或一个数组参数来解决。参见[N+1 是一个循环，不是慢查询](/22-queries/#n1-is-a-loop-not-a-slow-query)。

### 嵌套循环（Nested loop） {#nested-loop}

对外侧每一行都执行一次内侧操作的连接方式。外侧很小、内侧是索引查找时效果很好；外侧行数估错时则会很糟。参见[每种连接方法只适合某些行数](/19-explain/#each-join-method-is-right-only-for-some-row-counts)。

### 网络块存储（Network block storage） {#network-block-storage}

通过网络访问、按 IOPS 和吞吐量计费的云磁盘：持久可靠、可以分离，但每个未命中内存的页都意味着向远端存储服务器发出一次请求。本地 NVMe 快得多，但会随主机丢失。参见[存储决定基准测试结果](/35-providers/#storage-decides-the-benchmark)。

### 节点（Node） {#node}

查询计划中的一个步骤：扫描、连接、排序或聚合，从下层节点拉取行，再向上层传递行。读计划要从缩进最深的节点向外读。参见[计划是一棵树；从里向外读取](/19-explain/#the-plan-is-a-tree-read-it-inside-out)。

### NOT VALID {#not-valid}

添加约束时不检查已有行的选项，只短暂持锁；之后再用 `validate constraint` 在较弱的锁下检查已有行。这是在大表上添加外键和检查约束的安全方式。参见[先添加 NOT VALID 外键，再验证](/26-migrations/#add-foreign-keys-not-valid-then-validate)。

## O {#o}

### 在线事务处理（OLTP） {#oltp}

在线事务处理（online transaction processing）：大量短事务，每个只读写少量行，正是 Postgres 的行式存储和 B-树所针对的负载。分析查询扫描许多行、却只使用少量列，是列式存储占优的场景。参见[行式存储为了用两列，必须读取所有列](/41-limits/#a-row-store-reads-every-column-to-use-two)。

### 操作符类（Operator class） {#operator-class}

索引定义中说明某种类型如何比较、索引能支持哪些操作符的部分。`text_pattern_ops` 让 B-树在语言相关的排序规则下也能支持 `like 'abc%'`；`jsonb_path_ops` 则是用于包含关系查询、体积更小的 GIN 操作符类。参见[前缀查询需要正确的操作符类](/18-more-indexes/#prefix-search-needs-the-right-operator-class)。

### 对象关系映射（ORM） {#orm}

对象关系映射器（object-relational mapper），将对象转换为 SQL 的库。典型应用发送的大部分查询都由它生成，因此要阅读它生成的 SQL：N+1 循环和重写所有列的更新都源于这里。参见[N+1 是一个循环，不是慢查询](/22-queries/#n1-is-a-loop-not-a-slow-query)。

### 操作系统页缓存（OS page cache） {#os-page-cache}

内核利用空闲内存缓存的文件内容，位于 `shared_buffers` 之下的第二层缓存。执行计划中的 `read` 可能只花几微秒就从这里完成，热点页也可能同时存在于两层缓存中（双重缓冲）。参见[一页可能位于三种位置之一](/03-latency/#a-page-lives-in-one-of-three-places)。

### 事务发件箱（Outbox） {#outbox}

与业务变更在同一事务中写入的表，保存应通知其他系统的消息。转发程序发布消息并删除已发送的记录，因此不可能出现提交了业务变更却没有对应消息，或有消息却没有对应提交的情况。参见[把消息和订单放进同一个事务](/09-acid/#put-the-message-in-the-same-transaction-as-the-order)。

## P {#p}

### 页（Page） {#page}

Postgres 读取、写入、缓存和记入日志的 8 KB 单位：页头、从前端排列的行指针、从后端排列的元组，以及两者之间的空闲空间。查询的代价主要取决于它访问多少个页。参见[每个页都有相同的布局](/04-storage/#every-page-has-the-same-layout)。

### 并行查询（Parallel query） {#parallel-query}

将大型扫描或聚合分给 `Gather` 节点下的多个工作进程的执行计划。它让一条查询更早完成，读取的页数却相同，因此消耗的服务器资源更多，而不是更少。参见[并行查询更快，但不更便宜](/19-explain/#parallel-query-is-faster-not-cheaper)。

### 部分索引（Partial index） {#partial-index}

只为满足其 `where` 子句的行建立的索引，例如尚未处理的任务或存活行。它体积小、维护代价低，但查询条件必须蕴含该谓词才能使用。参见[只为要查询的行建索引，而不是整张表](/17-btree/#index-the-rows-you-ask-about-not-the-whole-table)。

### 分区（Partition） {#partition}

分区表的一张子表，保存分区键落在其范围或列表中的行。每个分区都有自己的堆、索引和清理安排，因此执行保留策略时，只需快速删除整张子表。参见[所有收益都来自拆成独立的表](/39-partitioning/#every-benefit-comes-from-separate-tables)。

### 分区剪枝（Partition pruning） {#partition-pruning}

在规划时或执行时跳过不可能包含匹配行的分区的步骤。只有查询按分区键过滤时才会发生。不要与清除单个页内死元组的页内剪枝混淆。参见[分区边界是免费的粗粒度索引](/39-partitioning/#the-bounds-are-a-free-coarse-index)。

### pgbench {#pgbench}

Postgres 自带的基准测试工具。它按你指定的客户端数运行 SQL 脚本，并报告吞吐量和延迟。内置的类 TPC-B 测试主要衡量磁盘的 fsync，因此应编写贴近实际负载的脚本。参见[pgbench 已经安装好了](/29-benchmarking/#pgbench-is-already-installed)。

### PgBouncer {#pgbouncer}

外部连接池：用一个事件驱动的进程，将少量、固定数量的服务器连接借给众多客户端。应与应用自身的连接池配合使用。参见[在应用中并在数据库前面使用连接池](/28-connections/#pool-in-the-app-and-in-front-of-the-database)。

### pg_stat_statements {#pg_stat_statements}

汇总每条规范化语句的调用次数、耗时、行数和页数的扩展。寻找昂贵操作，应从这里开始。参见[从 pg_stat_statements 开始](/31-observability/#start-with-pg_stat_statements)。

### 时间点恢复（PITR） {#pitr}

时间点恢复（point-in-time recovery）：还原基础备份，然后重放归档 WAL（每个 16 MB 段写满后就复制出去），直到误操作发生之前。参见[时间点恢复就是持续重放](/32-backups/#point-in-time-recovery-is-replay-that-keeps-going)。

### 连接池模式（Pooling modes） {#pooling-modes}

连接池借出服务器连接的三种方式。会话池在整个会话期间保留连接。事务池只在事务内保留连接：收益最大，但会破坏 `set` 等会话状态。语句池禁止包含多条语句的事务。参见[事务池模式会破坏会话状态](/28-connections/#transaction-pooling-breaks-session-state)。

### Postmaster {#postmaster}

Postgres 启动的第一个进程，也是所有其他进程的父进程。它监听连接，为每个连接启动一个后端进程，并启动后台进程。要避免它被 OOM 杀手终止。参见[每个连接都是一个进程](/28-connections/#every-connection-is-a-process)。

### 页内剪枝（Pruning） {#pruning}

查询读取一个接近填满的页时，顺手清除页内死元组的操作：代价低，每次只处理一页，不处理索引。完整清理工作由 VACUUM 完成。不要与跳过整个分区的分区剪枝混淆。参见[页接近填满时才进行页内剪枝](/07-hot/#pruning-waits-for-a-nearly-full-page)。

## R {#r}

### Recall@k {#recallk}

真正最近的 k 个邻居中，被近似搜索返回的比例。Recall@10 为 0.9，意味着真正最近的十个邻居返回了九个；近似索引用召回率换速度。参见[ef_search 用延迟换召回率](/23-search/#ef_search-trades-latency-for-recall)。

### 倒数排名融合（Reciprocal rank fusion） {#reciprocal-rank-fusion}

合并评分尺度不同的排名的方法，用于文本与向量的混合搜索：每份返回某文档的列表，都为它贡献 `1 / (60 + rank)` 分，各项之和决定排序。参见[关键词和向量的失败方式不同，所以要融合](/23-search/#keywords-and-vectors-fail-differently-so-fuse-them)。

### 重定向行指针（Redirect） {#redirect}

指向同一页上另一个行指针的行指针，在页内剪枝或清理移除 HOT 链头时留下。索引仍指向旧槽位，由重定向行指针继续转向目标。参见[只有没有快照能看到的版本才是死版本](/06-mvcc/#a-version-is-dead-only-when-no-snapshot-can-see-it)。

### 复制槽（Replication slot） {#replication-slot}

主库记录某个消费者已读取到哪里，并承诺保留它仍然需要的 WAL。废弃的复制槽会一直保留 WAL，直到撑满磁盘。参见[复制槽承诺保留 WAL](/38-replication/#replication-slots-are-a-promise-to-keep-wal)。

### 汇总表（Rollup） {#rollup}

存储聚合结果的表，例如每个账户每天的事件数；新行到来时持续更新，通常通过幂等的插入或更新实现。仪表盘读取汇总表而非原始行：在我们的测试中，只读 4 个页，而不是 35,249 个。参见[预先算好要展示的内容](/37-scale/#precompute-what-you-show)。

### 行级安全（Row-level security） {#row-level-security}

Postgres 添加到针对某张表的每次查询中的策略；策略条件不为真的行无法读取或写入。将租户记录在会话设置中，即使应用忘记了 `where`，策略仍然有效。参见[策略会让其他租户的行不可见](/33-security/#a-policy-makes-other-tenants-rows-invisible)。

### RPO 与 RTO（RPO and RTO） {#rpo-and-rto}

恢复点目标，表示你能容忍丢失多少数据，以时间衡量；恢复时间目标，表示你能容忍多长的停机恢复时间。选择备份方法前，先写下这两项目标。参见[先写下 RPO 和 RTO](/32-backups/#write-down-rpo-and-rto-first)。

## S {#s}

### 可利用索引的（Sargable） {#sargable}

将未经包装的列与扫描前已知的值相比较的谓词，因此可以利用索引。如果给列套上函数或类型转换，索引就帮不上忙了。参见[保持索引列裸露](/22-queries/#keep-the-indexed-column-bare)。

### 保存点（Savepoint） {#savepoint}

事务内一个带名字的位置，可以回滚到这里，而不丢掉整个事务，用于限制单条语句失败造成的影响。保存点内一旦写入，就会分配独立的子事务，因此不要在循环中使用。参见[保存点可以把损害控制住](/25-concurrency/#savepoints-contain-the-damage)。

### search_path {#search_path}

Postgres 查找未限定名称时依次搜索的模式。以所有者权限运行的 `security definer` 函数必须固定它，否则调用者就可能放入一个以函数所有者身份执行的对象。参见[较旧的数据库仍允许任何人在 public 中创建对象](/33-security/#older-databases-still-let-anyone-create-in-public)。

### 选择率（Selectivity） {#selectivity}

规划器预计过滤后会保留的行的比例，依据高频值列表、直方图或兜底估算得出。后续每项选择都建立在它之上。参见[手算规划器的算术](/20-planner/#basics-20-do-the-planners-arithmetic-by-hand)。

### 顺序扫描（Sequential scan） {#sequential-scan}

按物理顺序读取表中每个页，并逐行检查过滤条件的扫描方式。需要表中很大一部分数据时，它是合适的计划；只要少量行时则不合适，此时会表现为 `Seq Scan` 配上很大的 `Rows Removed by Filter`。参见[Filter 表示行已经被读出并丢弃](/19-explain/#filter-means-rows-were-read-and-thrown-away)。

### 可串行化（Serializable） {#serializable}

最严格的隔离级别：结果必须等价于某种逐个执行事务的顺序，否则某个事务会以 SQLSTATE `40001` 失败，由你的代码重试。参见[Serializable 能捕获 repeatable read 漏掉的写偏差](/25-concurrency/#serializable-catches-the-write-skew-repeatable-read-misses)。

### 分片（Shard） {#shard}

由独立主库承载的一部分行。分片键决定每一行存在哪里；查询若没有指定分片键，就会发往每个分片。参见[分片让一切成倍增加](/40-sharding/#sharding-multiplies-everything)。

### shared_buffers {#shared_buffers}

Postgres 在共享内存中维护的页缓存。默认大小为 128 MB；专用服务器可从物理内存的约 25% 起步。参见[shared_buffers 是一个页数组](/05-buffers/#shared_buffers-is-an-array-of-pages)。

### SKIP LOCKED {#skip-locked}

一个行锁选项：遇到其他事务锁住的行时跳过，而不等待。它让多个工作进程可以从同一张队列表领取任务，互不阻塞。参见[Postgres 队列与业务写入一起提交](/25-concurrency/#a-postgres-queue-commits-with-the-business-write)。

### 跳跃扫描（Skip scan） {#skip-scan}

PostgreSQL 18 在未指定多列 B-树首列时使用该索引的方式：首列的每个值各沿树向下查找一次。首列不同值很少时有效，但不要围绕它来做设计。参见[先等值，再范围或排序](/17-btree/#equality-first-then-range-or-sort)。

### 快照（Snapshot） {#snapshot}

在语句或事务开始时，记录哪些事务已经提交。行版本若在快照之前诞生、到那时还没有死亡，就是可见的。参见[一个快照选择一个版本](/06-mvcc/#a-snapshot-picks-one-version)。

### SP-GiST {#sp-gist}

空间分区 GiST（Space-partitioned GiST），适用于能划分为互不重叠区域的数据（前缀、点、IP 网络），搜索因此可以沿树中的一条路径向下进行。参见[你很少会需要 SP-GiST](/18-more-indexes/#youll-rarely-need-sp-gist)。

### 脑裂（Split brain） {#split-brain}

两台服务器同时作为主库接受写入，通常是因为故障切换提升了副本，却没有隔离旧主库。两边的历史会分叉，而且没有机制合并。应使用能隔离旧主库的故障切换管理工具，绝不要自行写脚本。参见[不要自己拼凑故障切换](/38-replication/#dont-hand-roll-failover)。

### 可串行化快照隔离（SSI） {#ssi}

可串行化快照隔离（serializable snapshot isolation），Postgres 实现可串行化的方式：在可重复读的快照上，额外跟踪读写依赖；一旦形成危险的环，就中止一个事务。无需阻塞任何事务，但有事务需要重试。参见[serializable 如何在不阻塞任何人的情况下捕获它](/09-acid/#basics-9-how-serializable-catches-it-without-blocking-anyone)。

### statement_timeout {#statement_timeout}

控制一条语句可以运行多久、超时后即取消的设置。应设得比请求截止时间更短，让已被放弃的工作不再继续持锁。参见[每个超时默认都是关闭的](/28-connections/#every-timeout-defaults-to-off)。

### 流复制（Streaming replication） {#streaming-replication}

备库随主库 WAL 到来而重放，形成逐字节一致、可响应读取的副本（热备库）。默认异步，因此故障切换可能丢失最后几次提交。参见[副本是一台始终处于恢复中的服务器](/38-replication/#a-replica-is-a-server-stuck-in-recovery)。

### 子事务（Subtransaction） {#subtransaction}

保存点或 PL/pgSQL 的 `exception` 块发生写入时取得的事务 ID。每个后端进程缓存 64 个；超过后，可见性检查就要回到磁盘查找。参见[子事务并非没有代价](/25-concurrency/#subtransactions-are-not-free)。

### synchronous_commit {#synchronous_commit}

控制提交要等待什么的设置。设为 off 时，提交会在 WAL 刷新前返回；崩溃可能丢失一个短时间窗口内、其他事务已经见过的事务，但不会造成数据损坏。参见[synchronous_commit = off 会丢失一个窗口](/09-acid/#synchronous_commit--off-loses-a-window)。

### 同步复制（Synchronous replication） {#synchronous-replication}

每次提交都等待备库确认 WAL 的复制方式，因此故障切换不会丢失数据。每次提交都要付出一次网络往返的代价；如果备库不可用，写入就会停止。参见[同步提交要付出一次往返](/38-replication/#synchronous-commit-costs-a-round-trip)。

## T {#t}

### 租户（Tenant） {#tenant}

多租户应用中的一个客户账户，多个客户共用同一批表。本书在每张租户表上都设置 `account_id`，并将它放在键的开头，让查询、行级安全以及将来的分片键保持一致。参见[让租户无处不在](/13-keys/#carry-the-tenant-everywhere)。

### 文本搜索配置（Text search configuration） {#text-search-configuration}

解析器与每种词元所经过的词典的组合，例如 `'english'`。它是索引所存内容的一部分，因此始终应显式传入。参见[配置是索引的一部分](/23-search/#the-configuration-is-part-of-the-index)。

### 时间线（Timeline） {#timeline}

WAL 历史中带编号的分支。每次提升都会开启一条新时间线，WAL 文件名中包含其编号，因此恢复过程和 `pg_rewind` 能分辨一个段属于哪段历史。参见[一次调用提升副本，开启新时间线](/38-replication/#promotion-takes-one-call-and-starts-a-new-timeline)。

### TOAST {#toast}

超长属性存储技术（The Oversized-Attribute Storage Technique）：当一行超过约 2 KB 时，大字段值会被压缩，必要时分块移到附属表中。修改一个经过 TOAST 处理的值，会重写整个值。参见[大值会先压缩，再移出行外](/04-storage/#large-values-are-compressed-then-moved-out-of-the-row)。

### 事务 ID（Transaction ID） {#transaction-id}

事务首次写入时取得的 32 位编号（XID）；只读事务从不取得这一编号。行版本中会记录事务 ID，因此计数器回卷至关重要。参见[每次写入都会取得一个事务 ID](/06-mvcc/#every-write-gets-a-transaction-id)。

### 触发器（Trigger） {#trigger}

表发生变化时，数据库运行的函数：可以在每行变化之前或之后执行，也可以每条语句执行一次。它对每个写入者都会触发，这正是它的意义；行级触发器即使几乎什么也不做，每行也要花费约一微秒。外键同样由触发器强制执行。参见[触发器逐行运行，除非你另有指定](/24-functions/#triggers-run-once-per-row-unless-you-say-otherwise)。

### 三字符组（Trigram） {#trigram}

字符串中连续三个字符组成的序列。`pg_trgm` 扩展通过 GIN 或 GiST 为每个三字符组建立索引，让 `like '%x%'` 和相似度搜索可以利用索引。参见[pg_trgm 让前置通配符也能使用索引](/18-more-indexes/#pg_trgm-makes-a-leading-wildcard-indexable)。

### tsvector {#tsvector}

全文搜索类型：带位置信息、按顺序排列的词素，与 `tsquery` 通过 `@@` 匹配。应将它存入一列，并在该列上建立索引。参见[存储 tsvector；不要索引表达式](/23-search/#store-the-tsvector-dont-index-the-expression)。

### 元组（Tuple） {#tuple}

存储在页上的一个行版本。更新会写入新元组；旧元组会一直保留，直到死亡并被清理。参见[每个页都有相同的布局](/04-storage/#every-page-has-the-same-layout)。

### 元组头（Tuple header） {#tuple-header}

每个元组开头的 23 字节：`xmin`、`xmax`、ctid（自身或更新版本的地址）以及标志位；若有空值位图，则紧随其后。参见[一行的成本高于它的列](/04-storage/#a-row-costs-more-than-its-columns)。

### 两阶段提交（Two-phase commit） {#two-phase-commit}

跨多个数据库的一笔事务：各方先准备，再全部提交。锁会一直持有到第二阶段；如果协调者在两阶段之间故障，就会留下已准备的事务。参见[两阶段提交很少是答案](/09-acid/#two-phase-commit-is-rarely-the-answer)。

### TypeID {#typeid}

带前缀 ID 的一种规范：小写类型前缀、下划线，再接 base32 编码的 UUIDv7，例如 `prj_01j6b7yh69fq2vyabwvmba4nr5`。存储 `uuid`，显示时再带上前缀。参见[前缀让 ID 说明自己的类型](/13-keys/#a-prefix-makes-an-id-say-what-it-is)。

## U {#u}

### ULID {#ulid}

一个 128 位 ID，布局类似 UUIDv7（48 位毫秒时间戳、80 位随机数），没有版本位，以 26 个 Crockford base32 字符表示。它可以逐字节放入 `uuid` 列。参见[ULID 与 uuid 列逐字节匹配](/13-keys/#a-ulid-fits-a-uuid-column-byte-for-byte)。

### 不记日志表（Unlogged table） {#unlogged-table}

不写 WAL 的表：写入便宜得多，崩溃后会被清空，也不会复制。适合暂存和可丢弃的数据。参见[崩溃后，不记日志表会被清空](/15-models/#an-unlogged-table-is-emptied-after-a-crash)。

### 插入或更新（Upsert） {#upsert}

键已存在时改为更新已有行的插入操作，以一条原子语句完成：`insert ... on conflict`。它指定用于裁决冲突的唯一索引，在并发下也是安全的。参见[ON CONFLICT 是安全的插入或更新](/22-queries/#on-conflict-is-the-safe-upsert)。

### UUIDv4 {#uuidv4}

包含 122 个随机位的 UUID。随机键可能落到 B-树的任何位置；在我们的测试中，100 万个这样的键写出了 551 MB WAL，而 UUIDv7 为 143 MB。参见[UUIDv4 隐藏创建时间，但 WAL 是 3.8 倍](/13-keys/#uuidv4-hides-creation-time-at-38-times-the-wal)。

### UUIDv7 {#uuidv7}

以 48 位毫秒时间戳开头的 UUID，因此新键落在索引最右端。自 PostgreSQL 18 起内置 `uuidv7()`；它会暴露行的创建时间。参见[UUIDv7 是默认选择，而且会泄露创建时间](/13-keys/#uuidv7-is-the-default-and-it-reveals-creation-time)。

## V {#v}

### VACUUM {#vacuum}

维护命令，用于移除死元组及其索引条目、记录空闲空间、截断尾部空页、冻结旧元组，并维护可见性映射。它让空间可以复用，很少会缩小文件。参见[清理要做五件事](/10-vacuum/#vacuum-does-five-jobs)。

### VACUUM FULL {#vacuum-full}

将表重写为一个新的紧凑文件的命令，在整个运行期间持有 `ACCESS EXCLUSIVE`。应安排维护窗口，或使用在线重建工具。参见[大表执行 VACUUM FULL 会造成停机](/10-vacuum/#vacuum-full-is-an-outage-on-a-big-table)。

### 可见性映射（Visibility map） {#visibility-map}

每个堆页对应两个位：全可见和全冻结。仅索引扫描和清理依据它们跳过页；对页的任何修改都会清除它们。参见[每页两位让扫描和清理跳过工作](/04-storage/#two-bits-per-page-let-scans-and-vacuum-skip-work)。

### 易变性（Volatility） {#volatility}

函数向规划器给出的承诺：`immutable`、`stable` 或 `volatile`（默认值）。错误地声明为 `immutable` 会返回过时的结果。参见[易变性是给规划器的承诺](/24-functions/#volatility-is-a-promise-to-the-planner)。

## W {#w}

### 等待事件（Wait event） {#wait-event}

`pg_stat_activity` 中显示的会话正在等待的对象：`Lock`、`LWLock`、`IO` 或 `Client`。对这些事件采样，就能了解时间花在哪里。参见[没有等待事件的活动会话正在占用 CPU](/31-observability/#an-active-session-with-no-wait-event-is-on-a-cpu)。

### 预写式日志（WAL） {#wal}

预写式日志（write-ahead log）：在写入数据页之前，先将每次变更作为紧凑记录追加进去。提交只需等待日志；恢复、复制和时间点恢复都通过重放它完成。参见[先写日志，而不是写数据页](/08-wal/#write-the-log-not-the-pages)。

### 工作集（Working set） {#working-set}

负载在某段时间（例如一小时）内访问的页：是实际使用的那部分，而非整个数据库。应按工作集配置内存，超过它再加内存也没有收益。参见[根据工作集配置 RAM](/03-latency/#size-ram-to-the-working-set)。

### work_mem {#work_mem}

一个排序或哈希节点在溢写到临时文件之前可以使用的内存，默认 4 MB。它按节点、按连接分别计算，因此调高前先算乘法。参见[work_mem 是按节点计算的，而且可以看到](/05-buffers/#work_mem-is-per-node-and-you-can-see-it)。

### 回卷（Wraparound） {#wraparound}

32 位事务 ID 计数器转过一整圈、追上未冻结行的时刻，旧行会突然看起来像来自未来。Postgres 会在此之前停止接受写入，因此冻结必须跟上。参见[回卷会在任何内容损坏前停止写入](/10-vacuum/#wraparound-stops-writes-before-anything-is-corrupted)。

### 写偏差（Write skew） {#write-skew}

两个事务读取相同数据、各自修改不同的行，合起来却破坏了一条各自单独执行时都不会破坏的规则的异常。只有可串行化级别能捕获它。参见[Serializable 能捕获 repeatable read 漏掉的写偏差](/25-concurrency/#serializable-catches-the-write-skew-repeatable-read-misses)。

## X {#x}

### xmin 与 xmax {#xmin-and-xmax}

每个元组头中的两个事务 ID：`xmin` 插入了这个版本；`xmax` 删除、替换或锁住了它（均未发生时为 0）。将它们与快照对照，就能决定谁能看到这行。参见[每次写入都会取得一个事务 ID](/06-mvcc/#every-write-gets-a-transaction-id)。

### xmin 清理界限（xmin horizon） {#xmin-horizon}

仍在使用的最老快照。早于它死亡的版本可以移除，其余必须保留。因此，一笔长事务会拖住整个数据库的清理；复制槽则会拖住整个集簇的清理。参见[长事务会把一切都拖住](/06-mvcc/#long-transactions-hold-everything-back)。