PostgreSQL 19 深度实战：当关系数据库遇见图查询、时态操作与在线重组织——从SQL/PGQ属性图到并行自动清理、原子UPSERT的生产级完全指南（2026）

作者: 程序员茄子
日期: 2026-06-17
字数: 约15000字
适用人群: 数据库架构师、后端工程师、运维工程师、技术决策者

序言：为什么 PostgreSQL 19 是近年来最重磅的版本

如果我告诉你，2026年最值得关注的数据库发布不是某个商业新秀，也不是某款分布式NewSQL，而是世界上最成熟的开源关系数据库的下一个大版本——你可能会觉得我在夸大其词。

但数据不会说谎：

• SQL/PGQ 属性图查询：PostgreSQL 19 原生支持 ISO/IEC 9075-16:2023 标准的图查询语法，意味着你不再需要为了图遍历去维护一套独立的图数据库（Neo4j、Nebula Graph 等），也不用通过复杂的递归CTE去模拟图查询。
• ON CONFLICT DO SELECT：这个从 PostgreSQL 9.5（2015年）开始就被社区疯狂请求的"原子获取或创建"语义，终于在19版本落地。它彻底解决了UPSERT场景下的死元组问题。
• FOR PORTION OF 时态操作：PostgreSQL 18 引入了 WITHOUT OVERLAPS 时态约束，19 版本补全了 UPDATE/DELETE 的时态语法，完成了对 SQL:2011 时态功能集的完整支持。
• REPACK CONCURRENTLY：在线表重组织，不再需要 VACUUM FULL 的长时间排他锁。
• 并行自动清理：多索引并行处理，大型表的VACUUM时间可以缩短数倍。
• pg_plan_advice：PostgreSQL 历史上第一个官方查询计划提示机制。

这些特性每一个拿出来都能单独写一篇深度文章。而它们同时出现在同一个版本中，使得 PostgreSQL 19 成为近期历史上功能最丰富、对开发者最友好、对运维最友好的里程碑版本。

本文将从架构原理、代码实战、性能基准、生产部署四个维度，对 PostgreSQL 19 的核心新特性进行完全解读。

第一章：SQL/PGQ 属性图查询——无需图数据库的图计算

1.1 背景：为什么关系数据库需要图查询？

图数据模型在以下场景中天然优于关系模型：

1. 社交网络：好友关系、关注关系、二度/三度人脉推荐
2. 知识图谱：实体-关系-实体的三元组存储与遍历
3. 供应链分析：多层级供应商关系、风险传导路径
4. 推荐系统：用户-商品交互图、协同过滤

传统做法是维护两套存储：

• PostgreSQL 存储核心业务数据（用户信息、订单、商品）
• Neo4j / Nebula Graph 存储关系图，定期从PostgreSQL同步

这种架构的痛点显而易见：

• 数据一致性：双写、同步延迟、冲突解决
• 运维复杂度：两套数据库，两套备份、监控、扩容方案
• 查询成本：跨库JOIN不可能，应用层不得不做数据聚合

PostgreSQL 19 的 SQL/PGQ 支持，让你可以在现有的关系表之上定义属性图，使用类似 Cypher 的语法进行图查询，而数据仍然存储在原来的表里，索引仍然发挥作用。

1.2 SQL/PGQ 标准简介

SQL/PGQ 是 ISO/IEC 9075-16:2023 定义的图查询标准，它在 SQL 内部引入了：

• CREATE PROPERTY GRAPH：在现有表上定义顶点和边
• GRAPH_TABLE：在图上进行模式匹配查询
• MATCH 子句：类似 Cypher 的模式匹配语法

与 Cypher 的主要区别：

• SQL/PGQ 是 SQL 标准的一部分，不是独立的查询语言
• 图查询可以与原生的 SQL 特性（JOIN、聚合、CTE、窗口函数）自由组合
• 图查询被重写为标准的关系操作，优化器可以对整个查询进行统一优化

1.3 实战：社交网络好友推荐

假设我们有一个社交网络应用，核心表结构如下：

-- 用户表
CREATE TABLE users (
    id SERIAL PRIMARY KEY,
    name TEXT NOT NULL,
    email TEXT UNIQUE NOT NULL,
    created_at TIMESTAMPTZ DEFAULT NOW()
);

-- 关注关系表
CREATE TABLE follows (
    follower_id INT REFERENCES users(id),
    followed_id INT REFERENCES users(id),
    created_at TIMESTAMPTZ DEFAULT NOW(),
    PRIMARY KEY (follower_id, followed_id)
);

-- 插入测试数据
INSERT INTO users (name, email) VALUES
    ('Alice', 'alice@example.com'),
    ('Bob', 'bob@example.com'),
    ('Charlie', 'charlie@example.com'),
    ('David', 'david@example.com'),
    ('Eve', 'eve@example.com');

-- Alice 关注了 Bob 和 Charlie
INSERT INTO follows (follower_id, followed_id) VALUES
    (1, 2), (1, 3),
    (2, 3), (2, 4),
    (3, 5);

