pgrust 深度实战：当 PostgreSQL 被 Rust 重写——100% 回归测试通过，分析负载快 300 倍

一、背景：为什么有人要用 Rust 重写 PostgreSQL？

2026 年 7 月，GitHub Trending 上出现了一个画风清奇的项目：pgrust——用 Rust 重写的 PostgreSQL，不仅通过了 100% 的官方回归测试（46,066 个查询），还宣称在分析负载上比原生 PostgreSQL 快 300 倍。

这不是玩具项目，不是 POC，而是实打实的"换心手术"：兼容 PostgreSQL 18.3 的磁盘格式，能直接启动已有的 PG 数据目录，连 psql 客户端都能无缝对接。

为什么有人要干这事儿？

答案是：PostgreSQL 的历史包袱太重了。

1.1 四马之战：PostgreSQL 的四大痛点

pgrust 作者在博客《The Four Horsemen Behind Thousands of Postgres Outages》中总结了生产环境 PostgreSQL 的四大杀手：

第一匹马：进程模型

PostgreSQL 采用"一个连接一个进程"的经典架构。这在 1990 年代是稳健的选择——进程崩溃不会影响其他连接，隔离性强。但到了 2026 年：

-- 当你有 10,000 个并发连接时
SELECT count(*) FROM pg_stat_activity;
-- 返回 10,000 行
-- 意味着 10,000 个进程，每个占用几十 MB 内存

每个连接的进程上下文切换、内存占用、IPC 开销，在高并发场景下成为瓶颈。虽然后来有了 pgBouncer、Pgpool-II 这类连接池，但本质上是"打补丁"——为什么不让数据库内核自己支持多线程？

第二匹马：VACUUM

-- 典型的 VACUUM 痛点
CREATE TABLE orders (
    id SERIAL PRIMARY KEY,
    data JSONB,
    created_at TIMESTAMP DEFAULT NOW()
);

-- 高频更新场景
UPDATE orders SET data = data || '{"status": "shipped"}' 
WHERE id = 123;

-- 每次更新都产生死元组
-- VACUUM 必须定期扫描，否则表膨胀
-- 但 VACUUM 本身又消耗 I/O，影响业务

PostgreSQL 的 MVCC 实现要求定期 VACUUM 清理死元组。在大表场景，VACUUM 可能跑几个小时，期间 I/O 飙升，业务抖动。这是架构层面的代价——没有 undo log，所有历史版本都留在表里。

第三匹马：规划器不确定性

-- 同一条 SQL，不同数据分布可能导致完全不同的执行计划
EXPLAIN ANALYZE SELECT * FROM orders WHERE user_id = 123 AND status = 'pending';

-- 今天用了索引扫描，明天数据量变了，规划器突然改用全表扫描
-- 查询时间从 50ms 暴涨到 30s

PostgreSQL 的查询规划器基于成本估算，但估算本身是概率性的。统计信息更新不及时、相关系数计算偏差，都可能导致规划器选择次优计划。更糟的是，这种"突然变慢"在生产环境很难提前预防。

第四匹马：扩展开发门槛

// PostgreSQL 扩展开发——C 语言，手动内存管理
#include "postgres.h"
#include "fmgr.h"

PG_MODULE_MAGIC;

PG_FUNCTION_INFO_V1(my_function);

Datum
my_function(PG_FUNCTION_ARGS)
{
    int32 arg = PG_GETARG_INT32(0);
    char *result = palloc(256);  // 手动管理内存
    // ... 一旦出错，可能导致整个 backend 崩溃
    PG_RETURN_TEXT_P(cstring_to_text(result));
}

写一个 PostgreSQL 扩展需要理解大量内部 API，而且 C 语言的内存不安全意味着一个越界就能让整个进程崩溃。这限制了扩展生态的繁荣。

1.2 pgrust 的野心

pgrust 不是要做一个"更好的数据库"，而是要让 PostgreSQL 变得更容易改变。

核心思路：

1. 保持 PostgreSQL 的行为不变（用官方测试套件作为 oracle）
2. 用 Rust 重写内核，引入内存安全、并发安全
3. 在新架构上探索：多线程、no-vacuum、更好的 JSON 支持、AI 生成 SQL 的运行时防护

这是一场"在飞行中更换引擎"的实验。

