From 20bb109ec6910627db0b1660c5422d187fe48b3d Mon Sep 17 00:00:00 2001 From: Richard Guo Date: Tue, 25 Nov 2025 13:00:20 +0900 Subject: [PATCH v1 1/2] Simplify COALESCE arguments using NOT NULL constraints The COALESCE function returns the first of its arguments that is not null. When an argument is proven non-null, if it is the first non-null-constant argument, the entire COALESCE expression can be replaced by that argument. If it is a subsequent argument, all following arguments can be dropped, since they will never be reached. Currently, we perform this simplification for Const arguments. Since we now have the NOT NULL attribute information available during constant folding, we can extend this simplification to Var arguments. This can help avoid the overhead of evaluating unreachable arguments. It can also lead to better plans when the first argument is a NOT NULL column and thus replaces the expression, as the planner no longer has to treat the expression as non-strict, and can also leverage index scans on that column. --- src/backend/optimizer/util/clauses.c | 17 +++++-- .../regress/expected/generated_virtual.out | 48 ++++++++++--------- src/test/regress/sql/generated_virtual.sql | 11 +++-- 3 files changed, 44 insertions(+), 32 deletions(-) diff --git a/src/backend/optimizer/util/clauses.c b/src/backend/optimizer/util/clauses.c index 202ba8ed4bb..b85715ab274 100644 --- a/src/backend/optimizer/util/clauses.c +++ b/src/backend/optimizer/util/clauses.c @@ -3318,10 +3318,10 @@ eval_const_expressions_mutator(Node *node, context); /* - * We can remove null constants from the list. For a - * non-null constant, if it has not been preceded by any - * other non-null-constant expressions then it is the - * result. Otherwise, it's the next argument, but we can + * We can remove null constants from the list. For a + * nonnullable expression, if it has not been preceded by + * any non-null-constant expressions then it is the + * result. Otherwise, it's the next argument, but we can * drop following arguments since they will never be * reached. */ @@ -3334,6 +3334,15 @@ eval_const_expressions_mutator(Node *node, newargs = lappend(newargs, e); break; } + if (IsA(e, Var) && context->root && + var_is_nonnullable(context->root, (Var *) e, false)) + { + if (newargs == NIL) + return e; /* first expr */ + newargs = lappend(newargs, e); + break; + } + newargs = lappend(newargs, e); } diff --git a/src/test/regress/expected/generated_virtual.out b/src/test/regress/expected/generated_virtual.out index dde325e46c6..249e68be654 100644 --- a/src/test/regress/expected/generated_virtual.out +++ b/src/test/regress/expected/generated_virtual.out @@ -1509,10 +1509,11 @@ create table gtest32 ( a int primary key, b int generated always as (a * 2), c int generated always as (10 + 10), - d int generated always as (coalesce(a, 100)), - e int + d int generated always as (coalesce(f, 100)), + e int, + f int ); -insert into gtest32 values (1), (2); +insert into gtest32 (a, f) values (1, 1), (2, 2); analyze gtest32; -- Ensure that nullingrel bits are propagated into the generation expressions explain (costs off) @@ -1591,46 +1592,47 @@ where coalesce(t2.b, 1) = 2 or t1.a is null; -- Ensure that the generation expressions are wrapped into PHVs if needed explain (verbose, costs off) select t2.* from gtest32 t1 left join gtest32 t2 on false; - QUERY PLAN ---------------------------------------------------------------- + QUERY PLAN +--------------------------------------------------------------------- Nested Loop Left Join - Output: t2.a, (t2.a * 2), (20), (COALESCE(t2.a, 100)), t2.e + Output: t2.a, (t2.a * 2), (20), (COALESCE(t2.f, 100)), t2.e, t2.f Join Filter: false -> Seq Scan on generated_virtual_tests.gtest32 t1 - Output: t1.a, t1.b, t1.c, t1.d, t1.e + Output: t1.a, t1.b, t1.c, t1.d, t1.e, t1.f -> Result - Output: t2.a, t2.e, 20, COALESCE(t2.a, 100) + Output: t2.a, t2.e, t2.f, 20, COALESCE(t2.f, 100) Replaces: Scan on t2 One-Time Filter: false (9 rows) select t2.* from gtest32 t1 left join gtest32 t2 on false; - a | b | c | d | e ----+---+---+---+--- - | | | | - | | | | + a | b | c | d | e | f +---+---+---+---+---+--- + | | | | | + | | | | | (2 rows) explain (verbose, costs off) -select * from gtest32 t group by grouping sets (a, b, c, d, e) having c = 20; - QUERY PLAN ------------------------------------------------------ +select * from gtest32 t group by grouping sets (a, b, c, d, e, f) having c = 20; + QUERY PLAN +-------------------------------------------------------- HashAggregate - Output: a, ((a * 2)), (20), (COALESCE(a, 100)), e + Output: a, ((a * 2)), (20), (COALESCE(f, 100)), e, f Hash Key: t.a Hash Key: (t.a * 2) Hash Key: 20 - Hash Key: COALESCE(t.a, 100) + Hash Key: COALESCE(t.f, 100) Hash Key: t.e + Hash Key: t.f Filter: ((20) = 20) -> Seq Scan on generated_virtual_tests.gtest32 t - Output: a, (a * 2), 20, COALESCE(a, 100), e -(10 rows) + Output: a, (a * 2), 20, COALESCE(f, 100), e, f +(11 rows) -select * from gtest32 t group by grouping sets (a, b, c, d, e) having c = 20; - a | b | c | d | e ----+---+----+---+--- - | | 20 | | +select * from gtest32 t group by grouping sets (a, b, c, d, e, f) having c = 20; + a | b | c | d | e | f +---+---+----+---+---+--- + | | 20 | | | (1 row) -- Ensure that the virtual generated columns in ALTER COLUMN TYPE USING expression are expanded diff --git a/src/test/regress/sql/generated_virtual.sql b/src/test/regress/sql/generated_virtual.sql index 2911439776c..81152b39a79 100644 --- a/src/test/regress/sql/generated_virtual.sql +++ b/src/test/regress/sql/generated_virtual.sql @@ -817,11 +817,12 @@ create table gtest32 ( a int primary key, b int generated always as (a * 2), c int generated always as (10 + 10), - d int generated always as (coalesce(a, 100)), - e int + d int generated always as (coalesce(f, 100)), + e int, + f int ); -insert into gtest32 values (1), (2); +insert into gtest32 (a, f) values (1, 1), (2, 2); analyze gtest32; -- Ensure that nullingrel bits are propagated into the generation expressions @@ -859,8 +860,8 @@ select t2.* from gtest32 t1 left join gtest32 t2 on false; select t2.* from gtest32 t1 left join gtest32 t2 on false; explain (verbose, costs off) -select * from gtest32 t group by grouping sets (a, b, c, d, e) having c = 20; -select * from gtest32 t group by grouping sets (a, b, c, d, e) having c = 20; +select * from gtest32 t group by grouping sets (a, b, c, d, e, f) having c = 20; +select * from gtest32 t group by grouping sets (a, b, c, d, e, f) having c = 20; -- Ensure that the virtual generated columns in ALTER COLUMN TYPE USING expression are expanded alter table gtest32 alter column e type bigint using b; -- 2.39.5 (Apple Git-154)