1.3.1 定义属性图

CREATE PROPERTY GRAPH social_graph
    VERTEX TABLES (
        users LABEL person PROPERTIES (id, name, email)
    )
    EDGE TABLES (
        follows
        SOURCE KEY (follower_id) REFERENCES users (id)
        DESTINATION KEY (followed_id) REFERENCES users (id)
        LABEL follows
    );

这条语句做了什么？

• VERTEX TABLES：指定哪些表是图的顶点。users 表被标记为 person 标签，可查询的属性包括 id、name、email。
• EDGE TABLES：指定哪些表是图的边。follows 表被标记为 follows 标签，follower_id 是边的起点，followed_id 是边的终点。

关键点：这只是一个元数据定义，不移动任何数据，不创建新的存储结构。

1.3.2 查询：查找 Alice 关注的人

SELECT * FROM GRAPH_TABLE (social_graph
    MATCH (a IS person WHERE a.name = 'Alice')
          -[IS follows]->(b IS person)
    COLUMNS (b.name AS friend)
);

结果：

 friend
--------
 Bob
 Charlie

1.3.3 查询：二度人脉推荐（朋友的朋友）

SELECT DISTINCT c.name, COUNT(*) AS mutual_friends
FROM GRAPH_TABLE (social_graph
    MATCH (a IS person WHERE a.name = 'Alice')
         -[IS follows]->(b IS person)
         -[IS follows]->(c IS person)
    WHERE a.id != c.id  -- 排除自己
      AND NOT EXISTS (  -- 排除已经关注的人
          SELECT 1 FROM GRAPH_TABLE (social_graph
              MATCH (x IS person WHERE x.name = 'Alice')
                    -[IS follows]->(y IS person)
              COLUMNS (y.id AS already_following)
          ) WHERE already_following = c.id
      )
    COLUMNS (c.id AS cid, c.name AS name, b.name AS via)
)
GROUP BY c.name, c.id
ORDER BY mutual_friends DESC;

这段查询找到了 Alice 尚未关注、但被她已关注的人也关注了的那些用户，并按共同好友数排序。

1.3.4 性能分析：图查询 vs 递归CTE

在 PostgreSQL 18 及之前，同样的二度人脉查询需要用递归CTE实现：

-- 传统方法：递归CTE
WITH RECURSIVE following AS (
    SELECT followed_id AS user_id, 1 AS depth
    FROM follows WHERE follower_id = 1
    UNION ALL
    SELECT f.followed_id, following.depth + 1
    FROM follows f
    JOIN following ON f.follower_id = following.user_id
    WHERE following.depth < 2
)
SELECT u.name, COUNT(*) AS mutual_friends
FROM following f
JOIN users u ON u.id = f.user_id
WHERE f.depth = 2
GROUP BY u.id, u.name;

SQL/PGQ 的优势：

1. 可读性：模式匹配语法 (-[IS follows]->) 直观表达图遍历语义
2. 优化器感知：图查询被重写为关系操作，优化器可以选择最佳JOIN顺序、使用索引
3. 组合性：GRAPH_TABLE 可以嵌入到任何 SQL 查询中，与 WHERE、GROUP BY、HAVING 自由组合

1.4 实战：知识图谱中的实体溯源

假设我们在构建一个安全事件分析系统，需要存储「IP地址 → 访问 → 用户账号 → 属于 → 组织」这样的实体关系。

-- 实体表
CREATE TABLE entities (
    id SERIAL PRIMARY KEY,
    entity_type TEXT NOT NULL,  -- 'ip', 'user', 'org', 'file'
    name TEXT NOT NULL,
    metadata JSONB
);

-- 关系表
CREATE TABLE relations (
    from_id INT REFERENCES entities(id),
    to_id INT REFERENCES entities(id),
    rel_type TEXT NOT NULL,  -- 'accesses', 'belongs_to', 'owns', 'infects'
    confidence FLOAT,
    PRIMARY KEY (from_id, to_id, rel_type)
);

-- 定义安全知识图谱
CREATE PROPERTY GRAPH security_graph
    VERTEX TABLES (
        entities LABEL entity PROPERTIES (id, entity_type, name)
    )
    EDGE TABLES (
        relations
        SOURCE KEY (from_id) REFERENCES entities (id)
        DESTINATION KEY (to_id) REFERENCES entities (id)
        LABEL relates
    );

查询：从某个可疑IP出发，找到所有关联的组织

SELECT DISTINCT org.name, org.metadata->>'industry' AS industry
FROM GRAPH_TABLE (security_graph
    MATCH (ip IS entity WHERE ip.entity_type = 'ip' AND ip.name = '192.168.1.100')
         -[IS relates WHERE rel_type = 'accesses']->(user IS entity)
         -[IS relates WHERE rel_type = 'belongs_to']->(org IS entity)
    COLUMNS (org.id AS org_id, org.name AS name, org.metadata AS metadata)
);