二、架构分析：Rust 如何重写 PG 内核

2.1 项目结构

pgrust/
├── crates/              # Rust 核心实现
│   ├── postgres/        # 主进程（postgres binary）
│   ├── pg_sys/          # PostgreSQL C API 的 Rust binding
│   ├── storage/         # 存储引擎
│   ├── executor/        # 查询执行器
│   └── planner/         # 查询规划器
├── vendor/
│   └── postgres-18.3/   # 官方 PG 18.3 源码（用于测试）
├── scripts/
│   └── run-regression   # 回归测试脚本
└── docker/              # 容器化部署

2.2 关键技术决策

决策一：进程模型 → 多线程模型

原生 PostgreSQL：

[Postmaster 进程]
    ├── [Backend 进程 1] ←→ 客户端连接 1
    ├── [Backend 进程 2] ←→ 客户端连接 2
    ├── [Background Writer 进程]
    ├── [WAL Writer 进程]
    └── [Autovacuum Launcher 进程]

pgrust 新架构（未发布版本）：

[pgrust 主线程]
    ├── [连接池线程]
    │   ├── [Worker 线程 1] ←→ 客户端连接
    │   ├── [Worker 线程 2] ←→ 客户端连接
    │   └── ...
    ├── [存储线程]
    ├── [WAL 线程]
    └── [后台任务线程]

多线程的优势：

• 内存共享：连接之间可以共享缓存，不需要每个进程单独加载
• 上下文切换更快：线程切换比进程切换开销小 10-100 倍
• 更好的 CPU 缓存局部性：共享 L1/L2 缓存

决策二：保持磁盘兼容

pgrust 直接兼容 PostgreSQL 18.3 的数据目录格式：

# 使用已有的 PG 数据目录启动 pgrust
target/release/postgres \
  -D /var/lib/postgresql/18/main \
  -c listen_addresses='*' \
  -p 5432

这意味着你不需要迁移数据——换个二进制就能跑。这是 pgrust 能通过 100% 回归测试的关键：用真实数据验证行为一致性。

决策三：AI 辅助开发

pgrust 作者在博客中提到，整个重写过程大量使用 AI 辅助编程（Claude、GPT 等）。核心流程：

1. 从 PostgreSQL C 源码提取语义（函数、结构体、宏）
2. 让 AI 生成 Rust 等价实现
3. 运行回归测试，收集失败用例
4. 让 AI 根据失败信息修复代码
5. 重复直到全部通过

这不是简单的"翻译"，而是理解语义 → 重新实现 → 验证行为。46,066 个测试用例就是最好的验证集。

2.3 性能对比数据

pgrust 官方给出的性能数据（未发布版本）：

为什么分析负载快这么多？

答案在于向量化执行 + 列式扫描优化。

PostgreSQL 原生是行存，即使有并行查询，也无法达到专门的列式数据库的性能。pgrust 在查询执行器中引入了向量化执行：

// 伪代码：向量化执行 vs 行式执行
// 行式：一次处理一行
fn execute_row_by_row(rows: &[Row]) -> i64 {
    let mut sum = 0;
    for row in rows {
        sum += row.get_column("amount");
    }
    sum
}

// 向量化：一次处理一批
fn execute_vectorized(column: &Column<i64>) -> i64 {
    column.iter().sum()  // SIMD 优化
}

当数据量达到百万级，向量化执行可以比行式快 10-100 倍。pgrust 在保持 SQL 兼容性的同时，引入了类似 DuckDB 的向量化引擎。

三、实战：从零到一运行 pgrust

3.1 Docker 一键体验

最简单的方式是通过 Docker：

# 拉取镜像并启动
docker run -d --name pgrust \
  -e POSTGRES_PASSWORD=secret \
  malisper/pgrust:v0.1

# 等待启动完成
until docker exec -e PGPASSWORD=secret pgrust \
  psql -h 127.0.0.1 -U postgres -c '\q' >/dev/null 2>&1; do
  sleep 1
done

# 连接并查询
docker exec -it -e PGPASSWORD=secret pgrust \
  psql -h 127.0.0.1 -U postgres

# 在 psql 中
SELECT version();
-- 返回类似：
-- PostgreSQL 18.3 (pgrust 0.1) on x86_64-pc-linux-gnu

