DuckDB 1.5.3 深度实战：Quack 协议让嵌入式数据库变身分布式利器——2026年完全指南
2026年5月20日，DuckDB 发布了 v1.5.3。这个"补丁版本"却带来了一个颠覆性功能：Quack——DuckDB 官方客户端-服务器协议。从此，"分析界的 SQLite"不再局限于单进程，正式进军分布式场景。
一、背景：为什么 DuckDB 需要 Quack？
1.1 DuckDB 的基因：嵌入式、进程内、列式分析
DuckDB 自 2019 年发布以来，一直走的是嵌入式路线——没有独立的服务进程，没有网络协议，所有操作都在调用方的进程内完成。这种设计带来了巨大的优势：
- 零部署成本：
pip install duckdb一行搞定，无需配置数据库服务器 - 零网络开销：没有序列化/反序列化的代价，函数调用级别的数据访问
- 嵌入式友好：直接嵌入到 Python、Node.js、Rust、Go 等应用中
这种架构在数据科学、Jupyter Notebook、单机 ETL 等场景下表现极其出色。但问题也随之而来。
1.2 痛点：单进程写入的天然瓶颈
当一个团队或服务需要在同一份数据上同时进行读写操作时，嵌入式架构就力不从心了：
# 进程 A：写入遥测数据
import duckdb
conn = duckdb.connect("telemetry.duckdb")
conn.execute("INSERT INTO events VALUES (?, ?, ?)", (event_id, ts, payload))
# 进程 B：同时查询仪表盘
import duckdb
conn = duckdb.connect("telemetry.duckdb")
conn.execute("SELECT COUNT(*) FROM events WHERE ts > now() - interval '1 hour'")
SQLite 用 WAL 模式支持并发读，但写仍然是串行的。DuckDB 的情况更复杂——它在内存中维护了大量状态（缓冲池、Catalog 信息、事务状态），多进程同时修改这些状态需要极其复杂的同步机制。
1.3 野路子：社区的曲线救国方案
在 Quack 之前，社区已经搞出了不少"伪分布式"方案：
- MotherDuck：自建了专有的客户端-服务器协议，提供云端的 DuckDB 托管
- Arrow Flight SQL：通过 Arrow 格式序列化查询结果，再用 Flight 协议传输
- 自建 RPC 服务：用 FastAPI/Flask 包一层 DuckDB，暴露 HTTP 接口
- EleDucken：在 PostgreSQL 里跑 DuckDB（pg_duckdb 扩展），借用 PG 的网络能力
这些方案要么引入了额外依赖，要么性能开销巨大，要么维护成本高。DuckDB 团队终于坐不住了。
二、Quack 协议：从设计哲学到技术架构
2.1 设计理念：站在巨人的肩膀上
Quack 诞生于 2026 年，DuckDB 团队获得了从零设计数据库通信协议的奢侈机会。他们仔细研究了现有的数据库协议：
| 协议 | 核心思想 | 优点 | 缺点 |
|---|---|---|---|
| PostgreSQL Wire Protocol | 二进制流，自定义消息格式 | 成熟稳定 | 协议复杂，扩展困难 |
| MySQL Protocol | 文本/二进制混合 | 广泛兼容 | 历史包袱重 |
| Arrow Flight SQL | 基于 gRPC + Arrow | 列式传输高效 | gRPC 依赖重，序列化开销 |
| HTTP-based (Quack) | 基于 HTTP/2 | 简单、穿透防火墙 | 需要精心设计 |
Quack 最终选择了 基于 HTTP 的方案，理由很充分：
- 基础设施成熟：HTTP/2 天然支持多路复用、流式传输、加密（TLS）
- 穿透性强：在任何网络环境下都能工作，不需要额外端口
- 调试友好：可以用 curl、浏览器开发者工具直接调试
- 生态丰富：负载均衡、反向代理、认证中间件全部现成
2.2 核心架构
┌─────────────────┐ ┌─────────────────┐
│ DuckDB Client │ │ DuckDB Server │
│ (进程内) │ Quack │ (进程内) │
│ │ ◄──────► │ │
│ ATTACH 'quack: │ HTTP/2 │ quack_serve( │
│ remote:5432' │ Protocol│ 'quack:...') │
│ │ │ │
│ 本地数据 + │ │ 服务端数据库 │
│ 远程数据视图 │ │ 完整读写能力 │
└─────────────────┘ └─────────────────┘
关键设计决策：
- 对等架构：任何 DuckDB 实例都可以同时是客户端和服务器
- 透明代理：远程数据库通过
ATTACH语句挂载，对用户来说就像本地表 - 流式传输：大数据集不需要一次性加载到内存，按需流式获取
- Token 认证：简单的共享密钥认证，适合内部网络
三、快速上手：5 分钟搭建你的第一个 Quack 集群
3.1 安装 DuckDB 1.5.3
# macOS / Linux
curl https://install.duckdb.org | sh
# Python
pip install duckdb --upgrade
# Node.js
npm install @duckdb/node-api
# Go
go get github.com/duckdb/duckdb-go/v2
# Rust
cargo add duckdb --features bundled
3.2 启动服务端
-- 服务端 DuckDB CLI
CALL quack_serve(
'quack:localhost',
token = 'my_secret_token'
);
-- 创建测试数据
CREATE TABLE sensor_readings AS
SELECT
range AS id,
'sensor_' || (range % 10) AS device_id,
random() * 100 AS temperature,
random() * 50 AS humidity,
'2026-05-20 00:00:00'::TIMESTAMP + (range * INTERVAL '1 minute') AS reading_time
FROM range(100000);
3.3 连接客户端
-- 客户端 DuckDB CLI（另一个终端）
CREATE SECRET (
TYPE quack,
TOKEN 'my_secret_token'
);
ATTACH 'quack:localhost' AS remote;
-- 像查询本地表一样查询远程表
SELECT device_id, AVG(temperature) AS avg_temp
FROM remote.sensor_readings
GROUP BY device_id
ORDER BY avg_temp DESC;
就这么简单。没有配置文件，没有端口管理，没有 SSL 证书。一个 ATTACH 语句，远程数据库变成了本地视图。
四、Python 实战：构建遥测数据收集系统
下面我们用 Python 构建一个真实的场景：多个数据采集进程同时写入 DuckDB 服务端，同时有一个分析进程实时查询数据。
4.1 服务端：数据汇聚中心
# server.py
import duckdb
import threading
import time
def start_server():
"""启动 DuckDB 服务端并初始化数据库"""
conn = duckdb.connect("telemetry.db")
# 启动 Quack 服务
conn.execute("""
CALL quack_serve(
'quack:0.0.0.0:5432',
token = 'prod_token_2026'
)
""")
# 初始化表结构
conn.execute("""
CREATE TABLE IF NOT EXISTS events (
id BIGINT,
source VARCHAR,
event_type VARCHAR,
payload JSON,
created_at TIMESTAMP DEFAULT current_timestamp
)
""")
# 创建索引提升查询性能
conn.execute("CREATE INDEX IF NOT EXISTS idx_events_type ON events(event_type)")
conn.execute("CREATE INDEX IF NOT EXISTS idx_events_time ON events(created_at)")
conn.execute("CREATE INDEX IF NOT EXISTS idx_events_source ON events(source)")
print("[Server] DuckDB Quack 服务已启动，监听 quack://0.0.0.0:5432")
print("[Server] 等待客户端连接...")
# 保持服务运行
while True:
time.sleep(1)
if __name__ == "__main__":
start_server()
4.2 数据采集客户端
# collector.py
import duckdb
import uuid
import json
import random
import time
from datetime import datetime
def create_collector(collector_id: str):
"""创建一个数据采集客户端"""
conn = duckdb.connect(":memory:") # 本地内存数据库
# 连接远程 DuckDB 服务
conn.execute("""
CREATE SECRET (
TYPE quack,
TOKEN 'prod_token_2026'
)
""")
conn.execute("ATTACH 'quack:localhost:5432' AS telemetry")
print(f"[Collector-{collector_id}] 已连接到远程 DuckDB 服务")
event_types = [
"page_view", "api_call", "error",
"user_signup", "purchase", "search"
]
batch = []
batch_size = 100
for i in range(1000):
event = {
"id": str(uuid.uuid4().int)[:18],
"source": collector_id,
"event_type": random.choice(event_types),
"payload": json.dumps({
"url": f"/api/v2/resource/{random.randint(1, 1000)}",
"duration_ms": random.randint(10, 5000),
"status_code": random.choice([200, 200, 200, 301, 404, 500])
}),
}
batch.append(tuple(event.values()))
# 批量写入
if len(batch) >= batch_size:
conn.executemany(
"INSERT INTO telemetry.events VALUES (?, ?, ?, ?, current_timestamp)",
batch
)
print(f"[Collector-{collector_id}] 已写入 {len(batch)} 条事件")
batch = []
time.sleep(random.uniform(0.01, 0.05))
# 写入剩余数据
if batch:
conn.executemany(
"INSERT INTO telemetry.events VALUES (?, ?, ?, ?, current_timestamp)",
batch
)
if __name__ == "__main__":
import sys
collector_id = sys.argv[1] if len(sys.argv) > 1 else "default"
create_collector(collector_id)
4.3 分析仪表盘
# dashboard.py
import duckdb
def run_analysis():
"""连接远程 DuckDB 并执行分析查询"""
conn = duckdb.connect(":memory:")
conn.execute("""
CREATE SECRET (
TYPE quack,
TOKEN 'prod_token_2026'
)
""")
conn.execute("ATTACH 'quack:localhost:5432' AS telemetry")
# 实时统计
print("=" * 60)
print("📊 实时遥测仪表盘")
print("=" * 60)
# 1. 事件总量
total = conn.execute(
"SELECT COUNT(*) FROM telemetry.events"
).fetchone()[0]
print(f"\n📌 总事件数: {total:,}")
# 2. 按事件类型分布
print("\n📋 事件类型分布:")
print("-" * 40)
result = conn.execute("""
SELECT
event_type,
COUNT(*) AS cnt,
ROUND(COUNT(*) * 100.0 / SUM(COUNT(*)) OVER (), 1) AS pct
FROM telemetry.events
GROUP BY event_type
ORDER BY cnt DESC
""").fetchall()
for row in result:
bar = "█" * int(row[2] / 2)
print(f" {row[0]:<15} {row[1]:>6} ({row[2]:>5}%) {bar}")
# 3. 每分钟事件吞吐量
print("\n📈 每分钟吞吐量趋势:")
print("-" * 40)
throughput = conn.execute("""
SELECT
date_trunc('minute', created_at) AS minute,
COUNT(*) AS events_per_min
FROM telemetry.events
GROUP BY minute
ORDER BY minute DESC
LIMIT 10
""").fetchall()
for row in throughput:
bar = "▓" * min(int(row[1] / 5), 40)
print(f" {row[0]} {row[1]:>4} events {bar}")
# 4. 数据源贡献
print("\n📡 数据源贡献:")
print("-" * 40)
sources = conn.execute("""
SELECT
source,
COUNT(*) AS cnt
FROM telemetry.events
GROUP BY source
ORDER BY cnt DESC
""").fetchall()
for row in sources:
print(f" {row[0]:<20} {row[1]:>6} events")
# 5. 错误率分析
print("\n⚠️ 错误率分析:")
print("-" * 40)
errors = conn.execute("""
SELECT
event_type,
COUNT(*) FILTER (WHERE json_extract(payload, '$.status_code')::INT >= 400) AS error_count,
COUNT(*) AS total,
ROUND(
COUNT(*) FILTER (WHERE json_extract(payload, '$.status_code')::INT >= 400)
* 100.0 / NULLIF(COUNT(*), 0),
2
) AS error_rate
FROM telemetry.events
GROUP BY event_type
HAVING error_count > 0
ORDER BY error_rate DESC
""").fetchall()
for row in errors:
status = "🔴" if row[3] > 10 else "🟡" if row[3] > 5 else "🟢"
print(f" {status} {row[0]:<15} 错误: {row[1]:>4}/{row[2]:<4} ({row[3]:>5}%)")
if __name__ == "__main__":
run_analysis()
4.4 运行整个系统
# 终端 1：启动服务端
python server.py
# 终端 2-4：启动多个采集器（并发写入）
python collector.py alpha &
python collector.py beta &
python collector.py gamma &
# 终端 5：实时分析
python dashboard.py
这个架构完全基于 DuckDB + Quack，没有 PostgreSQL，没有 Kafka，没有 Redis。对于中小规模的遥测/日志收集场景，这已经足够了。
五、DuckLake + Quack：构建数据湖仓
DuckDB 1.5.3 的另一个重要更新是 DuckLake 现在支持 Quack 作为 Catalog 数据库。
5.1 什么是 DuckLake？
DuckLake 是 DuckDB 的数据湖管理框架，类似于 LakeFS 但更轻量。它提供了：
- Catalog 管理：版本化的数据集元数据
- 数据版本控制：类似 Git 的数据版本管理
- 事务支持：对数据湖的 ACID 操作
- 多格式支持：Parquet、CSV、JSON 等原生支持
5.2 配合 Quack 使用
-- 服务端：启动 Quack 服务
CALL quack_serve(
'quack:0.0.0.0:5432',
token => 'lake_secret'
);
-- 客户端：通过 Quack 连接 DuckLake
INSTALL ducklake;
CREATE SECRET (
TYPE quack, TOKEN 'lake_secret'
);
ATTACH 'ducklake:quack:localhost:5432'
AS lake (DATA_PATH 'data');
USE lake;
-- 创建表（数据以 Parquet 格式存储在 data/ 目录）
CREATE TABLE sales (
id BIGINT,
product VARCHAR,
quantity INT,
price DOUBLE,
sale_date DATE,
region VARCHAR
);
-- 批量写入
INSERT INTO sales VALUES
(1, 'Widget A', 100, 29.99, '2026-05-01', 'North'),
(2, 'Widget B', 50, 49.99, '2026-05-01', 'South'),
(3, 'Gadget X', 200, 19.99, '2026-05-02', 'North'),
(4, 'Gadget Y', 75, 39.99, '2026-05-02', 'East');
-- 查询数据（透明访问 Parquet 文件）
SELECT region, SUM(quantity * price) AS revenue
FROM sales
GROUP BY region
ORDER BY revenue DESC;
这给了你一个极简的数据湖仓方案：
data/
├── sales/
│ ├── part-0.parquet
│ └── part-1.parquet
└── _ducklake/
└── catalog.db # Quack 连接的远程 catalog
不需要 AWS S3，不需要 Delta Lake，不需要复杂的 Spark 集群。一台服务器 + Quack + DuckLake，就是你的完整数据湖。
六、Iceberg 集成：企业级表格格式支持
DuckDB 1.5.2 到 1.5.3 期间，Iceberg 扩展迎来了大量功能更新，让 DuckDB 可以作为完整的 Iceberg 客户端使用。
6.1 核心新特性
- MERGE INTO 支持：对 Iceberg 表执行 upsert 操作
- 分区表写入：支持
truncate和bucket分区转换 - CTAS via ADBC：通过 ADBC 接口创建新表
- ALTER TABLE 支持：修改 Iceberg 表结构
- GEOMETRY 类型：支持地理空间数据
6.2 MERGE INTO 实战
-- 安装 Iceberg 扩展
INSTALL iceberg;
LOAD iceberg;
-- 从 Parquet 创建 Iceberg 表
CREATE TABLE orders_iceberg
AS SELECT * FROM read_parquet('orders/*.parquet');
-- MERGE INTO：实现 upsert 语义
MERGE INTO orders_iceberg AS target
USING (
SELECT * FROM read_parquet('incremental/orders_20260520.parquet')
) AS source
ON target.order_id = source.order_id
WHEN MATCHED AND source.status != 'cancelled' THEN
UPDATE SET
status = source.status,
updated_at = source.updated_at
WHEN NOT MATCHED THEN
INSERT (order_id, customer_id, amount, status, created_at)
VALUES (source.order_id, source.customer_id, source.amount,
source.status, source.created_at);
6.3 分区表操作
-- 创建分区 Iceberg 表
CREATE TABLE page_views_ice (
url VARCHAR,
user_id BIGINT,
view_time TIMESTAMP,
duration_ms BIGINT
)
PARTITION BY (truncate(view_time, 'day'));
-- 写入分区表
INSERT INTO page_views_ice
SELECT * FROM read_parquet('pageviews/*.parquet');
-- 查询时自动分区裁剪
SELECT
date_trunc('day', view_time) AS day,
COUNT(*) AS views,
AVG(duration_ms) AS avg_duration
FROM page_views_ice
WHERE view_time >= '2026-05-01' AND view_time < '2026-06-01'
GROUP BY day
ORDER BY day;
七、AWS 扩展：云原生数据访问
7.1 IRSA 支持
DuckDB AWS 扩展新增了 web_identity 链类型，支持 IAM Roles for Service Accounts (IRSA)。这意味着在 EKS 或 OpenShift 上运行的 DuckDB 可以直接使用 Kubernetes Service Account 关联的 IAM 角色，无需手动管理 AWS 凭证。
-- 配置 IRSA 认证
CREATE SECRET (
TYPE s3,
PROVIDER credential_chain,
CHAIN 'web_identity'
);
-- 查询 S3 上的数据
SELECT * FROM read_parquet('s3://my-bucket/analytics/*.parquet');
7.2 RDS/Aurora IAM 认证
AWS 扩展现在支持对 RDS/Aurora 上的 PostgreSQL 数据库进行 IAM 认证：
-- 使用 IAM 认证连接 RDS PostgreSQL
ATTACH 'postgresql:user=db_user@my-cluster.xxxx.us-east-1.rds.amazonaws.com'
AS aurora (TYPE postgres, IAM_AUTH true);
-- 直接查询 Aurora 中的数据
SELECT * FROM aurora.public.orders
WHERE created_at > current_date - interval '7 days';
这对于需要同时分析 Aurora 中结构化数据和 S3 上非结构化数据的混合场景非常实用。
八、性能优化：让 Quack 飞起来
8.1 网络层优化
DuckDB 1.5.0 引入了 curl 作为网络栈，取代了之前的自实现 HTTP 客户端。1.5.3 进一步完善了网络层：
-- 配置 HTTP 代理（企业网络环境）
SET http_proxy = 'http://proxy.company.com:8080';
SET https_proxy = 'http://proxy.company.com:8080';
-- 现在 DuckDB 的所有网络操作都会走代理，包括扩展安装
INSTALL httpfs;
LOAD httpfs;
8.2 查询下推
Quack 的一个重要优化是 查询下推——尽量在服务端完成计算，只传输必要的结果集。
-- ❌ 差：拉取全部数据到客户端再过滤
SELECT * FROM remote.sensor_readings
WHERE temperature > 80;
-- ✅ 好：WHERE 条件会被下推到服务端执行
-- Quack 会自动优化，但显式写清楚有助于理解
SELECT device_id, temperature, reading_time
FROM remote.sensor_readings
WHERE temperature > 80
AND reading_time > '2026-05-20'
ORDER BY temperature DESC
LIMIT 100;
8.3 批量操作优化
# ❌ 差：逐条插入（每条一个网络往返）
for event in events:
conn.execute("INSERT INTO remote.events VALUES (?, ?, ?)", event)
# ✅ 好：批量插入（一个网络往返）
conn.executemany("INSERT INTO remote.events VALUES (?, ?, ?)", events)
# ✅ 更好：使用 COPY 命令（流式传输，最小化内存占用）
conn.execute("""
COPY remote.events FROM 'local_events.csv'
(DELIMITER ',', HEADER true)
""")
8.4 jemalloc 内存分配器
DuckDB 1.5.3 将 jemalloc 作为静态链接库集成到核心中，替代了默认的 glibc malloc。jemalloc 在高并发分配/释放场景下表现显著更好：
- 减少内存碎片
- 提高多线程分配性能
- 更稳定的内存使用模式
这对于 Quack 服务端尤为重要——当多个客户端同时发来查询时，内存分配器的性能直接影响响应延迟。
九、Rust 集成：构建高性能数据服务
DuckDB 的 Rust 绑定非常成熟，适合构建高性能的数据服务。
use duckdb::{params, Connection, Result};
fn main() -> Result<()> {
// 创建本地连接
let conn = Connection::open_in_memory()?;
// 配置 Quack 认证
conn.execute_batch(
"CREATE SECRET (TYPE quack, TOKEN 'rust_client_secret')"
)?;
// 连接远程 DuckDB
conn.execute_batch(
"ATTACH 'quack:localhost:5432' AS analytics"
)?;
// 查询远程数据
let mut stmt = conn.prepare(
"SELECT region, SUM(revenue) AS total
FROM analytics.sales
GROUP BY region
ORDER BY total DESC"
)?;
let sales_by_region: Vec<(String, f64)> = stmt.query_map([], |row| {
Ok((row.get(0)?, row.get(1)?))
})?.filter_map(|r| r.ok()).collect();
println!("📊 各区域销售额:");
for (region, total) in &sales_by_region {
println!(" {}: ¥{:.2}", region, total);
}
// 写入数据到远程
let mut insert_stmt = conn.prepare(
"INSERT INTO analytics.events VALUES (?, ?, ?, ?, current_timestamp)"
)?;
let events = vec![
("rust_service", "api_call", r#"{"endpoint": "/health"}"#),
("rust_service", "api_call", r#"{"endpoint": "/metrics"}"#),
];
for event in &events {
insert_stmt.execute(params![event.0, event.1, event.2])?;
}
println!("✅ 已写入 {} 条事件", events.len());
Ok(())
}
Cargo.toml:
[package]
name = "duckdb-quack-client"
version = "0.1.0"
edition = "2024"
[dependencies]
duckdb = { version = "1.5.3", features = ["bundled"] }
十、生产部署最佳实践
10.1 安全配置
-- 生产环境安全配置
-- 1. 使用强 Token
CALL quack_serve(
'quack:0.0.0.0:5432',
token => 'CHANGE_ME_TO_A_LONG_RANDOM_STRING_AT_LEAST_32_CHARS'
);
-- 2. 在 Nginx 反向代理后启用 TLS
-- nginx.conf:
-- upstream duckdb {
-- server 127.0.0.1:5432;
-- }
-- server {
-- listen 443 ssl;
-- server_name db.yourcompany.com;
-- ssl_certificate /path/to/cert.pem;
-- ssl_certificate_key /path/to/key.pem;
-- location / {
-- proxy_pass http://duckdb;
-- proxy_http_version 1.1;
-- }
-- }
10.2 监控
-- 服务端监控查询
SELECT * FROM duckdb_queries(); -- 当前执行的查询
SELECT * FROM duckdb_memory(); -- 内存使用情况
-- 自定义监控表
CREATE TABLE _metrics (
metric_name VARCHAR,
metric_value DOUBLE,
recorded_at TIMESTAMP DEFAULT current_timestamp
);
-- 定期记录
INSERT INTO _metrics (metric_name, metric_value)
SELECT 'total_rows', COUNT(*) FROM events;
10.3 备份策略
# backup.py
import duckdb
import shutil
from pathlib import Path
from datetime import datetime
def backup_database(db_path: str, backup_dir: str):
"""安全备份数据库文件"""
timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
backup_path = f"{backup_dir}/duckdb_backup_{timestamp}.duckdb"
# 使用 DuckDB 的 CHECKPOINT 确保数据一致性
conn = duckdb.connect(db_path)
conn.execute("CHECKPOINT")
conn.close()
# 复制文件（DuckDB 单文件设计使得备份极其简单）
shutil.copy2(db_path, backup_path)
print(f"✅ 备份完成: {backup_path}")
# 清理旧备份（保留最近 7 天）
backup_path = Path(backup_dir)
for old in backup_path.glob("duckdb_backup_*.duckdb"):
age = datetime.now() - datetime.fromtimestamp(old.stat().st_mtime)
if age.days > 7:
old.unlink()
print(f"🗑️ 清理旧备份: {old.name}")
backup_database("telemetry.db", "./backups")
十一、Quack 的局限性（诚实的技术评测）
作为一个负责任的技术博主，我不能只说好话。以下是 Quack 目前已知的局限性：
11.1 Beta 状态
Quack 目前仍处于 Beta 阶段，协议、函数名、行为都可能在后续版本中发生 Breaking Changes。DuckDB 团队计划在 2026 年秋季随 DuckDB v2.0 一起发布生产就绪版本。如果你现在要在生产环境使用，需要做好升级时可能需要适配的准备。
11.2 单服务端瓶颈
Quack 目前是 单服务端架构，一个 DuckDB 实例就是一个服务端，没有内置的分片、复制或故障转移。如果你的写入量超过单机承受能力，目前需要自己在上层做分片路由。这和 PostgreSQL 主从架构相比还有差距。
11.3 没有细粒度权限控制
目前的认证只有一个共享 Token，没有用户级别的权限管理。在多租户场景下，你需要在应用层自己实现权限隔离。
11.4 并发写入性能待验证
虽然 Quack 支持多客户端并发写入，但在高并发场景下的具体性能数据还没有官方 benchmark。DuckDB 团队也没有公布 QPS 上限。
11.5 适合什么场景？
✅ 适合：
- 小团队内部的数据共享（10 个客户端以内）
- 数据科学团队的协作分析
- 微服务的本地数据汇总
- CI/CD 流水线的测试数据共享
- 边缘计算节点的数据回传
❌ 暂不适合：
- 大规模分布式数据库（用 PostgreSQL/CockroachDB/TiDB）
- 需要强一致性的金融系统
- 需要细粒度权限控制的 SaaS 平台
- PB 级数据仓库（用 Snowflake/ClickHouse）
十二、总结：DuckDB 的身份演变
从 2019 年到 2026 年，DuckDB 走过了一条清晰的进化路线：
2019: 嵌入式 OLAP 数据库（"分析界的 SQLite"）
2024: 多格式数据访问（Parquet/CSV/JSON/HTTP/ICEBERG）
2026: Quack 协议加持 → "能联网的分析引擎"
2026 秋: DuckDB v2.0 + Quack GA → "轻量级分布式数据平台"
Quack 的推出并不意味着 DuckDB 要变成另一个 PostgreSQL。它的定位很清晰：在保持嵌入式数据库简洁性的同时，补充缺失的多进程协作能力。
作为一个程序员，我欣赏这种务实的设计哲学：
- 不搞大而全：没有花里胡哨的分布式共识算法，就是简单的 HTTP 协议
- 零学习成本：一个
ATTACH语句搞定，会 DuckDB 就会用 Quack - 渐进增强：你可以在单机模式和 Quack 模式之间无缝切换
- 生态开放：HTTP 协议意味着任何语言、任何框架都能轻松集成
如果你正在寻找一个轻量级的数据共享方案，DuckDB 1.5.3 + Quack 值得一试。它可能不会替代你的 PostgreSQL 或 MySQL，但它一定能在某个场景下让你感叹："原来这事可以这么简单。"
参考资源：