为什么 PostgreSQL 的 numeric 类型这么慢?
本页目录
原作者:Andrei Lepikhov,pgEdge。原文发表于 2026 年 10 月 8 日:Why is PostgreSQL's Numeric Type so Slow?。
以下为原文翻译。文中的“我”、测试数据和性能判断均属于原作者;必要的技术说明以“译注”标出。中文翻译与校订:xiongcc。
numeric 类型在 PostgreSQL 中已经存在二十五年有余,期间经历了许多优化和改进。然而,这个类型上的运算,尤其是聚合,看起来仍然不够高效。
PostgreSQL 社区通常会解决那些有相对简单、明确解决方案的问题。那么,numeric 是否存在某些结构上的限制,使数据库难以进一步加快这个类型的运算?
为了让分析更直观,我也会看看 DuckDB 如何处理同样的任务。AI 工具让源码分析和测试方便了许多。
这里需要记住一点:DuckDB 专门面向 OLAP 查询。正如我在此前的文章中提到的,它对运算精确性的要求有所不同;后文也会看到,DuckDB 的开发团队利用了这些差异来提高查询执行效率。
两份执行计划
先看两份 EXPLAIN 输出。第一份按一组共 12 个 numeric 列对表中的行进行分组:
Finalize HashAggregate (actual time=4320 rows=591894 loops=1)
Group Key: _q_000_f_010rref, _q_000_f_008_rrref, ...
Batches: 1 Memory Usage: 1835033kB
Buffers: shared hit=111632
-> Gather (actual time=1441 rows=1582591 loops=1)
Buffers: shared hit=111632
-> Partial HashAggregate (actual time=868 rows=263765.17 loops=6)
Group Key: _q_000_f_010rref, _q_000_f_008_rrref, ...
Batches: 1 Memory Usage: 704537kB
-> Parallel Seq Scan on tt4 t2 (actual time=68 rows=500000.00 loops=6)
Execution Time: 4512.880 ms
第二份执行的是相同查询,但列的类型换成了 double precision。为了这个测试,我们暂时不考虑数值精确性的差异。
Finalize HashAggregate (actual time=1553 rows=591894 loops=1)
Group Key: _q_000_f_008_type, _q_000_f_008_rtref, ...
Batches: 1 Memory Usage: 196641kB
Buffers: shared hit=125000
-> Gather (actual time=596 rows=1577001 loops=1)
Buffers: shared hit=125000
-> Partial HashAggregate (actual time=337 rows=262833 loops=6)
Group Key: _q_000_f_008_type, _q_000_f_008_rtref, ...
Batches: 1 Memory Usage: 90145kB
Buffers: shared hit=125000
-> Parallel Seq Scan on tt4_dbl t2 (actual time=28 rows=500000 loops=6)
Execution Time: 1620.060 ms
速度提高了接近三倍。注意,double precision 版本扫描的页面还更多:约 12.5 万页,而 numeric 版本约为 11.1 万页。但使用 numeric 聚合,内存占用约为前者的九倍。这个类型优化了二十五年多,为什么仍有这么大的性能开销?有没有可能减少,甚至消除这些开销?我们从基本原理看起。
乍看之下,问题似乎出在十进制算术。不过,已有三个尝试通过扩展实现快速十进制类型的项目停滞下来:Pavel Stehule 的 pgDecimal、Feng Tian 的 pgdecimal2,以及 2ndQuadrant 的 fixeddecimal。它们都曾加快算术运算。因此,问题不只在算术本身。
PostgreSQL 为四项设计付出的代价
进入实现细节之前,先看整体设计。
常见数据库都有精确十进制类型。实现较快的那些,往往采用相近的方法:把值保存为普通整数,小数点的位置则单独记录在列的描述信息中。SQL Server、DuckDB、ClickHouse 的 DECIMAL,以及 Arrow、Parquet 中的 decimal,大概都属于这一路径。PostgreSQL 选择了另一条路,作出了以下几项关键设计决定:
- 数值的表示方式不依赖列声明。 其他实现会根据声明的精度选择存储宽度:较窄的数用两到四字节,较宽的数用八到十六字节。在 PostgreSQL 中,类型长度是类型本身的属性,而不是某个列的属性,因此
numeric采用变长表示。 - 小数位数保存在值中,而不是列的描述信息中。 所以,即使列没有指定小数位数,
numeric中的1.5与1.50仍能保留不同的显示形式。 - 结果的小数位数由数据决定,而非事先固定。 除法结果保留多少位,取决于参与运算的数值,而不只是它们的类型。
- 精度上限很宽。 严格来说,
numeric有上限:小数点前最多 131072 位,小数点后最多 16383 位。不过,实际应用中的大部分数值远远达不到这个范围。结果所需空间按实际计算结果分配,而非按列声明预留,因此通常很难遇到这一实现上限导致的溢出。
译注:这里的宽范围针对未指定精度的
numeric。numeric(p,s)仍会约束写入值,超出允许的整数位数会报错;显式声明的精度p最大为 1000。
单独看,每项选择都有道理,而且大多与各行业对精确计算的要求有关。但它们都有成本。后面的“表示方式”讨论第一点,“按值传递”和“元组拆解”讨论随之产生的影响,“中间结果的小数位数”讨论第二、第三点,最后再看十进制计算本身的开销。
我主要用 DuckDB 作对照。它在这四个方面采用了相反的选择,便于看出 PostgreSQL 的开销在哪里,而且源码也可以直接阅读分析。
先介绍几个 PostgreSQL 内部术语:
| 术语 | 含义 |
|---|---|
varlena |
变长值,其开头包含记录长度的头部 |
detoast |
使用值之前,将其取出或展开为所需的表示形式 |
Datum |
查询执行器用来传递值的机器字 |
typmod |
列声明中的精度和小数位数等类型修饰信息,例如 (15,2) |
dscale |
输出时显示的小数位数,保存在值本身之中 |
deform |
将表中的一行拆解为各个列值 |
精确十进制类型的内部表示
PostgreSQL 的 numeric 实现
通用处理器使用二进制。十进制的 0.1 在二进制中是无限循环小数,就像十进制中的 1/3 一样。因此,double precision 存储的是最接近 0.1 的可表示二进制数,而不是精确的 0.1。著名的例子是 0.1 + 0.2 得到 0.30000000000000004。
金额、仓库中的电缆长度、水电费用等,通常按十进制计量。分、利率和舍入规则,也都用十进制数字描述。精确十进制类型的用途就在于此:让 0.1 确实是 0.1,并在规则要求的十进制数位上舍入。
因此,第一项决定是存储十进制数字。这本身并不决定值的宽度和小数点位置。DuckDB 的 DECIMAL 同样是十进制,却采用定长表示。不过,这正是理解 numeric 的起点。
数字分组存储。 每个十进制数字占一个字节会很浪费:一个字节能表示 0 到 255,却只拿来保存 0 到 9。PostgreSQL 的代码中还留有这种表示方式的痕迹,但当前实现每两字节保存一组 0 到 9999 的数。它采用的是以 10000 为基数的位值表示法,与熟悉的十进制类似,只是每个“数字”的取值范围变成了一万种。
为什么是 10000?这与长乘法算法有关:两个“数字”的乘积需要放进一个 int。只从算术上看,小于 sqrt(INT_MAX)、约 46341 的偶数基数都可以。在这些候选中,选择十的幂可以简化输出和按十进制数位舍入;满足条件的最大十的幂就是 10000。
用 weight 定位小数点。 如果用“小数点距开头多少位”记录位置,极大和极小的数就可能积累很长的零串。因此,numeric 保存一个 weight,表示第一个“数字”所对应的 10000 的幂次。数值可以按下式还原:
value = digit[0] * 10000^weight
+ digit[1] * 10000^(weight-1)
+ digit[2] * 10000^(weight-2) + ...
例如,123456.00 的表示如下:
digits: 12 3456
power: 10000^1 10000^0
120000 + 3456 = 123456
对于很小的数,这种设计很有用:0.0000000012 只需要一个取值为 1200 的“数字”,weight 为 -3,不必保存一长串零。
用 dscale 决定显示形式。 1.5 和 1.50 在数值上相等,内部的数字组也相同,但输出不同。这个差异由 dscale 保存,也就是“显示多少位小数”:
1.5 digits: [1, 5000] weight: 0 dscale: 1 -> prints "1.5"
1.50 digits: [1, 5000] weight: 0 dscale: 2 -> prints "1.50"
逐字节看,它们是不同的值,但比较运算必须认为二者相等。这带来了一些额外要求:比较和哈希必须忽略 dscale,输出时却必须保留它。
上述情况针对未指定精度的 numeric。如果列声明为 numeric(15,2),写入时的类型转换会将两者的 dscale 都设置为 2,使它们的表示一致。
符号和特殊值。 符号并未单独占据一个字段,而是与格式标志一起放在头部的高两位中:
00 -> positive NUMERIC_POS
01 -> negative NUMERIC_NEG
10 -> short format NUMERIC_SHORT
11 -> special value NUMERIC_SPECIAL - NaN, +Infinity, -Infinity
译注:
10表示NumericShort格式,此时符号保存在同一头部的另一位。上表的高两位同时编码格式与符号类别,不能把10理解为没有正负号。
特殊值没有数字组,只保留两字节的 numeric 内部头部;加上外层长度头,元组中可占三字节,独立值通常占六字节。此外,数字组序列两端的零会被去掉,所以 1.0000 只保存一个值为 1 的数字组,dscale 为 4。
紧凑存储。 numeric 值还可以使用紧凑存储形式。如果数字数量较少,不超过约 62,就可以使用一字节的长度头,并且无需按通常方式对齐;更长的值使用标准的四字节长度头。同一个类型的不同值,可以采用其中任一形式。
译注:这里需要区分两层头部。外层
varlena能否使用一字节长度头取决于整个值的长度;内层NumericShort则要求dscale <= 63且weight在-64到63之间。“约 62”不能理解为 62 位十进制有效数字。以两字节 numeric 内部头部为例,一字节外层头最多能容纳 62 个 base-10000 数字组,总长为 127 字节。
处理 numeric 的运算函数期望收到标准长度头,因此随时都要准备把带一字节长度头的值展开成标准表示。
实际应用中的数值大多较短,因此,这种展开通常会发生在每个值上,也就带来了额外的动态内存分配和复制。
紧凑格式也有好处:小的 numeric 值,存储起来有时甚至比 bigint 更省空间。pg_column_size 可以显示这一点:
CREATE TABLE t(x numeric(15,2));
INSERT INTO t VALUES (123456.00);
SELECT pg_column_size(x) FROM t; -- 7
SELECT pg_column_size(123456.00::numeric); -- 10
由此可见,一个 numeric 值就是一个自包含的小结构:格式标志、符号、权重、小数位数,以及一串 base-10000 数字组。它携带了描述数值大小和显示形式所需的信息,所以列即使只声明为 numeric,不指定其他属性,也能保存这些值。
这种设计支持灵活、精确的数值处理,同时也增加了存储和处理开销。接下来看看 DuckDB 如何实现精确十进制类型。
DuckDB 的 DECIMAL 实现
DuckDB 同样需要精确十进制数,但选择用整数保存。DECIMAL(15,2) 中的 123456.00 被存储为整数 12345600,没有 base-10000 数字组,也没有 weight 或 dscale:
value = integer / 10^scale
小数点在输出时才被加上。MonetDB 文档对此的描述是:
decimal 类型表示为定长整数,小数点在结果输出时生成。
因此,小数位数成为列类型的属性。在 DuckDB 中执行:
select typeof(1.5), typeof(1.50), typeof(1.500);
-- DECIMAL(2,1) DECIMAL(3,2) DECIMAL(4,3)
PostgreSQL 把小数位数保存在值的 dscale 中,DuckDB 则把它放在类型信息中。同一个数的不同写法,体现为不同的类型,而非同一类型中不同的值表示。把它们放进同一列后,差异立即显现:
CREATE TABLE t AS SELECT * FROM (VALUES (1.5),(1.50),(1.500)) v(x);
-- column type: DECIMAL(4,3)
-- values: '1.500', '1.500', '1.500'
一个列只有一种类型,因此也只有一种小数位数和输出形式。相同的三个值如果存入 PostgreSQL 的无约束 numeric 列,会保留 1、2、3 三种 dscale,输出也不同。
这样便能提前选择合适的物理表示。DuckDB 根据精度采用不同宽度的整数:精度上限分别为 4、9、18、38 位,对应 INT16、INT32、INT64 和 INT128。文档描述了这个分级,源码 decimal.hpp 则用一组特化定义它:
在内部,decimal 根据指定的 WIDTH 使用不同整数类型表示。
选择在查询规划时完成,之后循环执行的是针对具体整数类型的专用函数。从外部也能看到这种宽度差异:导出到 Parquet 时,DECIMAL(15,2) 使用物理类型 INT64,DECIMAL(20,2) 则使用字节数组。Parquet 与 DuckDB 都在 18 和 38 位处出现边界,并非巧合,它们面对的是相同的机器整数限制。
结果是,数值采用普通整数的字节表示。它占用的空间可能比紧凑的 numeric 更多,但加法、乘法等基本运算简单得多。
固定格式也意味着最大值有硬性上限。DuckDB 的 DECIMAL 不支持 NaN、正无穷和负无穷。这大概与需要覆盖常见的 38 位精度范围有关。超出 38 位上限,会在运行时报错。
按值传递,还是按引用传递
PostgreSQL 内部通过 Datum 传递值。它是一个机器字,在 64 位平台上占八字节。如果类型采用按值传递,值就直接放在这个机器字中,例如 bigint。如果采用按引用传递,机器字中保存的则是指针。
numeric 始终按引用传递。因此,每次数值算术运算都需要一个地方保存结果,也就涉及为运算结果分配内存。以加法为例:
bigint: a + b -> one instruction, result in a register
numeric: a + b -> align the scales
-> add
-> check the limits
-> palloc for the result
-> write the result to memory
译注:这是原文的成本示意。按值还是按引用传递,由类型目录中的
typbyval等属性决定,并非每次根据实际值大小选择;bigint的完整 SQL 运算也需要处理溢出,不能严格等同于一条机器指令。
即使限制 numeric 的实现,只要保留较大的小数位数范围和灵活的中间结果上限,值仍然放不进八字节,也就无法转为按值传递。Thomas Munro 在 2017 年讨论 DECFLOAT 的“Decimal64 and Decimal128”邮件中指出过这个障碍:
DECFLOAT(9),也就是 32 位,以及DECFLOAT(17),也就是 64 位,理论上都可以按值传递。但我们没有办法让它们按值传递,同时又让DECFLOAT(34),也就是 128 位,按引用传递。上一次我对这个问题感兴趣时,就卡在这里。这似乎是一个有望获得相当大性能收益的地方,但相关技术限制已经深深嵌入 PostgreSQL。
DuckDB 的做法不同:根据列声明的精度选择物理存储类型。
| 精度 WIDTH | 存储类型 | 字节数 |
|---|---|---|
| 1–4 | INT16 | 2 |
| 5–9 | INT32 | 4 |
| 10–18 | INT64 | 8 |
| 19–38 | INT128 | 16 |
精度不超过 18 位时,值就是一个机器整数,不经过 PostgreSQL 那样的 Datum、指针和逐值 palloc 路径。我在 M4 Pro、单线程、两千万行数据上的测试为:SUM(DECIMAL(18,2)) 耗时 8.7 毫秒,SUM(BIGINT) 耗时 8.5 毫秒。二者之比为 1.02,几乎没有额外的十进制开销:小数位数存在类型信息中,运行时处理的是普通 int64。
但在相同数据上换成 DECIMAL(19,2),测试耗时约为 880 毫秒。18 位到 19 位这个边界上,耗时增加了约一百倍。这个测试里的主要差异来自值的宽度,而非十进制规则本身;DuckDB 的速度很大程度上得益于底层使用 int64。
在 PostgreSQL 中,类型长度和传递方式都是系统目录中类型本身的属性,并不是列的属性。因此,在现有架构下,无法仅根据 numeric 列声明的精度,在这些传递方式之间切换。
元组拆解
进行比较之前,要先从行中取出各列的值,这个过程称为元组拆解,或者 deform。对 numeric 而言,这个过程也更贵。
PostgreSQL 的一行由行头、可能存在的 NULL 位图,以及依次排列的列值构成。要定位第二十列,必须知道它相对行起始位置的偏移。如果前面的列都是定长、也没有 NULL 等因素影响布局,就能计算偏移并缓存在元组描述符中:
20 int4 columns - the offsets are known in advance
+----+----+----+----+----+--- ... ---+----+
| c1 | c2 | c3 | c4 | c5 | |c20 |
+----+----+----+----+----+--- ... ---+----+
0 4 8 12 16 76
offset of c20 = 19 * 4 - computed and cached once.
如果列值是变长的,这个办法就行不通。构建元组描述符的代码中,直接写着这样的规则:不要为定长列之后的列继续缓存偏移。numeric 正属于这种情况。遇到第一个变长列之后,要定位后面的列,就得读取前面值的头部、根据实际长度继续推进:
20 numeric columns - every value has its own length
+------+-----+--------+------+--- ... ---+-----+
| c1 | c2 | c3 | c4 | | c20 |
+------+-----+--------+------+--- ... ---+-----+
0 7 12 21 ???
to find the offset of c20, read the headers of c1...c19 - on every row, again.
译注:图中的偏移用于说明列值区域内的布局,未计入行头、NULL 位图和对齐。实际拆解会在一次处理过程中逐列推进,并在 slot 中保留已拆出的值;并非访问每个后续列都重新从第一列扫描。
PostgreSQL 内核正在优化这部分开销。David Rowley 连续两个开发周期改进元组拆解:PostgreSQL 18 的提交 d28dff3f,将元组描述符中的 104 字节 FormData_pg_attribute 换成了 16 字节的 CompactAttribute。根据提交中的测试,在一张 16 列表上执行 OLAP 聚合,TPS 提升约 10%,最高约 25%,原因是拆解过程中访问的缓存行更少。
后续的“More speedups for tuple deformation”进入 PostgreSQL 19,原文引用的测试平均提升 21%,最高 44%。值得注意的是,这组测试中,一半用例与另一半的差别,仅在于第一列是 INT 还是 TEXT。社区一直在关注变长列对性能的影响。
译注:21% 和 44% 来自开发邮件中 AMD Zen 2、GCC 下的一组补丁测试,测试也包含其他硬件和编译器,结果不尽相同;它们不是 PostgreSQL 19 所有查询或
numeric运算的统一提速幅度。
不过,这并没有消除变长表示本身。numeric 使用变长存储,源于早期就决定支持任意精度数值。换句话说,如果让它变成定长类型,元组遍历就可能更便宜一些。
DuckDB 采用列式存储,没有 PostgreSQL 这种行式元组拆解过程,通常通过数组下标定位值,不必逐列计算偏移。但它也有类似的成本。在默认开启压缩的情况下,扫描 DECIMAL(18,2) 与 DECIMAL(19,2) 的差异很大。对于:
count(*) where v > 5.00
我测得窄类型平均耗时 5–7 毫秒,宽类型约为 380 毫秒。通过 SET force_compression='uncompressed' 关闭压缩后,这个差距消失了。这里几乎没有算术运算,差异应当来自 int128 的解压开销。
在这些测试中,将值送到运算环节的成本,甚至超过运算本身。PostgreSQL 的成本是元组拆解,DuckDB 的成本是解压;它们都与宽度和存储格式有关。
另一方面,整数表示也能利用快速处理路径。这也是为什么,听到“改成浮点数更快”时,需要看看具体实现。DuckDB 的 decimal 列可以使用 BitPacking,而 DOUBLE 使用的是 ALP 压缩。
所以,“精确性需要付出多少资源”,很大程度上取决于具体实现,并不能只由“精确十进制”这个名称判断。
中间结果的小数位数
前面讨论了打包、表示和存储。但在执行计划中,原始值只是运算的输入。运算结果的精度和小数位数可能与输入差别很大,这又会影响计算成本和保存中间结果所需的内存。两个数据库分别怎样处理?
numeric 如何管理中间结果精度
对于两个 bigint 的普通算术运算,结果要么仍是 bigint,要么因超出范围而报错。
numeric 则复杂一些:两个各有 32 位有效数字的数相乘,结果最多需要 64 位;除法还可能产生无限循环小数,例如 1/3。
因此,需要明确的舍入规则。舍入会影响熟悉的代数性质:求和可以保持结合性,但乘积经舍入后不再保证结合性,进而影响聚合运算的重排和并行化。
译注:这里的“求和保持结合性”针对未在中间步骤舍入、也未超出实现范围的精确加法。若每一步都舍入到固定小数位,加法同样可能失去结合性。
numeric并非不支持并行聚合。
PostgreSQL 根据输入值确定算术结果的小数位数:
select 1.5 + 1.50; -- 3.00 (2 digits)
select 2.0 * 3.00; -- 6.000 (3 digits)
select 10.0 / 4; -- 2.5000000000000000 (16 digits)
加法取两个输入中较大的小数位数,乘法取两者之和。除法呢?
select 1 / 3::numeric; -- 0.33333333333333333333 (20 digits)
select 1000000 / 3::numeric; -- 333333.333333333333 (12 digits)
select 0.001 / 3::numeric; -- 0.00033333333333333333 (20 digits)
尽管参数类型相同,结果的小数位数仍然不同。除法会选择能够提供至少 16 位有效数字的小数位数。PostgreSQL 源码注释解释道:
SQL 标准没有规定除法结果的小数位数。在 PostgreSQL 中,我们选择能够提供至少
NUMERIC_MIN_SIG_DIGITS位有效数字的小数位数,使 numeric 的结果精度不低于 float8;同时,结果的小数位数不低于任一输入值的显示小数位数。
为什么要关心中间结果的小数位数?我开始关注这一点,是因为 PVLDB 2023 论文《The FastLanes Compression Layout》,尤其是下面这句话:
我们认为,下一代数据库系统在扫描时,不应急于将列解压为其 SQL 类型,因为该类型可能是一个很宽的整数,例如存储为 64 位整数的 decimal;应当将其解压为足以供查询运算符处理的最小类型。
也就是说,在执行器内部为值采用专门的表示方式,可能同时节省内存并提高算术运算效率。复杂查询树中有许多中间状态,收益可能相当可观。
PostgreSQL 中,每个具体值都有自己的小数位数,因此,算术结果也在执行时动态决定。在规划阶段,可以尝试预测加法和乘法结果的最大精度及小数位数;其他运算则困难得多,按上限预留可能得到过大的范围。同时,numeric 的语义不允许提前把每一步结果都固定成同一种小数位数:
select 1.0 = 1.00; -- true
select (1.0)::text = (1.00)::text; -- false
select hash_numeric(1.0) = hash_numeric(1.00); -- true
统一小数位数后,这种差别就会丢失。许多应用可能不在意,但若要从类型设计上固定下来,就需要另一种具有不同语义的新类型。
小数位数的不确定性还带来额外开销:比较时需要将数值放到相同的尺度上,哈希也不能直接覆盖整个值的字节,而必须按数值的规范形式计算。
译注:PostgreSQL 的
cmp_var_common按符号、weight和数字组比较,并不根据dscale先统一显示小数位数;hash_numeric也忽略dscale,对去除首尾零组后的数字与权重计算哈希。1.0与1.00不会仅因dscale不同而触发一次数值对齐。原文把这种成本概括为“对齐小数位数”,不宜当作这两个函数的具体算法。
这些变长数值操作包含依赖数据的分支,处理器和编译器较难像处理规则整数数组那样组织执行。对于统一的整数循环,可以展开循环,或通过 SIMD 一次处理多个值;出现数据相关分支之后,就更难向量化,分支预测失败也有成本。bigint 的比较可以展开为少量指令,numeric 则需要更复杂的函数逻辑。
再看聚合。sum(numeric) 的中间状态不必是另一个普通 numeric 值,累加结果会随行数增长。PostgreSQL 专门设计了 NumericSumAccum,源码注释说明了原因:
它使用 32 位整数保存数字组,而不是通常的 16 位整数,基数仍为 10000。这样,在任何数字组面临溢出风险之前,可以安全累加最多
NBASE - 1个值,而无需传播进位。
同一段注释还说明:
正数和负数分别累加,保存在
pos_digits和neg_digits中。
也就是说,不必每处理一行就传播进位,可以累加最多 9999 个值后再做;正数和负数也分别积累。这也说明了累加器扩大范围的必要性;sum(bigint) 返回 numeric,同样与累加结果的范围有关。
译注:返回类型与内部累加器应分开看。在支持 128 位整数的构建上,PostgreSQL 的
sum(bigint)可以使用 128 位整数中间状态,最终再转换为numeric;并非所有这类聚合都逐行使用NumericSumAccum。
DuckDB 的 DECIMAL 如何管理中间结果精度
DuckDB 在规划阶段就计算并固定运算结果的小数位数:
select typeof(1.8), typeof(1.9), typeof(1.8*1.9), 1.8*1.9;
-- DECIMAL(2,1) DECIMAL(2,1) DECIMAL(4,2) 3.42
这得益于它的架构:类型附着在结果列上,而不保存在每个值中。运行时,中间值按批次传递,一个批次对应一种类型,小数位数只记录一次。
更准确地说,PostgreSQL 的 numeric 是自描述的值:比较、相加和输出所需的信息都随值携带,因此它可以存放在一个仅声明为 numeric 的列中。DuckDB 的 DECIMAL 则由类型描述这些属性;类型不仅附着于列,也附着于表达式树的节点,不必进入每个值中。
所以,DuckDB 没有 PostgreSQL 那种无约束 DECIMAL:省略参数时,会使用 DECIMAL(18,3)。
DuckDB 是怎样做到的?它通过提前固定类型,消除了运行时决定小数位数的问题。
加法和乘法结果的小数位数,根据输入声明的小数位数计算,在绑定阶段便已确定:加法为 max(s1,s2),乘法为 s1+s2。无须读取数据,规划器就知道结果的表示方式。不过,为了避免切换到更昂贵的整数宽度,结果精度有时会被限制在输入所使用的物理整数范围内。
DuckDB 的源码注释解释了这一选择:
我们不会自动提升到 hugeint,因为 hugeint 会带来较大的性能开销。
乘法也有自己的类型推导逻辑,同样包含 MAX_WIDTH_INT64 的限制。举例来说:
DECIMAL(18,2) * DECIMAL(18,2) -> DECIMAL(18,4) <- should be 36,4
DECIMAL(20,2) * DECIMAL(20,2) -> DECIMAL(38,4) <- input is already int128, the rule did not fire
这会带来什么实际影响?
SELECT cast(999999999999999999 AS decimal(18,0)) * cast(999999999999999999 AS decimal(18,0));
-- Out of Range Error: Overflow in multiplication of DECIMAL(18)
一个数学上可以计算的表达式,会因为引擎为速度限制了结果精度而在运行时报错,这就是这种取舍的代价。
对于除法,DuckDB 不选择十进制结果的小数位数,而是转向浮点计算。文档在“Arithmetic and Internal Representation”一节中写道:
定点十进制数相除,通常无法得到有限位数的十进制展开。因此,凡是涉及定点十进制数的除法,DuckDB 都采用近似浮点运算,并返回浮点类型。
具体运算的类型如下:
typeof(DECIMAL(10,2) / DECIMAL(10,2)) -> DOUBLE 1/3 = 0.3333333333333333
typeof(AVG(DECIMAL(10,2))) -> DOUBLE
typeof(DECIMAL(10,2) % DECIMAL(10,2)) -> DECIMAL(10,2) the remainder stays exact
也就是说,对 DuckDB 中的金额 decimal 列求平均值,返回的是 DOUBLE。原作者据此认为,这不足以满足欧盟条例 1103/97 中相关中间计算“不得舍入或截断”的要求。PostgreSQL 为除法小数位数付出的计算,在 DuckDB 这里被省略了,相应地也不再返回十进制除法结果。
译注:
numeric的1/3同样是有限位十进制近似,并不是无限精确的商;这里的实质区别是十进制结果及其小数位数规则,与二进制浮点结果之间的差异。是否满足具体金额计算规则,还取决于完整的计算与舍入流程,不能仅凭返回类型下结论。
这组设计决定说明,统一小数位数与限制运算精度分别看都很合理,结合起来却可能造成实际限制。设计定长十进制类型时,需要同时考虑这两者。
十进制计算本身的成本
前面讨论的设计都可以作出不同选择。接下来这部分则与十进制表示本身有关:在二进制硬件上处理十进制,常常要乘除十的幂,相关工作只能放在算术运算或输出转换等不同位置完成。
numeric 在算术阶段承担更多成本,转换为十进制文本相对直接。DuckDB 和 MonetDB 则把小数点放到结果输出时处理。成本发生在哪里,会影响不同负载下的表现。
为什么需要乘以十的幂? 以 1.5 和 1.50 相加为例,用十进制系数表示,若一个是 15,另一个是 150,就要先将 15 乘以十,使两者采用相同的小数位数。移动一位相当于乘十,移动两位相当于乘一百,移动 k 位相当于乘 10^k。
舍入可以从相反方向理解:将一个有五位小数的数舍入到两位小数,可以抽象为缩放、舍入,再恢复尺度的过程。
这里的 k 并没有直接写在查询中。对齐小数位数时,它来自两个值的小数位数之差;舍入时,它来自值的小数位数与目标小数位数之差。两者都可能到执行时才知道。
处理器执行整数除法的成本较高,往往需要几十个周期。编译器因此会优化常量除法:如果代码写的是 x / 1000,可以转换成乘一个预先计算的常量,再配合移位。但这种优化需要编译器提前知道除数。
如果除数是运行时决定的 10^k,就无法直接套用同一种常量优化,需要查询相应幂值并执行计算。
译注:以上是原文用整数系数解释缩放成本的模型,不是
numeric.c的逐步算法。PostgreSQL 已按 base-10000 存储数值;加法通过数字组和weight对齐,round_var在数字组内完成必要舍入,并不是每次都执行“整数除以10^k、舍入、再乘回去”。
numeric 得到了什么? 数字本来就按四位十进制一组保存,numeric_out 可以直接将这些组转换成字符串。若使用二进制整数系数,则需要额外完成整数到十进制文本的转换。
这里要考虑负载:每个以文本形式返回的值都需要输出转换,只有涉及算术的查询才需要算术运算。一条不做计算的 SELECT,也可能要输出大量值。因此,考虑“把 numeric 直接换成 int128”时,也应计算这些附带成本。
如果真的改成 128 位整数呢? 很多“快速 numeric”项目都采用这个方向,但仍有两个问题。
首先,主流平台的通用整数指令以 64 位为主,128 位运算往往由编译器组合实现。128 位乘法可以由几次普通乘法和加法组成;但 x86-64 的 divq 执行的是 128 位被除数除以 64 位除数,商还必须放得进 64 位,并不是通用的 128 位除以 128 位。后一种除法通常需要调用 __udivti3 之类的运行库函数。
因此,换成 int128 并不会让除法本身变成一条便宜的指令。潜在收益更多来自周边开销的减少:palloc、短头展开、结果小数位数计算等。加法同样能从这些变化受益。
其次是范围上限。若要按小数位数 s 计算十进制除法,可以先构造 a * 10^s / b。被除数因此需要额外的数字空间。numeric 可以扩展数字组数组,int128 的空间则固定,通常按 38 位十进制精度使用:
DECIMAL(18,2) / DECIMAL(18,2), result with 6 digits
-> dividend 18 + 6 = 24 digits -> int64 is too small, int128 needed
DECIMAL(38,2) / DECIMAL(38,2), result with 6 digits
-> dividend 38 + 6 = 44 digits -> even int128 is too small
对于这种先放大被除数的直接实现,要保证中间值能放进 int128,输入精度加上所需扩展位数不能超过其容量。超出范围时,就需要更宽的中间表示,例如 int256,或者报错,或者转向浮点数。固定宽度与大范围十进制除法之间,存在实际矛盾。
DuckDB 较少承担运行时对齐尺度的成本,因为输入类型已经说明小数位数。若小数位数相同,执行循环可以直接对整数系数做加法。
还有一个值得注意的优化:逐值溢出检查会增加分支,影响向量化。DuckDB 的优化器会尝试利用列的最小值、最大值统计信息,证明特定运算不会溢出;成功后,可以换用省去检查的运算实现,相关代码可见 PropagateNumericStats。于是,循环中剩下规则的整数运算,编译器更容易将其向量化。
最后还有一个细节。在 DuckDB 中,改变结果的物理宽度,也会造成明显成本。DECIMAL(9,2) * DECIMAL(9,2) 得到 DECIMAL(18,4),结果跨过 int32 到 int64 的边界,两个输入都需要转换。我测得耗时 40.0 毫秒,而直接使用 DECIMAL(18,2)、结果仍留在 int64 的对应测试为 13.9 毫秒。窄类型在这个测试中反而慢了近三倍。
由此看来,不能简单说某种十进制类型总是便宜。关键在于昂贵路径何时出现、出现多频繁。PostgreSQL 要处理值自身携带的小数位数和变长表示;DuckDB 的成本则可能集中在整数宽度切换、溢出处理和解压等环节。
可以继续优化的方向
回到开头的问题,各项设计的成本可以归纳如下:
| 设计决定 | 原文归纳的成本 |
|---|---|
| 表示方式不依赖列声明 | 变长表示、运算结果的内存分配、短长度头展开,以及元组拆解时偏移缓存的限制 |
| 小数位数保存在值中 | 比较和哈希必须处理数值语义,而不能简单比较或哈希整个值的字节;具体算法见前文译注 |
| 结果小数位数由数据决定 | 中间结果的表示需要在运行时处理,聚合还需要 NumericSumAccum 等专门状态 |
| 精度上限很宽 | 按结果的实际需求分配空间,而非只依赖固定宽度的列声明 |
numeric 的表示让十进制文本输出较为直接,同时在处理数值时承担了灵活表示的成本。“直接保存成 int128”看似简单,却还要面对除法中间值的范围、输出转换及类型语义等问题。
在现有精确十进制类型的设计框架下,值得继续寻找的优化点不只在算术算法本身,也在周边环节:palloc、短长度头展开,以及小数位数的计算。
这就是本文的判断:numeric 的性能不能只归因于“十进制算术慢”。它还与几项长期保留、各有理由的设计决定有关。接下来能怎样改进,以及能改进多少,仍值得继续研究。
原文资料与技术核对
- 原文:Andrei Lepikhov / pgEdge。本文保留其技术正文和案例,未收录网站导航与营销内容。
- 类型与语义:PostgreSQL 18 Numeric Types、DuckDB Numeric Types、PostgreSQL 基础类型与 Datum。
- PostgreSQL 实现:numeric.c,REL_18_STABLE,包含
NumericShort、NumericLong、cmp_var_common、hash_numeric、NumericSumAccum和select_div_scale。 - 元组拆解:CompactAttribute 提交 d28dff3f、More speedups for tuple deformation。
- DuckDB 的运算类型推导:arithmetic.cpp,v1.5.5。
- 十进制扩展:pgDecimal、pgdecimal2(原文所链仓库)、fixeddecimal。
- 研究背景:The FastLanes Compression Layout,PVLDB 2023。