3.2 从源码构建（macOS）

如果你想在本地编译，步骤如下：

# 1. 安装依赖
brew install icu4c openssl@3 libpq

# 2. 设置环境变量
export LIBRARY_PATH="$(brew --prefix openssl@3)/lib:${LIBRARY_PATH:-}"
export PKG_CONFIG_PATH="$(brew --prefix openssl@3)/lib/pkgconfig:$(brew --prefix icu4c)/lib/pkgconfig:${PKG_CONFIG_PATH:-}"
export PATH="$(brew --prefix libpq)/bin:$PATH"

# 3. 克隆仓库
git clone https://github.com/malisper/pgrust.git
cd pgrust

# 4. 构建发布版本
PGRUST_PGSHAREDIR="$PWD/vendor/postgres-18.3/share" \
  cargo build --release --locked --bin postgres

# 5. 初始化数据目录
target/release/postgres --initdb \
  -D /tmp/pgrust-data \
  -L "$PWD/vendor/postgres-18.3/share" \
  --no-locale \
  --encoding UTF8 \
  -U postgres

# 6. 启动数据库（注意栈大小设置）
ulimit -s 65520

RUST_MIN_STACK=33554432 target/release/postgres \
  -D /tmp/pgrust-data \
  -F \
  -c listen_addresses= \
  -k /tmp \
  -p 5432 \
  -c io_method=sync \
  -c max_stack_depth=60000

# 7. 连接测试
psql -h /tmp -p 5432 -U postgres -d postgres \
  -c "SELECT version(), 1 + 1 AS two"

3.3 WebAssembly 浏览器体验

pgrust 提供了一个在线 Demo，直接在浏览器中运行：

访问地址： https://pgrust.com

这是通过 WebAssembly 编译的 pgrust，在浏览器中直接运行。首次加载需要编译，之后查询速度很快。

-- 在浏览器中尝试这些查询
CREATE TABLE users (
    id SERIAL PRIMARY KEY,
    name TEXT NOT NULL,
    email TEXT UNIQUE
);

INSERT INTO users (name, email) VALUES
    ('Alice', 'alice@example.com'),
    ('Bob', 'bob@example.com'),
    ('Charlie', 'charlie@example.com');

SELECT * FROM users WHERE name LIKE 'A%';

-- 尝试 JSON 查询
SELECT '{"a": 1, "b": [2, 3, 4]}'::jsonb -> 'b';

3.4 运行回归测试

想验证 pgrust 是否真的 100% 兼容？运行官方回归测试：

# 设置 pgrust 二进制路径
export PGRUST_BIN="$PWD/target/release/postgres"

# 如果 psql 不在 PATH 中，设置路径
export PGRUST_PSQL=/usr/local/bin/psql

# 运行回归测试
scripts/run-regression

# 输出示例：
# ======================
# Running PostgreSQL regression tests...
# ======================
# parallel group (33 tests):  ... ok
# parallel group (20 tests):  ... ok
# ...
# ======================
# All 46066 tests passed!
# ======================

四、技术深度：Rust 如何改造 PG 内核

4.1 内存安全：告别 use-after-free

PostgreSQL 的 C 代码中大量手动内存管理：

// PostgreSQL C 源码示例（简化）
void process_query(Query *query) {
    char *buffer = palloc(1024);  // 从内存上下文分配
    
    // ... 复杂的处理逻辑
    
    // 如果中间有 early return，可能忘记 pfree
    if (error_condition) {
        return;  // buffer 泄漏！
    }
    
    pfree(buffer);  // 手动释放
}

pgrust 的 Rust 实现：

// Rust 自动内存管理
fn process_query(query: &Query) -> Result<(), Error> {
    let buffer = vec![0u8; 1024];  // 自动分配
    
    // ... 复杂的处理逻辑
    
    if error_condition {
        return Err(Error::new("error"));  // buffer 自动释放
    }
    
    Ok(())  // buffer 自动释放
}

Rust 的所有权系统在编译期就能捕获大部分内存错误：

• use-after-free：编译器拒绝编译
• double-free：编译器拒绝编译
• 内存泄漏：仍有可能，但可以通过 RAII 模式最小化

4.2 并发安全：数据竞争在编译期被拒绝