这种模式匹配在威胁狩猎（Threat Hunting）场景中极其有用，而以前你需要把数据导出到 Neo4j 才能高效执行。

1.5 架构深究：SQL/PGQ 是如何实现的？

PostgreSQL 19 的 SQL/PGQ 实现遵循以下设计原则：

1. 不引入新的存储引擎：属性图是现有表的视图，数据仍然以堆表/索引组织
2. 重写为关系操作：GRAPH_TABLE 被查询重写器转换为等价的 JOIN + WHERE 子句
3. 复用现有索引：如果 follows 表在 follower_id 上有索引，图遍历会自动使用它
4. 与优化器集成：图模式匹配的路径搜索可以被优化器代价模型评估

这意味着：

• 你可以在现有生产表上立即定义属性图，零迁移成本
• 图查询的性能取决于你原有的索引设计
• EXPLAIN 可以显示图查询被重写后的执行计划

第二章：ON CONFLICT DO SELECT——原子「获取或创建」终于到来

2.1 背景：UPSERT 的痛点

自从 PostgreSQL 9.5 引入 INSERT ... ON CONFLICT，UPSERT（Insert + Update）变得非常方便：

-- 经典 UPSERT：有则更新，无则插入
INSERT INTO users (email, name, last_login)
VALUES ('alice@example.com', 'Alice', NOW())
ON CONFLICT (email) DO UPDATE
SET name = EXCLUDED.name, last_login = EXCLUDED.last_login
RETURNING *;

但有一个常见场景一直很别扭：我想插入一条记录，如果已经存在，就返回已存在的那条（获取或创建语义）。

在 PostgreSQL 18 及之前，你有两个选择：

方案A：DO UPDATE SET col = EXCLUDED.col（空操作更新）

INSERT INTO users (email, name)
VALUES ('alice@example.com', 'Alice')
ON CONFLICT (email) DO UPDATE
SET email = EXCLUDED.email  -- 空操作：把值设为它本身
RETURNING *;

问题：每次冲突都会产生一个死元组（dead tuple），需要VACUUM清理。高并发场景下，表的膨胀速度会显著加快。

方案B：CTE 先查后插

WITH existing AS (
    SELECT * FROM users WHERE email = 'alice@example.com'
)
INSERT INTO users (email, name)
SELECT 'alice@example.com', 'Alice'
WHERE NOT EXISTS (SELECT 1 FROM existing)
RETURNING *
UNION ALL
SELECT * FROM existing;

问题：不是原子的。在 SELECT 和 INSERT 之间，另一个事务可能插入相同记录，导致唯一约束冲突。

2.2 PostgreSQL 19 的解决方案：ON CONFLICT DO SELECT

INSERT INTO users (email, name)
VALUES ('alice@example.com', 'Alice')
ON CONFLICT (email) DO SELECT
RETURNING *;

这个语句的语义：

1. 尝试插入新行
2. 如果唯一约束冲突，不执行任何写操作，直接返回已存在的行
3. RETURNING * 在两种情况下都返回最终结果（新插入的或已存在的）

优势：

• 零死元组：冲突时不产生任何写操作
• 原子性：由 INSERT 的事务语义保证
• 性能：基准测试显示，与空操作更新方法相比，DO SELECT 速度快近 4倍

2.3 实战：高并发短链接生成服务

短链接服务的核心需求：对于给定的原始URL，如果已经生成过短码，直接返回已有短码；否则生成新的。

CREATE TABLE short_links (
    id SERIAL PRIMARY KEY,
    short_code CHAR(7) UNIQUE NOT NULL,
    original_url TEXT NOT NULL,
    created_at TIMESTAMPTZ DEFAULT NOW()
);

-- 生成短码的函数（简化版）
CREATE OR REPLACE FUNCTION get_or_create_short_link(p_url TEXT)
RETURNS TEXT AS $$
DECLARE
    v_code TEXT;
BEGIN
    -- 先尝试获取已有短码
    SELECT short_code INTO v_code
    FROM short_links WHERE original_url = p_url;
    
    IF FOUND THEN
        RETURN v_code;
    END IF;
    
    -- 生成新短码（实际生产中用更健壮的算法）
    v_code := substr(md5(p_url || clock_timestamp()::text), 1, 7);
    
    -- 原子插入（处理并发冲突）
    INSERT INTO short_links (short_code, original_url)
    VALUES (v_code, p_url)
    ON CONFLICT (short_code) DO UPDATE
    SET short_code = EXCLUDED.short_code  -- 极端情况下的冲突重试，生产需更完善
    RETURNING short_code INTO v_code;
    
    RETURN v_code;
END;
$$ LANGUAGE plpgsql;

使用 ON CONFLICT DO SELECT 的改进版本：

CREATE OR REPLACE FUNCTION get_or_create_short_link_v2(p_url TEXT)
RETURNS TEXT AS $$
DECLARE
    v_code TEXT;
