From 553e9403fbdc6f1066566619393791ae9ebf61c2 Mon Sep 17 00:00:00 2001 From: Rui Zhao Date: Thu, 12 Nov 2026 23:09:00 +0800 Subject: [PATCH] Lock composite SRF result types before copying their descriptors DECLARE CURSOR builds the expected result descriptor before calling the function. Locking in plpgsql_estate_setup() leaves ALTER TYPE free to change the row type before FETCH, causing a column-count mismatch. Move the lock to init_sexpr(), before the caller copies the descriptor. This covers both FunctionScan and ProjectSet, including cached plans and domains over composites. Keep the lock until transaction end. Extend rowtypes-alter with both scan forms, a domain, and SPI plan reuse. Also synchronize the expected comments changed by v2-0005. --- src/backend/executor/execSRF.c | 14 ++ src/pl/plpgsql/src/pl_exec.c | 15 -- .../isolation/expected/rowtypes-alter.out | 139 ++++++++++++++++++ src/test/isolation/specs/rowtypes-alter.spec | 49 ++++++ src/test/regress/expected/alter_table.out | 12 +- 5 files changed, 209 insertions(+), 20 deletions(-) diff --git a/src/backend/executor/execSRF.c b/src/backend/executor/execSRF.c index 3cd6b1708bc..c45fc19e063 100644 --- a/src/backend/executor/execSRF.c +++ b/src/backend/executor/execSRF.c @@ -25,7 +25,9 @@ #include "miscadmin.h" #include "nodes/nodeFuncs.h" #include "parser/parse_coerce.h" +#include "parser/parse_type.h" #include "pgstat.h" +#include "storage/lmgr.h" #include "utils/acl.h" #include "utils/builtins.h" #include "utils/lsyscache.h" @@ -772,6 +774,18 @@ init_sexpr(Oid foid, Oid input_collation, Expr *node, /* Otherwise, caller should have marked the sexpr correctly */ Assert(sexpr->func.fn_retset == sexpr->funcReturnsSet); + /* + * Lock a named composite SRF result before copying its descriptor here or + * in ExecInitFunctionScan(). ALTER TYPE must wait until transaction end. + */ + if (sexpr->func.fn_retset) + { + Oid typrelid = typeOrDomainTypeRelid(exprType((Node *) node)); + + if (OidIsValid(typrelid)) + LockRelationOid(typrelid, AccessShareLock); + } + /* If function returns set, prepare expected tuple descriptor */ if (sexpr->func.fn_retset && needDescForSRF) { diff --git a/src/pl/plpgsql/src/pl_exec.c b/src/pl/plpgsql/src/pl_exec.c index ef29ae3d009..cfc54dbfd32 100644 --- a/src/pl/plpgsql/src/pl_exec.c +++ b/src/pl/plpgsql/src/pl_exec.c @@ -34,7 +34,6 @@ #include "parser/parse_coerce.h" #include "parser/parse_type.h" #include "plpgsql.h" -#include "storage/lmgr.h" #include "storage/proc.h" #include "tcop/cmdtag.h" #include "tcop/pquery.h" @@ -4062,20 +4061,6 @@ plpgsql_estate_setup(PLpgSQL_execstate *estate, estate->retistuple = func->fn_retistuple; estate->retisset = func->fn_retset; - /* - * Keep named composite SETOF return types stable for the whole function - * execution. This prevents concurrent ALTER TYPE from changing rowshape - * between statement setup and RETURN QUERY execution. - */ - if (estate->retisset && estate->retistuple) - { - Oid typrelid; - - typrelid = typeOrDomainTypeRelid(estate->fn_rettype); - if (OidIsValid(typrelid)) - LockRelationOid(typrelid, AccessShareLock); - } - estate->readonly_func = func->fn_readonly; estate->atomic = true; diff --git a/src/test/isolation/expected/rowtypes-alter.out b/src/test/isolation/expected/rowtypes-alter.out index 6791893bd8b..e3085a3ef69 100644 --- a/src/test/isolation/expected/rowtypes-alter.out +++ b/src/test/isolation/expected/rowtypes-alter.out @@ -158,3 +158,142 @@ t step s3_leader: <... completed> ERROR: row type of datum tuple was altered after the datum's creation + +starting permutation: s1_srf_data s1_begin s1_declare_srf s2_add_column s1_fetch s1_commit s1_call_srf +step s1_srf_data: + SET plan_cache_mode = force_generic_plan; + INSERT INTO rta_tab VALUES (1, '\x4649584d45'); + +step s1_begin: BEGIN; +step s1_declare_srf: DECLARE rta_cur CURSOR FOR SELECT * FROM rta_srf(); +step s2_add_column: + BEGIN; + ALTER TYPE rta_type ADD ATTRIBUTE c int; + ALTER TABLE rta_tab ADD COLUMN c int DEFAULT 99; + COMMIT; + +step s1_fetch: FETCH NEXT FROM rta_cur; +a|b +-+------------ +1|\x4649584d45 +(1 row) + +step s1_commit: COMMIT; +step s2_add_column: <... completed> +step s1_call_srf: SELECT * FROM rta_srf(); +a|b | c +-+------------+-- +1|\x4649584d45|99 +(1 row) + + +starting permutation: s1_srf_data s1_begin s1_declare_target_srf s2_add_column s1_fetch s1_commit s1_call_srf +step s1_srf_data: + SET plan_cache_mode = force_generic_plan; + INSERT INTO rta_tab VALUES (1, '\x4649584d45'); + +step s1_begin: BEGIN; +step s1_declare_target_srf: DECLARE rta_cur CURSOR FOR SELECT rta_srf(); +step s2_add_column: + BEGIN; + ALTER TYPE rta_type ADD ATTRIBUTE c int; + ALTER TABLE rta_tab ADD COLUMN c int DEFAULT 99; + COMMIT; + +step s1_fetch: FETCH NEXT FROM rta_cur; +rta_srf +------------------- +(1,"\\x4649584d45") +(1 row) + +step s1_commit: COMMIT; +step s2_add_column: <... completed> +step s1_call_srf: SELECT * FROM rta_srf(); +a|b | c +-+------------+-- +1|\x4649584d45|99 +(1 row) + + +starting permutation: s1_srf_data s1_begin s1_declare_domain_srf s2_add_column s1_fetch s1_commit s1_call_srf +step s1_srf_data: + SET plan_cache_mode = force_generic_plan; + INSERT INTO rta_tab VALUES (1, '\x4649584d45'); + +step s1_begin: BEGIN; +step s1_declare_domain_srf: DECLARE rta_cur CURSOR FOR SELECT * FROM rta_domain_srf(); +step s2_add_column: + BEGIN; + ALTER TYPE rta_type ADD ATTRIBUTE c int; + ALTER TABLE rta_tab ADD COLUMN c int DEFAULT 99; + COMMIT; + +step s1_fetch: FETCH NEXT FROM rta_cur; +a|b +-+------------ +1|\x4649584d45 +(1 row) + +step s1_commit: COMMIT; +step s2_add_column: <... completed> +step s1_call_srf: SELECT * FROM rta_srf(); +a|b | c +-+------------+-- +1|\x4649584d45|99 +(1 row) + + +starting permutation: s1_srf_data s1_begin s1_open_cached s1_fetch s1_commit s1_begin s1_open_cached s2_add_column s1_fetch s1_commit s1_begin s1_open_cached s1_fetch s1_commit +step s1_srf_data: + SET plan_cache_mode = force_generic_plan; + INSERT INTO rta_tab VALUES (1, '\x4649584d45'); + +step s1_begin: BEGIN; +step s1_open_cached: SELECT rta_open_cursor(); +rta_open_cursor +--------------- +rta_cur +(1 row) + +step s1_fetch: FETCH NEXT FROM rta_cur; +a|b +-+------------ +1|\x4649584d45 +(1 row) + +step s1_commit: COMMIT; +step s1_begin: BEGIN; +step s1_open_cached: SELECT rta_open_cursor(); +rta_open_cursor +--------------- +rta_cur +(1 row) + +step s2_add_column: + BEGIN; + ALTER TYPE rta_type ADD ATTRIBUTE c int; + ALTER TABLE rta_tab ADD COLUMN c int DEFAULT 99; + COMMIT; + +step s1_fetch: FETCH NEXT FROM rta_cur; +a|b +-+------------ +1|\x4649584d45 +(1 row) + +step s1_commit: COMMIT; +step s2_add_column: <... completed> +step s1_begin: BEGIN; +step s1_open_cached: SELECT rta_open_cursor(); +rta_open_cursor +--------------- +rta_cur +(1 row) + +step s1_fetch: FETCH NEXT FROM rta_cur; +a|b | c +-+------------+-- +1|\x4649584d45|99 +(1 row) + +step s1_commit: COMMIT; diff --git a/src/test/isolation/specs/rowtypes-alter.spec b/src/test/isolation/specs/rowtypes-alter.spec index 2bc353c7628..e711a1cb384 100644 --- a/src/test/isolation/specs/rowtypes-alter.spec +++ b/src/test/isolation/specs/rowtypes-alter.spec @@ -9,6 +9,26 @@ setup { CREATE TABLE rta_tab (a int, b bytea); CREATE TYPE rta_type AS (a int, b bytea); + CREATE DOMAIN rta_domain AS rta_type; + CREATE FUNCTION rta_srf() RETURNS SETOF rta_type LANGUAGE plpgsql AS $$ + BEGIN + RETURN QUERY SELECT * FROM rta_tab; + END; + $$; + CREATE FUNCTION rta_domain_srf() RETURNS SETOF rta_domain + LANGUAGE plpgsql AS $$ + BEGIN + RETURN QUERY SELECT * FROM rta_tab; + END; + $$; + CREATE FUNCTION rta_open_cursor() RETURNS refcursor LANGUAGE plpgsql AS $$ + DECLARE + c refcursor := 'rta_cur'; + BEGIN + OPEN c FOR SELECT * FROM rta_srf(); + RETURN c; + END; + $$; CREATE TABLE rta_lockme (); -- Blocks until s2 releases its advisory lock, then processes the @@ -38,6 +58,8 @@ setup teardown { DROP FUNCTION rta_wait(), rta_wait_read(rta_type); + DROP FUNCTION rta_srf(), rta_domain_srf(), rta_open_cursor(); + DROP DOMAIN rta_domain; DROP TABLE rta_tab, rta_lockme, rta_ptab; DROP TYPE rta_type; } @@ -86,6 +108,16 @@ step s1_query SELECT x::text, rta_wait(), x::text FROM (SELECT '(1,\\x4649584d45)'::rta_tab AS x OFFSET 0) s; } +step s1_srf_data +{ + SET plan_cache_mode = force_generic_plan; + INSERT INTO rta_tab VALUES (1, '\x4649584d45'); +} +step s1_declare_srf { DECLARE rta_cur CURSOR FOR SELECT * FROM rta_srf(); } +step s1_declare_target_srf { DECLARE rta_cur CURSOR FOR SELECT rta_srf(); } +step s1_declare_domain_srf { DECLARE rta_cur CURSOR FOR SELECT * FROM rta_domain_srf(); } +step s1_open_cached { SELECT rta_open_cursor(); } +step s1_call_srf { SELECT * FROM rta_srf(); } teardown { DEALLOCATE ALL; CLOSE ALL; } session s2 @@ -94,6 +126,13 @@ step s2_alter_type { ALTER TYPE rta_type ALTER ATTRIBUTE b TYPE text; } step s2_alter_tab_same { ALTER TABLE rta_tab ALTER COLUMN b TYPE bytea; } step s2_lock { SELECT pg_advisory_lock(1); } step s2_unlock { SELECT pg_advisory_unlock(1); } +step s2_add_column +{ + BEGIN; + ALTER TYPE rta_type ADD ATTRIBUTE c int; + ALTER TABLE rta_tab ADD COLUMN c int DEFAULT 99; + COMMIT; +} session s3 # The leader doesn't participate. Plans are made for two workers, as one @@ -134,3 +173,13 @@ permutation s2_lock s1_query s2_alter_tab s2_unlock permutation s1_prepare s1_exec_tab s2_alter_tab_same s1_exec_tab # a datum formed in a parallel worker, read by the leader after waiting for s2 permutation s3_explain s2_lock s3_leader s2_alter_type s2_unlock + +# A named composite SRF result must stay unchanged after cursor setup, +# even before the first call of the function. +permutation s1_srf_data s1_begin s1_declare_srf s2_add_column s1_fetch s1_commit s1_call_srf +permutation s1_srf_data s1_begin s1_declare_target_srf s2_add_column s1_fetch s1_commit s1_call_srf +permutation s1_srf_data s1_begin s1_declare_domain_srf s2_add_column s1_fetch s1_commit s1_call_srf +# Reusing an SPI plan must reacquire the lock. Reopen after DDL as well. +permutation s1_srf_data s1_begin s1_open_cached s1_fetch s1_commit + s1_begin s1_open_cached s2_add_column s1_fetch s1_commit + s1_begin s1_open_cached s1_fetch s1_commit diff --git a/src/test/regress/expected/alter_table.out b/src/test/regress/expected/alter_table.out index 2faa747999f..9c724919435 100644 --- a/src/test/regress/expected/alter_table.out +++ b/src/test/regress/expected/alter_table.out @@ -3690,8 +3690,9 @@ DROP TYPE test_type_empty; -- Cached plans for queries that scan a set-returning function returning a -- named composite type must be invalidated when ALTER TYPE ADD ATTRIBUTE -- widens that type. The fix records the composite's underlying relation OID --- (pg_type.typrelid) in the plan's invalItems so the relcache invalidation --- broadcast by ALTER TYPE reaches the cached plan. +-- (pg_type.typrelid) in the plan's list of referenced relations +-- (glob->relationOids, checked by PlanCacheRelCallback) so the relcache +-- invalidation broadcast by ALTER TYPE reaches the cached plan. -- -- Without the fix the plan is never marked stale. A PL/pgSQL function whose -- RETURN QUERY calls such an SRF raises "structure of query does not match @@ -3699,9 +3700,10 @@ DROP TYPE test_type_empty; -- count while the SRF (independently replanned via table relcache) already -- returns the new one. -- --- SECURITY DEFINER prevents inlining; without inlining the outer plan holds --- only the proc OID in invalItems, so only the typrelid dependency added by --- the fix triggers its invalidation. +-- SECURITY DEFINER prevents inlining; without inlining the outer plan tracks +-- only the proc OID (in glob->invalItems, checked by PlanCacheObjectCallback), +-- so only the typrelid relation dependency added by the fix triggers its +-- invalidation. -- CREATE TYPE planinv_ct AS (a int, b int); CREATE TABLE planinv_tbl (a int, b int); -- 2.43.7