PostgreSQL 的进程模型天然避免了数据竞争——进程间不共享内存。但多线程模型下，共享状态需要小心处理。

Rust 的 Send 和 Sync trait 提供了编译期保障：

use std::sync::{Arc, Mutex};

// 共享的查询缓存
struct QueryCache {
    inner: Mutex<HashMap<String, Plan>>,
}

// 多个线程可以安全访问
fn execute_query(cache: Arc<QueryCache>, sql: &str) -> Result<ResultSet, Error> {
    // 获取锁，自动释放
    let plan = cache.inner.lock().unwrap()
        .get(sql)
        .cloned();
    
    match plan {
        Some(plan) => plan.execute(),
        None => {
            // 生成新计划
            let new_plan = Planner::create(sql)?;
            cache.inner.lock().unwrap()
                .insert(sql.to_string(), new_plan.clone());
            new_plan.execute()
        }
    }
}

如果尝试在不安全的上下文中修改共享状态，编译器会直接报错：

// 这段代码无法编译！
fn unsafe_example(cache: &QueryCache, sql: &str) {
    let mut guard = cache.inner.lock().unwrap();
    
    // 在另一个线程中修改 guard —— 编译器拒绝
    std::thread::spawn(|| {
        guard.insert(sql.to_string(), Plan::default());
    });
}

4.3 错误处理：Result 替代 elog/ereport

PostgreSQL 的错误处理：

// C 语言错误处理
void some_function(void) {
    if (some_error_condition) {
        ereport(ERROR,
                (errcode(ERRCODE_INTERNAL_ERROR),
                 errmsg("internal error"),
                 errdetail("Something went wrong")));
        // 不会执行到这里，PG 内部会 longjmp
    }
}

这种 longjmp 方式的问题：

1. 跳过栈上的析构函数（C 没有析构函数，但 C++ 扩展会出问题）
2. 状态管理复杂——需要手动清理资源

pgrust 的 Rust 错误处理：

// Rust 错误处理
fn some_function() -> Result<(), PgError> {
    if some_error_condition {
        return Err(PgError::InternalError {
            message: "internal error".to_string(),
            detail: Some("Something went wrong".to_string()),
        });
    }
    
    // 正常逻辑
    Ok(())
}

// 使用 ? 操作符自动传播错误
fn caller() -> Result<(), PgError> {
    some_function()?;  // 如果出错，自动返回 Err
    another_function()?;  // 同上
    Ok(())
}

Rust 的错误处理是显式的、类型安全的，而且自动清理资源。

4.4 向量化执行：SIMD 加速查询

pgrust 在执行器层面引入了向量化执行：

// 传统行式执行
fn evaluate_filter_row_by_row(
    table: &Table,
    predicate: &Predicate,
) -> Vec<Row> {
    let mut results = Vec::new();
    for row in table.scan() {
        if predicate.evaluate(&row) {
            results.push(row);
        }
    }
    results
}

// 向量化执行
fn evaluate_filter_vectorized(
    column: &Column,
    predicate: &Predicate,
) -> BitVec {
    // 批量评估，SIMD 优化
    predicate.evaluate_batch(column)
}

// 使用示例
fn main() {
    let column = Column::from_vec(vec![1, 2, 3, 4, 5, 6, 7, 8]);
    let predicate = Predicate::GreaterThan(5);
    
    let matches = evaluate_filter_vectorized(&column, &predicate);
    // matches: [false, false, false, false, false, true, true, true]
    
    // 根据 BitVec 提取匹配行
    let results = column.gather(&matches);
    // results: [6, 7, 8]
}

向量化执行的关键优势：

1. CPU 缓存友好：顺序访问内存，缓存命中率高
2. SIMD 并行：一条指令同时处理多个数据
3. 分支预测友好：批量处理减少分支

五、性能调优实战

5.1 配置参数

pgrust 引入了一些新配置参数：

-- 查看 pgrust 特有参数
SHOW ALL LIKE 'pgrust%';

-- 输出示例：
-- pgrust.thread_pool_size       | 8        | Worker 线程数
-- pgrust.vectorized_batch_size  | 1024     | 向量化批大小
-- pgrust.enable_simd            | on       | 启用 SIMD 优化
-- pgrust.cache_query_plans      | on       | 缓存查询计划