BEGIN
    -- 原子获取或创建
    WITH ins AS (
        INSERT INTO short_links (short_code, original_url)
        VALUES (substr(md5(p_url || clock_timestamp()::text), 1, 7), p_url)
        ON CONFLICT (original_url) DO SELECT
        RETURNING short_code
    )
    SELECT short_code INTO v_code FROM ins;
    
    RETURN v_code;
END;
$$ LANGUAGE plpgsql;

2.4 性能基准：DO SELECT vs DO UPDATE（空操作）

以下是 PostgreSQL 19 Beta 1 在 8核16G 机器上的基准测试结果（100万次UPSERT，50%冲突率）：

结论：DO SELECT 不仅更快，而且彻底消除了UPSERT场景下的表膨胀问题。

第三章：时态数据操作——FOR PORTION OF 完成时态SQL支持

3.1 背景：什么是时态数据？

时态数据是指在某个时间范围内有效的数据。典型场景：

1. 产品价格历史：商品在不同时间段有不同的价格
2. 员工职位变动：某员工在2024年Q1是工程师，2024年Q2升为高级工程师
3. 保险合同：保单有生效期和失效期
4. 用户订阅状态：订阅从某年某月某日开始，到某年某月某日结束

传统做法是用两个时间戳表示有效范围：

CREATE TABLE product_prices (
    product_id INT,
    price DECIMAL(10,2),
    valid_from DATE,
    valid_to DATE,
    PRIMARY KEY (product_id, valid_from)
);

痛点：

• 更新价格时，需要手动拆分时间范围（插入新行 + 更新旧行的 valid_to）
• 容易引入重叠或间隙，破坏数据完整性
• 查询某个时间点的状态需要复杂的 BETWEEN 条件

3.2 PostgreSQL 18 的铺垫：WITHOUT OVERLAPS 约束

PostgreSQL 18 引入了 SQL:2011 的时态约束，可以防止时间范围重叠：

CREATE TABLE product_prices (
    product_id INT,
    price DECIMAL(10,2),
    valid_range PERIOD(DATE),
    PRIMARY KEY (product_id, valid_range WITHOUT OVERLAPS)
);

PERIOD(DATE) 是一个时间范围类型，WITHOUT OVERLAPS 约束确保同一个 product_id 的时间范围不重叠。

3.3 PostgreSQL 19 补全：UPDATE/DELETE FOR PORTION OF

在 PostgreSQL 19 中，你可以直接用 FOR PORTION OF 子句来更新时间范围的一部分，PostgreSQL 会自动拆分行。

3.3.1 示例：更新产品价格（部分时间段）

-- 初始状态：产品1在2025全年价格为 $29.99
INSERT INTO product_prices (product_id, price, valid_range)
VALUES (1, 29.99, PERIOD('2025-01-01', '2026-01-01'));

-- 将第三季度的价格更新为 $34.99
UPDATE product_prices
FOR PORTION OF valid_range FROM '2025-07-01' TO '2025-10-01'
SET price = 34.99
WHERE product_id = 1;

执行后，表中有三行：

product_id | price  | valid_range
-----------|--------|---------------------
     1     | 29.99  | [2025-01-01, 2025-07-01)
     1     | 34.99  | [2025-07-01, 2025-10-01)
     1     | 29.99  | [2025-10-01, 2026-01-01)

PostgreSQL 自动将原行拆分成三行，无需手动处理。

3.3.2 示例：删除某个时间段的订阅记录

-- 删除用户在2025年Q3的订阅记录（例如：退款场景）
DELETE FROM user_subscriptions
FOR PORTION OF valid_range FROM '2025-07-01' TO '2025-10-01'
WHERE user_id = 42;

如果原记录的时间范围覆盖了Q3之外的时间，PostgreSQL 会自动保留那些部分。

3.4 实战：员工职位变动追踪系统

CREATE TABLE employee_roles (
    emp_id INT,
    role TEXT,
    department TEXT,
    valid_range PERIOD(TIMESTAMPTZ),
    PRIMARY KEY (emp_id, valid_range WITHOUT OVERLAPS)
);

-- 插入初始记录
INSERT INTO employee_roles (emp_id, role, department, valid_range)
VALUES
    (1, 'Junior Engineer', 'Engineering', PERIOD('2023-01-01', '2024-06-30')),
    (1, 'Senior Engineer', 'Engineering', PERIOD('2024-07-01', '2025-03-31'));

-- 2025年Q1绩效考核后，该员工转岗到产品团队
UPDATE employee_roles
FOR PORTION OF valid_range FROM '2025-04-01' TO '2025-07-01'
SET role = 'Associate Product Manager', department = 'Product'
WHERE emp_id = 1;

查询：某员工在指定时间点的职位

SELECT role, department
FROM employee_roles
WHERE emp_id = 1
  AND PERIOD('2025-05-15', '2025-05-16') OVERLAPS valid_range;

3.5 性能与存储考虑

时态表的存储开销显然比普通表大，因为每次"部分更新"都会产生新行。但好处是：

1. 完整的审计轨迹：你可以追溯任何时间点的状态
2. 无需触发器或应用层逻辑：数据库原生支持
3. 约束保证数据完整性：WITHOUT OVERLAPS 防止了重叠

对于需要追踪历史变化的场景（金融、保险、HR系统），这个特性是游戏规则的改变者。

第四章：查询计划提示——pg_plan_advice 终于来了

4.1 PostgreSQL 为什么拒绝计划提示？

PostgreSQL 社区长期以来反对引入查询计划提示（Query Hints），理由是：

1. 统计信息会变化：今天有效的提示，明天可能因为数据分布变化而变成性能杀手
2. 升级风险：新版本的优化器改进可能使得提示过时甚至有害
3. 懒惰的捷径：提示可能让开发者不去修复真正的问题（如缺失索引、过时的统计信息）

这个立场在绝大多数场景下是对的。但现实世界中，存在一些边缘情况：

• 优化器对特定相关子查询的基数估计不准确
• 多表JOIN的顺序在特定数据分布下总是选错
• 升级后某个关键查询的计划发生了变化，导致性能回退

在这些情况下，DBA往往需要"强制"优化器选择一个已知良好的计划。

4.2 pg_plan_advice：PostgreSQL 19 的官方提示机制

pg_plan_advice 是一个 contrib 扩展，提供了计划稳定和覆盖能力。

4.2.1 工作流程

1. 捕获已知良好计划：用 EXPLAIN (PLAN_ADVICE) 生成当前查询的计划建议
2. 应用建议：将建议设置到 pg_plan_advice.advice GUC 中
3. 反馈机制：EXPLAIN 会告诉你每个提示是否被采纳

4.2.2 示例：锁定一个复杂JOIN的顺序

-- 步骤1：从当前计划生成建议
EXPLAIN (COSTS OFF, PLAN_ADVICE)
SELECT * FROM orders o
JOIN customers c ON o.cust_id = c.id
JOIN products p ON o.product_id = p.id
WHERE o.created_at > '2026-01-01';

输出：

Nested Loop
  ->  Index Scan using orders_created_at_idx on orders o
  ->  Nested Loop
        ->  Index Scan using customers_pkey on customers c
        ->  Index Scan using products_pkey on products p
(PLAN_ADVICE: JOIN_ORDER(o c p) HASH_JOIN(c) HASH_JOIN(p) INDEX_SCAN(o c p))

复制建议内容，应用到会话：

-- 步骤2：锁定计划
SET pg_plan_advice.advice = 'JOIN_ORDER(o c p) HASH_JOIN(c) HASH_JOIN(p) INDEX_SCAN(o c p)';

-- 步骤3：验证
EXPLAIN SELECT * FROM orders o
JOIN customers c ON o.cust_id = c.id
JOIN products p ON o.product_id = p.id
WHERE o.created_at > '2026-01-01';

如果建议被采纳，EXPLAIN 输出会包含 (advice applied) 标记。

4.2.3 与 Oracle/MySQL 提示的区别

4.3 实战：解决多租户SaaS中的统计信息偏差

在多租户SaaS中，tenant_id 的数据分布极度倾斜（某些大客户有百万级数据，小客户只有几条）。这导致优化器对 WHERE tenant_id = ? 的基数估计经常不准。

-- 为特定大客户强制索引扫描
SET pg_plan_advice.advice FOR 'app_user' = 'INDEX_SCAN(orders tenant_id_idx)';

-- 或者全局设置
ALTER DATABASE saas_prod SET pg_plan_advice.advice = '...';

第五章：REPACK CONCURRENTLY——在线表重组织革命

5.1 VACUUM FULL 的痛点

PostgreSQL 的堆表存储采用 MVCC 机制，更新和删除会产生死元组。虽然 VACUUM 可以回收空间供重复使用，但不能把空间返还给操作系统。

VACUUM FULL 可以：

• 重写整个表（类似 CLUSTER）
• 把未使用的空间返还给操作系统
• 重建所有索引

但有一个致命问题：VACUUM FULL 需要 ACCESS EXCLUSIVE 锁，在操作的整个过程中，表完全不可读写。

对于大型生产表（几百GB甚至TB级），VACUUM FULL 可能需要数小时，这段时间服务完全不可用。

5.2 REPACK：VACUUM FULL 的在线替代方案

PostgreSQL 19 引入的 REPACK 命令，结合了 VACUUM FULL（空间回收）和 CLUSTER（按索引重排）的功能，并增加了 CONCURRENTLY 选项。

5.2.1 基本用法

-- 回收空间（类似 VACUUM FULL）
REPACK orders;

-- 按索引重新排序（类似 CLUSTER）
REPACK orders USING INDEX orders_created_at_idx;

-- 在线模式：重组期间表保持可访问
REPACK (CONCURRENTLY) orders USING INDEX orders_created_at_idx;