-- 调整参数
ALTER SYSTEM SET pgrust.vectorized_batch_size = 4096;
SELECT pg_reload_conf();

5.2 OLTP 场景优化

对于事务密集型场景：

-- 1. 增大连接池
ALTER SYSTEM SET pgrust.thread_pool_size = 32;

-- 2. 减少检查点频率
ALTER SYSTEM SET checkpoint_timeout = '15min';
ALTER SYSTEM SET max_wal_size = '4GB';

-- 3. 优化 WAL 写入
ALTER SYSTEM SET wal_compression = 'on';
ALTER SYSTEM SET wal_buffers = '64MB';

-- 4. 对于热点表，考虑预加载到内存
-- （pgrust 特有功能，原生 PG 没有）
SELECT pgrust_preload_table('hot_table_name');

5.3 OLAP 场景优化

对于分析查询：

-- 1. 增大向量化批大小
ALTER SYSTEM SET pgrust.vectorized_batch_size = 8192;

-- 2. 禁用行级锁（分析场景不需要）
ALTER SYSTEM SET pgrust.row_level_locking = off;

-- 3. 启用并行查询
ALTER SYSTEM SET max_parallel_workers_per_gather = 8;
ALTER SYSTEM SET max_parallel_workers = 16;

-- 4. 增大工作内存
ALTER SYSTEM SET work_mem = '256MB';

-- 5. 使用列式扫描提示（pgrust 特有）
/*+ ColumnScan */ 
SELECT 
    user_id,
    COUNT(*) as order_count,
    SUM(amount) as total_amount
FROM orders
WHERE created_at >= '2026-01-01'
GROUP BY user_id;

5.4 监控指标

pgrust 提供了额外的监控视图：

-- 查看线程状态
SELECT * FROM pgrust_thread_stats;
-- 输出：
-- thread_id | state     | current_query      | cpu_time
-- ----------|-----------|--------------------|----------
-- 1         | running   | SELECT * FROM ...  | 12.5ms
-- 2         | waiting   | idle               | 0ms
-- 3         | running   | INSERT INTO ...    | 8.3ms

-- 查看向量化执行统计
SELECT * FROM pgrust_vectorized_stats;
-- 输出：
-- query_pattern          | batches_processed | simd_efficiency
-- -----------------------|-------------------|----------------
-- SELECT ... FROM orders  | 1024             | 87.5%
-- SELECT ... FROM users   | 512              | 92.3%

-- 查看内存使用
SELECT * FROM pgrust_memory_usage;
-- 输出：
-- component       | allocated | used    | peak
-- ----------------|-----------|---------|----------
-- query_cache     | 128 MB    | 45 MB   | 120 MB
-- buffer_pool     | 4 GB      | 3.2 GB  | 4 GB
-- thread_stacks   | 512 MB    | 128 MB  | 512 MB

六、生产部署考量

6.1 当前限制

pgrust 目前还不适合生产环境，主要限制：

1. 扩展兼容性：原生 PG 扩展（PostGIS、pg_stat_statements 等）需要重新编译或尚未适配
2. 过程语言：PL/Python、PL/Perl、PL/Tcl 等尚未完全支持
3. 稳定性：虽然通过回归测试，但生产场景的边界情况可能暴露问题
4. 性能优化未完成：当前版本主要关注正确性，性能优化正在进行

6.2 迁移路径

如果你考虑未来迁移到 pgrust，建议：

阶段一：测试环境验证

# 使用生产数据快照测试
pg_dump -h production-db -U postgres mydb > backup.sql

# 在 pgrust 中恢复
docker exec -i pgrust psql -U postgres < backup.sql

# 运行应用测试套件
pytest tests/ --db-host=localhost --db-port=5432

阶段二：影子流量

# 配置双写
primary_db:
  host: postgres-primary.internal
  port: 5432
  
shadow_db:  # pgrust 实例
  host: pgrust-shadow.internal
  port: 5432

# 所有写操作发到 primary_db
# 读操作分流到 shadow_db 验证

阶段三：灰度切换

# 逐步增加 pgrust 的流量
canary:
  - weight: 10%
    target: pgrust-canary.internal
  - weight: 90%
    target: postgres-primary.internal

6.3 回滚策略

pgrust 兼容 PG 数据格式，回滚非常简单：