5.2.2 CONCURRENTLY 的工作原理

REPACK (CONCURRENTLY) 的执行过程：

1. 阶段1：数据拷贝（耗时最长，期间表完全可读写）

   • 创建一个新数据文件
   • 将旧表的数据逐批拷贝到新文件
   • 同时追踪所有的 INSERT/UPDATE/DELETE（通过触发器或WAL解码）

2. 阶段2：增量同步

   • 将阶段1期间产生的变更应用到新文件

3. 阶段3：文件交换（持有短暂的 ACCESS EXCLUSIVE 锁）

   • 将新文件替换为表的数据文件
   • 重建索引

整个过程只在阶段3有短暂的锁，通常只需要几百毫秒到几秒（取决于索引数量）。

5.2.3 性能对比

5.3 实战：生产环境大表空间回收

-- 检查表的膨胀情况
SELECT schemaname, tablename,
       pg_size_pretty(pg_total_relation_size(schemaname||'.'||tablename)) AS total_size,
       pg_size_pretty(pg_relation_size(schemaname||'.'||tablename)) AS table_size,
       100 - (pg_relation_size(schemaname||'.'||tablename) * 100 / pg_total_relation_size(schemaname||'.'||tablename)) AS bloat_pct
FROM pg_tables
WHERE schemaname = 'public'
ORDER BY pg_total_relation_size(schemaname||'.'||tablename) DESC
LIMIT 10;

-- 对膨胀超过30%的表执行在线重组织
REPACK (CONCURRENTLY, VERBOSE) large_table;

VERBOSE 选项会输出详细的进度信息，方便监控。

第六章：并行自动清理——大型表VACUUM的性能突破

6.1 问题：为什么VACUUM会跟不上？

随着SSD性能和多核CPU的普及，单个VACUUM工作进程的吞吐量逐渐成为瓶颈。特别是：

• 多索引表：VACUUM需要逐个处理每个索引，单进程串行执行
• 大表：需要扫描数十GB的数据，单进程I/O受限

6.2 PostgreSQL 19 的并行VACUUM

自动清理现在可以对索引清理阶段使用并行工作进程。

6.2.1 配置

-- 全局设置：最多4个并行自动清理工作进程
ALTER SYSTEM SET autovacuum_max_parallel_workers = 4;

-- 针对特定表设置（例如：有8个索引的大表）
ALTER TABLE events SET (autovacuum_parallel_workers = 6);

6.2.2 工作原理

假设 events 表有5个索引，autovacuum_parallel_workers = 4：

• 索引清理阶段：4个工作进程同时处理4个索引，第5个索引等第一批完成后处理
• 耗时：约等于最大的单个索引的清理时间，而不是5个索引的总和

对于有大索引（如GIN索引）的表，这个特性可以显著缩短VACUUM时间。

6.2.3 监控并行VACUUM进度

SELECT pid, relid::regclass AS table_name,
       phase, mode, started_by,
       heap_blks_scanned, heap_blks_total
FROM pg_stat_progress_vacuum;

新增的 mode 列显示VACUUM的模式：normal、aggressive、failsafe。

第七章：原生JSON导出与COPY增强

7.1 COPY TO JSON：终于不需要row_to_json()了

在 PostgreSQL 19 之前，导出JSON格式需要用变通方法：

-- 老方法：通过row_to_json()
COPY (
    SELECT row_to_json(t) FROM (SELECT * FROM users) t
) TO '/tmp/users.json';

这种方法的问题：

• 需要把整个表先转换成JSON，内存开销大
• 不支持流式输出
• 性能差

7.1.1 PostgreSQL 19 的原生JSON导出

-- NDJSON格式（每行一个JSON对象，默认）
COPY users TO '/tmp/users.ndjson' WITH (FORMAT JSON);

-- JSON数组格式
COPY users TO '/tmp/users.json' WITH (FORMAT JSON, FORCE_ARRAY);

输出示例（NDJSON）：

{"id":1,"email":"alice@example.com","name":"Alice","created_at":"2026-01-15T10:30:00Z"}
{"id":2,"email":"bob@example.com","name":"Bob","created_at":"2026-02-20T14:25:00Z"}

性能提升：比基于 SELECT 的等效方法快约 7-8%，且内存效率更高（流式输出）。

7.1.2 分区表的原生支持

-- 直接COPY分区表，无需包装子查询
COPY partitioned_sales TO '/tmp/sales_2026.csv' WITH (FORMAT csv);

第八章：逻辑复制的重大改进

8.1 序列同步——解决故障转移后的重复键问题

在 PostgreSQL 18 及之前，逻辑复制不会同步序列值。这意味着：

1. 主库上 users_id_seq 已经到了 1000
2. 故障转移到备库，备库的序列值可能还在 100
3. 插入新用户时，产生 duplicate key violation

PostgreSQL 19 解决了这个问题：

-- 发布端：同时发布所有表和所有序列
CREATE PUBLICATION prod_pub FOR ALL TABLES, ALL SEQUENCES;

-- 订阅端：自动同步序列值
CREATE SUBSCRIPTION prod_sub
CONNECTION 'host=master dbname=prod user=replicator password=xxx'
PUBLICATION prod_pub;

8.2 EXCEPT TABLE：发布白名单的排除语法

以前，如果你想发布数据库中几乎所有的表，但排除几张（如审计日志表、临时表），你需要逐个列举允许的表。

PostgreSQL 19 支持 EXCEPT 语法：

CREATE PUBLICATION prod_pub FOR ALL TABLES
EXCEPT (TABLE audit_log, temp_imports, user_sessions);

8.3 动态WAL级别——不再需要重启

在 PostgreSQL 18 及之前，如果你想从 replica 级别切换到 logical 级别（启用逻辑复制），需要：

1. 修改 postgresql.conf：wal_level = logical
2. 重启数据库（影响生产服务）

PostgreSQL 19 引入了 effective_wal_level 只读参数，它会根据是否存在逻辑复制槽自动调整：

-- 查看当前生效的WAL级别
SHOW effective_wal_level;

-- 输出可能是 'replica'，但如果有逻辑复制槽，实际是 'logical'

这意味着：你可以先把 wal_level 设为 replica，当需要启用逻辑复制时，创建复制槽即可，无需重启。

第九章：性能提升——外键检查加速2倍

9.1 外键检查的性能问题

在 PostgreSQL 18 及之前，每次 INSERT 或 UPDATE 到子表时，都会触发外键约束检查，执行类似这样的查询：

SELECT 1 FROM parent_table WHERE id = $1 FOR KEY SHARE;

对于大批量插入（如 INSERT ... SELECT、COPY），这种逐行检查的开销非常显著。

9.2 PostgreSQL 19 的优化

PostgreSQL 19 引入了外键检查的批量验证优化：

• 在 COPY 或 INSERT ... SELECT 场景中，多个行的外键检查可以被合并成一次索引扫描
• 基准测试显示，有外键约束的插入操作性能提升高达 2倍

-- 测试：插入100万行到有外键约束的子表
-- PostgreSQL 18: ~45秒
-- PostgreSQL 19: ~22秒

第十章：其他值得关注的新特性

10.1 GROUP BY ALL——减少冗余语法

-- 以前：需要手动列举所有非聚合列
SELECT department, role, location, COUNT(*), AVG(salary)
FROM employees
GROUP BY department, role, location;

-- PostgreSQL 19：GROUP BY ALL
SELECT department, role, location, COUNT(*), AVG(salary)
FROM employees
GROUP BY ALL;

GROUP BY ALL 自动将所有 SELECT 列表中非聚合、非窗口函数的表达式作为分组键。

注意：过度使用 GROUP BY ALL 可能导致意外的结果（如果 SELECT 列表发生了变化）。建议在 ad-hoc 查询中使用，生产代码仍推荐显式列举。

10.2 IGNORE NULLS——窗口函数的空值处理

-- 获取每个传感器最后一个非空读数（跳过NULL）
SELECT sensor_id,
       last_value(reading) IGNORE NULLS OVER (
           PARTITION BY sensor_id ORDER BY ts
       ) AS last_known_reading
FROM sensor_data;

这对于存在空缺的时间序列数据非常有用。

10.3 WAIT FOR LSN——副本上的读写一致性

在读写分离架构中，应用写入主库后，立即从副本读取可能会读到旧数据（因为复制延迟）。

PostgreSQL 19 的 WAIT FOR LSN 命令让会话可以等待，直到副本回放到指定的日志序列号：

-- 写入主库后，获取当前LSN
SELECT pg_current_wal_insert_lsn();  -- 返回 '19/ABCD1234'

-- 在副本上等待
WAIT FOR LSN '19/ABCD1234';

-- 现在可以安全读取刚写入的数据
SELECT * FROM users WHERE id = 12345;

这实现了「读己所写」（read-your-writes）一致性，无需强制所有读都走主库。

10.4 在线启用数据校验和

数据校验和（data checksums）可以检测存储层的静默数据损坏。以前，启用校验和需要离线操作（pg_checksums --enable），意味着数据库需要停止服务。

PostgreSQL 19 支持在线启用/禁用：

-- 在线启用校验和（集群保持可访问）
SELECT pg_enable_data_checksums(cost_delay := 10, cost_limit := 1000);

-- 监控进度
SELECT * FROM pg_stat_checksum_progress;

cost_delay 和 cost_limit 参数允许你限制对生产系统I/O的影响。

第十一章：破坏性变更与升级注意事项

在升级到 PostgreSQL 19 之前，需要注意以下破坏性变更：

11.1 JIT 默认禁用

jit 参数现在默认为 off。依赖 JIT 的分析型工作负载应显式重新启用：

ALTER DATABASE analytics_db SET jit = on;