# 如果 pgrust 出问题，直接切回原生 PostgreSQL
# 1. 停止 pgrust
kill -SIGTERM $(cat /var/run/pgrust.pid)

# 2. 启动原生 PostgreSQL（使用同一数据目录）
/usr/lib/postgresql/18/bin/postgres \
  -D /var/lib/postgresql/18/main \
  -c listen_addresses='*' \
  -p 5432

# 3. 验证数据完整性
pg_checksums --check /var/lib/postgresql/18/main

七、与竞品对比

7.1 pgrust vs PostgreSQL

7.2 pgrust vs ClickHouse

7.3 pgrust vs DuckDB

八、未来展望

pgrust 的 Roadmap 提到了几个有趣的方向：

8.1 No-Vacuum 设计

探索替代 MVCC 的方案：

-- 理想状态：更新操作不产生死元组
UPDATE users SET email = 'new@example.com' WHERE id = 123;
-- 直接覆盖原位置，不需要 VACUUM

-- 通过 undo log 实现事务隔离
-- 类似 MySQL InnoDB 的设计

8.2 AI 生成 SQL 的运行时防护

-- 检测 AI 生成的危险 SQL
/*+ AiGenerated(max_rows=1000, timeout=30s) */
SELECT * FROM large_table WHERE complex_condition;

-- 如果预估行数 > 1000 或执行时间 > 30s
-- 自动终止并提示人工审核

8.3 快速 Fork 和分支

-- 创建数据库分支（秒级）
CREATE DATABASE mydb_feature_branch
FROM mydb_production
AT '2026-07-14 10:00:00';

-- 开发测试完成后删除
DROP DATABASE mydb_feature_branch;

这种能力对 CI/CD 场景非常有用——每次 PR 都可以创建一个独立的数据库分支。

九、总结

pgrust 是一个大胆的实验：用 Rust 重写数据库内核，保持行为兼容，探索架构创新。

核心价值：

1. 100% 回归测试通过：不是玩具，是真实的 PostgreSQL 兼容实现
2. 性能飞跃：OLAP 场景快 300 倍，OLTP 场景快 50%
3. 开发门槛降低：Rust 的内存安全和并发安全让扩展开发更简单
4. 架构创新空间：多线程、no-vacuum、向量化执行……可以在不破坏兼容性的前提下探索

局限性：

1. 不适合生产：目前是实验阶段，缺少扩展支持
2. AGPL-3.0 许可证：商业使用有限制
3. 生态不完善：PostGIS 等扩展尚未完全适配

适合谁？

• 数据库内核开发者：研究 PostgreSQL 内部实现的绝佳素材
• 性能敏感场景：OLAP 查询性能提升显著
• 技术预研团队：探索下一代数据库架构

不适合谁？

• 追求稳定的业务：生产环境请继续使用官方 PostgreSQL
• 依赖扩展的项目：PostGIS、pg_stat_statements 等尚未完全支持
• 商业闭源产品：AGPL-3.0 许可证有传染性

pgrust 让我们看到：PostgreSQL 不是不可改变的。在保持 SQL 兼容性的前提下，数据库内核可以更快、更安全、更灵活。这是一场关于"如何在飞行中更换引擎"的精彩实验。

附录：常用命令速查

# Docker 启动
docker run -d --name pgrust -e POSTGRES_PASSWORD=secret malisper/pgrust:v0.1

# 连接
docker exec -it -e PGPASSWORD=secret pgrust psql -h 127.0.0.1 -U postgres

# 从源码构建
cargo build --release --locked --bin postgres

# 初始化数据目录
target/release/postgres --initdb -D /tmp/pgrust-data

# 启动
RUST_MIN_STACK=33554432 target/release/postgres -D /tmp/pgrust-data

# 运行回归测试
PGRUST_BIN="$PWD/target/release/postgres" scripts/run-regression

# 浏览器体验
open https://pgrust.com

参考资源：

• GitHub：https://github.com/malisper/pgrust
• 在线 Demo：https://pgrust.com
• 作者博客：https://malisper.me/pgrust-rebuilding-postgres-in-rust-with-ai/
• Discord 社区：https://discord.gg/FZZ4dbdvwU

本文字数：约 8500 字
发布时间：2026-07-14