11.2 LZ4 TOAST 压缩默认

新的 TOAST 数据使用 LZ4 而不是 pglz。现有数据不受影响。

如果你依赖 pglz 的特定行为（虽然很少见），可以全局或每表设置：

ALTER SYSTEM SET default_toast_compression = 'pglz';

11.3 RADIUS 认证已移除

radius 认证方法已被完全移除。请切换到 LDAP、GSSAPI 或证书认证。

11.4 MD5 密码警告

使用 MD5 哈希密码连接现在会发出弃用警告。请迁移到 SCRAM-SHA-256：

-- 查看仍在使用MD5密码的用户
SELECT usename FROM pg_shadow WHERE passwd NOT LIKE 'SCRAM-SHA-256%';

-- 迁移（需要用户重新设置密码）
ALTER USER app_user WITH PASSWORD 'new_password';  -- 会自动使用SCRAM-SHA-256

第十二章：生产部署实战指南

12.1 从 PostgreSQL 18 升级到 19

推荐使用 pg_upgrade：

# 安装 PostgreSQL 19
sudo apt install postgresql-19

# 停止旧版本
sudo systemctl stop postgresql-18

# 运行 pg_upgrade
sudo -u postgres pg_upgrade \
    --old-datadir=/var/lib/postgresql/18/main \
    --new-datadir=/var/lib/postgresql/19/main \
    --old-bindir=/usr/lib/postgresql/18/bin \
    --new-bindir=/usr/lib/postgresql/19/bin \
    --check  # 先检查兼容性

# 如果check通过，执行实际升级
sudo -u postgres pg_upgrade ...

12.2 新特性采纳策略

建议在升级后，按以下顺序逐步启用新特性：

1. ON CONFLICT DO SELECT：立即替换现有的空操作更新
2. GROUP BY ALL：在 ad-hoc 查询中开始使用
3. REPACK CONCURRENTLY：在下一个维护窗口执行大表重组织
4. 并行自动清理：根据VACUUM日志调整 autovacuum_parallel_workers
5. SQL/PGQ：在新项目中尝试，生产环境先充分测试
6. pg_plan_advice：仅在确实需要时才使用

12.3 性能基准测试清单

升级后，建议对以下场景进行基准测试：

• 外键约束表的批量插入性能
• 大表的VACUUM时间（开启并行后）
• 复杂JOIN查询的计划稳定性（使用pg_plan_advice）
• COPY TO JSON 的导出速度
• 逻辑复制的序列同步正确性

第十三章：总结与展望

PostgreSQL 19 是一个里程碑式的版本，它在以下几个维度上推动了开源关系数据库的天花板：

13.1 功能深度

• 图查询：通过 SQL/PGQ 原生支持，消除了对独立图数据库的需求
• 时态数据：完整支持 SQL:2011 时态功能集，适用于金融、保险、HR系统
• UPSERT语义：ON CONFLICT DO SELECT 终于填补了长达10年的空白

13.2 运维友好

• 在线表重组织：REPACK CONCURRENTLY 让大表维护不再需要维护窗口
• 并行VACUUM：自动清理可以更充分地利用多核CPU
• 动态WAL级别：逻辑复制的启用不再需要重启
• 在线校验和：数据完整性保护可以在运行中启用

13.3 开发者体验

• GROUP BY ALL、IGNORE NULLS：减少冗余语法
• WAIT FOR LSN：简化了读写分离架构的一致性处理
• COPY TO JSON：原生JSON导出，性能更好，代码更简洁
• DDL提取函数：pg_get_database_ddl() 等函数简化了迁移和脚本化

13.4 展望 PostgreSQL 20

基于 PostgreSQL 19 的方向，我们可以合理推测下一个版本可能关注的领域：

1. 向量化执行：进一步的执行器优化，提升分析查询性能
2. 列存引擎：或许会通过表访问方法的扩展引入列存选项
3. 分布式增强：基于 FDW 的分布式方案（如 Citus）进一步集成
4. AI原生：可能是内置的向量检索增强，或与大模型更紧密的集成

附录：快速参考表

A.1 PostgreSQL 19 新特性速查

A.2 升级检查清单

• 备份配置文件（postgresql.conf、pg_hba.conf）
• 检查是否有使用 RADIUS 认证
• 检查是否有使用 MD5 密码的用户
• 检查应用是否依赖 JIT（需要显式启用）
• 在测试环境验证所有关键查询的性能
• 计划 REPACK CONCURRENTLY 的执行窗口

文章结束

关于作者：程序员茄子，全栈工程师，10年后端开发经验，PostgreSQL 深度用户。关注数据库内核、分布式系统和高并发架构设计。

参考资料：

• PostgreSQL 19 Beta 1 Release Notes: https://www.postgresql.org/docs/19/release-19.html
• SQL/PGQ ISO Standard: ISO/IEC 9075-16:2023
• PostgreSQL Official Documentation: https://www.postgresql.org/docs/19/