Hi, On Thu, Jan 15, 2026 at 01:13:36PM -0600, Sami Imseih wrote: > > I only had a quick look at the code but unless I'm missing something it's > > mostly an oversight as I pass "new_query" to CreateCachedPlan() but still > > pass > > the original query string to pg_analyze_and_rewrite_varparams(). Using > > "new_query" there too should fix the problem? > > That will be a fix, but that seems way too invasive for me. Not sure if it may > break other things. > > > > I am thinking that storing the statement length and location in the entry > > > of prepared_queries may be the better option. Having that info, the > > > cleaned up query text can be generated on the fly whenever > > > pg_prepared_statement is called. > > > > I don't like this approach as it has more execution time overhead, but also > > doesn't fix at all the memory waste in the prepared statements cache. > > ISTM that your proposal will actually use more memory because > pstate->p_sourcetext does not get free'd, but we must now allocate > space for a new "cleaned" query.
I'm not sure that I understand. Sure we allocate a new temporary buffer for the cleaned up query string but this will be freed soon. The query string stored in the prepared statement will stay in memory as long as the prepare statement exist so this any cleanup can actually save a lot of memory. I'm attaching a v2 that fixes the crash you describe earlier, and with some minimal regression test in pg_stat_statements to cover it. > As far as execution overhead, this will only be paid when you query > pg_prepared_statement, and we can even optimize this a bit by only > cleaning once and reusing the results. Actually I thought that there was a requirement to have a zero terminated string in the API to transform C strings to text datums, but there is not. It's actually slightly faster if you know the size as there is on strlen() less call in that case. This could be done in both case though. > > FWIW I think that this should belong to pg_stat_statements testing, no the > > main > > regression tests. This would also ensure that we see consistent results in > > some other scenarios. > > I agree. As mentioned basic tests added in v2.
>From 9749ba6b026ed85749fde988c1c2c9d3cece63d1 Mon Sep 17 00:00:00 2001 From: Julien Rouhaud <[email protected]> Date: Wed, 24 Dec 2025 22:31:52 +0800 Subject: [PATCH v2] Cleanup explicit PREPARE query strings When a multi statements query string contains one PREPARE statement (or multiple), the whole query string was saved in the cached plan. This is wasteful as that string can be artitrarily big, but it can also confusing as some other parts like pg_prepared_statements will output the saved query string as-is. This commit changes this behavior and only stores the part of the query string that correspond to any given PREPARED statement, similarly to how it's already done in pg_stat_statements. --- contrib/auto_explain/t/001_auto_explain.pl | 8 +-- contrib/pg_stat_statements/Makefile | 2 +- .../pg_stat_statements/expected/prepare.out | 53 +++++++++++++++++++ contrib/pg_stat_statements/meson.build | 1 + contrib/pg_stat_statements/sql/prepare.sql | 15 ++++++ src/backend/commands/prepare.c | 45 ++++++++++++++-- src/test/regress/expected/prepare.out | 44 +++++++++------ src/test/regress/sql/prepare.sql | 2 +- 8 files changed, 143 insertions(+), 27 deletions(-) create mode 100644 contrib/pg_stat_statements/expected/prepare.out create mode 100644 contrib/pg_stat_statements/sql/prepare.sql diff --git a/contrib/auto_explain/t/001_auto_explain.pl b/contrib/auto_explain/t/001_auto_explain.pl index 5f673bd14c1..f2d8625f8bb 100644 --- a/contrib/auto_explain/t/001_auto_explain.pl +++ b/contrib/auto_explain/t/001_auto_explain.pl @@ -60,7 +60,7 @@ $log_contents = query_log($node, like( $log_contents, - qr/Query Text: PREPARE get_proc\(name\) AS SELECT \* FROM pg_proc WHERE proname = \$1;/, + qr/Query Text: PREPARE get_proc\(name\) AS SELECT \* FROM pg_proc WHERE proname = \$1/, "prepared query text logged, text mode"); like( @@ -82,7 +82,7 @@ $log_contents = query_log( like( $log_contents, - qr/Query Text: PREPARE get_type\(name\) AS SELECT \* FROM pg_type WHERE typname = \$1;/, + qr/Query Text: PREPARE get_type\(name\) AS SELECT \* FROM pg_type WHERE typname = \$1/, "prepared query text logged, text mode"); like( @@ -98,7 +98,7 @@ $log_contents = query_log( like( $log_contents, - qr/Query Text: PREPARE get_type\(name\) AS SELECT \* FROM pg_type WHERE typname = \$1;/, + qr/Query Text: PREPARE get_type\(name\) AS SELECT \* FROM pg_type WHERE typname = \$1/, "prepared query text logged, text mode"); unlike( @@ -164,7 +164,7 @@ $log_contents = query_log( like( $log_contents, - qr/"Query Text": "PREPARE get_class\(name\) AS SELECT \* FROM pg_class WHERE relname = \$1;"/, + qr/"Query Text": "PREPARE get_class\(name\) AS SELECT \* FROM pg_class WHERE relname = \$1"/, "prepared query text logged, json mode"); like( diff --git a/contrib/pg_stat_statements/Makefile b/contrib/pg_stat_statements/Makefile index fe0478ac552..9a6bda90070 100644 --- a/contrib/pg_stat_statements/Makefile +++ b/contrib/pg_stat_statements/Makefile @@ -21,7 +21,7 @@ LDFLAGS_SL += $(filter -lm, $(LIBS)) REGRESS_OPTS = --temp-config $(top_srcdir)/contrib/pg_stat_statements/pg_stat_statements.conf REGRESS = select dml cursors utility level_tracking planning \ user_activity wal entry_timestamp privileges extended \ - parallel plancache cleanup oldextversions squashing + parallel plancache cleanup oldextversions squashing prepare # Disabled because these tests require "shared_preload_libraries=pg_stat_statements", # which typical installcheck users do not have (e.g. buildfarm clients). NO_INSTALLCHECK = 1 diff --git a/contrib/pg_stat_statements/expected/prepare.out b/contrib/pg_stat_statements/expected/prepare.out new file mode 100644 index 00000000000..010e289c1b0 --- /dev/null +++ b/contrib/pg_stat_statements/expected/prepare.out @@ -0,0 +1,53 @@ +-- Tests for PREPARE +SELECT pg_stat_statements_reset() IS NOT NULL AS t; + t +--- + t +(1 row) + +-- Test that prepared statements in a multi-query string behaves as expected +SELECT 1\;PREPARE p1 AS SELECT 1\; PREPARE p2(int) AS SELECT 2 * $1\; SELECT 1, 1; + ?column? +---------- + 1 +(1 row) + + ?column? | ?column? +----------+---------- + 1 | 1 +(1 row) + +SELECT calls, rows, query FROM pg_stat_statements ORDER BY query COLLATE "C"; + calls | rows | query +-------+------+---------------------------------------------------- + 1 | 1 | SELECT $1 + 1 | 1 | SELECT $1, $2 + 1 | 1 | SELECT pg_stat_statements_reset() IS NOT NULL AS t +(3 rows) + +SELECT pg_stat_statements_reset() IS NOT NULL AS t; + t +--- + t +(1 row) + +EXECUTE p1; + ?column? +---------- + 1 +(1 row) + +EXECUTE p2(0); + ?column? +---------- + 0 +(1 row) + +SELECT calls, rows, query FROM pg_stat_statements ORDER BY query COLLATE "C"; + calls | rows | query +-------+------+---------------------------------------------------- + 1 | 1 | PREPARE p1 AS SELECT 1 + 1 | 1 | PREPARE p2(int) AS SELECT 2 * $1 + 1 | 1 | SELECT pg_stat_statements_reset() IS NOT NULL AS t +(3 rows) + diff --git a/contrib/pg_stat_statements/meson.build b/contrib/pg_stat_statements/meson.build index 079a8eb5afc..65258651bd2 100644 --- a/contrib/pg_stat_statements/meson.build +++ b/contrib/pg_stat_statements/meson.build @@ -59,6 +59,7 @@ tests += { 'cleanup', 'oldextversions', 'squashing', + 'prepare', ], 'regress_args': ['--temp-config', files('pg_stat_statements.conf')], # Disabled because these tests require diff --git a/contrib/pg_stat_statements/sql/prepare.sql b/contrib/pg_stat_statements/sql/prepare.sql new file mode 100644 index 00000000000..a6bc5de4430 --- /dev/null +++ b/contrib/pg_stat_statements/sql/prepare.sql @@ -0,0 +1,15 @@ +-- Tests for PREPARE + +SELECT pg_stat_statements_reset() IS NOT NULL AS t; + +-- Test that prepared statements in a multi-query string behaves as expected +SELECT 1\;PREPARE p1 AS SELECT 1\; PREPARE p2(int) AS SELECT 2 * $1\; SELECT 1, 1; + +SELECT calls, rows, query FROM pg_stat_statements ORDER BY query COLLATE "C"; + +SELECT pg_stat_statements_reset() IS NOT NULL AS t; + +EXECUTE p1; +EXECUTE p2(0); + +SELECT calls, rows, query FROM pg_stat_statements ORDER BY query COLLATE "C"; diff --git a/src/backend/commands/prepare.c b/src/backend/commands/prepare.c index 5b86a727587..b8fe3dd5302 100644 --- a/src/backend/commands/prepare.c +++ b/src/backend/commands/prepare.c @@ -27,6 +27,7 @@ #include "commands/prepare.h" #include "funcapi.h" #include "nodes/nodeFuncs.h" +#include "nodes/queryjumble.h" #include "parser/parse_coerce.h" #include "parser/parse_collate.h" #include "parser/parse_expr.h" @@ -64,6 +65,7 @@ PrepareQuery(ParseState *pstate, PrepareStmt *stmt, Oid *argtypes = NULL; int nargs; List *query_list; + const char *new_query; /* * Disallow empty-string statement name (conflicts with protocol-level @@ -80,14 +82,49 @@ PrepareQuery(ParseState *pstate, PrepareStmt *stmt, */ rawstmt = makeNode(RawStmt); rawstmt->stmt = stmt->query; - rawstmt->stmt_location = stmt_location; - rawstmt->stmt_len = stmt_len; + + /* + * Extract the query text if possible. + * + * If we have a statement location, we can extract the relevant part of the + * possibly multi-statement query string. If not just use what we were + * given. + */ + if (stmt_location < 0) + { + rawstmt->stmt_location = stmt_location; + rawstmt->stmt_len = stmt_len; + new_query = pstate->p_sourcetext; + } + else + { + const char *cleaned; + char *tmp; + + rawstmt->stmt_len = stmt_len; + cleaned = CleanQuerytext(pstate->p_sourcetext, &stmt_location, + &rawstmt->stmt_len); + + if (rawstmt->stmt_len == 0) + rawstmt->stmt_len = strlen(cleaned); + + /* + * CleanQuerytext() removes any leading whitespace and returns a + * pointer to the first actual character, so the cleaned query string + * is guaranteed to start at offset 0. + */ + rawstmt->stmt_location = 0; + tmp = palloc(rawstmt->stmt_len + 1); + strlcpy(tmp, cleaned, rawstmt->stmt_len + 1); + + new_query = tmp; + } /* * Create the CachedPlanSource before we do parse analysis, since it needs * to see the unmodified raw parse tree. */ - plansource = CreateCachedPlan(rawstmt, pstate->p_sourcetext, + plansource = CreateCachedPlan(rawstmt, new_query, CreateCommandTag(stmt->query)); /* Transform list of TypeNames to array of type OIDs */ @@ -116,7 +153,7 @@ PrepareQuery(ParseState *pstate, PrepareStmt *stmt, * information about unknown parameters to be deduced from context. * Rewrite the query. The result could be 0, 1, or many queries. */ - query_list = pg_analyze_and_rewrite_varparams(rawstmt, pstate->p_sourcetext, + query_list = pg_analyze_and_rewrite_varparams(rawstmt, new_query, &argtypes, &nargs, NULL); /* Finish filling in the CachedPlanSource */ diff --git a/src/test/regress/expected/prepare.out b/src/test/regress/expected/prepare.out index 5815e17b39c..c645a4e5d0e 100644 --- a/src/test/regress/expected/prepare.out +++ b/src/test/regress/expected/prepare.out @@ -6,7 +6,17 @@ SELECT name, statement, parameter_types, result_types FROM pg_prepared_statement ------+-----------+-----------------+-------------- (0 rows) -PREPARE q1 AS SELECT 1 AS a; +SELECT 'bingo'\; PREPARE q1 AS SELECT 1 AS a \; SELECT 42; + ?column? +---------- + bingo +(1 row) + + ?column? +---------- + 42 +(1 row) + EXECUTE q1; a --- @@ -14,9 +24,9 @@ EXECUTE q1; (1 row) SELECT name, statement, parameter_types, result_types FROM pg_prepared_statements; - name | statement | parameter_types | result_types -------+------------------------------+-----------------+-------------- - q1 | PREPARE q1 AS SELECT 1 AS a; | {} | {integer} + name | statement | parameter_types | result_types +------+-----------------------------+-----------------+-------------- + q1 | PREPARE q1 AS SELECT 1 AS a | {} | {integer} (1 row) -- should fail @@ -33,18 +43,18 @@ EXECUTE q1; PREPARE q2 AS SELECT 2 AS b; SELECT name, statement, parameter_types, result_types FROM pg_prepared_statements; - name | statement | parameter_types | result_types -------+------------------------------+-----------------+-------------- - q1 | PREPARE q1 AS SELECT 2; | {} | {integer} - q2 | PREPARE q2 AS SELECT 2 AS b; | {} | {integer} + name | statement | parameter_types | result_types +------+-----------------------------+-----------------+-------------- + q1 | PREPARE q1 AS SELECT 2 | {} | {integer} + q2 | PREPARE q2 AS SELECT 2 AS b | {} | {integer} (2 rows) -- sql92 syntax DEALLOCATE PREPARE q1; SELECT name, statement, parameter_types, result_types FROM pg_prepared_statements; - name | statement | parameter_types | result_types -------+------------------------------+-----------------+-------------- - q2 | PREPARE q2 AS SELECT 2 AS b; | {} | {integer} + name | statement | parameter_types | result_types +------+-----------------------------+-----------------+-------------- + q2 | PREPARE q2 AS SELECT 2 AS b | {} | {integer} (1 row) DEALLOCATE PREPARE q2; @@ -168,20 +178,20 @@ SELECT name, statement, parameter_types, result_types FROM pg_prepared_statement ------+------------------------------------------------------------------+----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------- q2 | PREPARE q2(text) AS +| {text} | {name,boolean,boolean} | SELECT datname, datistemplate, datallowconn +| | - | FROM pg_database WHERE datname = $1; | | + | FROM pg_database WHERE datname = $1 | | q3 | PREPARE q3(text, int, float, boolean, smallint) AS +| {text,integer,"double precision",boolean,smallint} | {integer,integer,integer,integer,integer,integer,integer,integer,integer,integer,integer,integer,integer,name,name,name} | SELECT * FROM tenk1 WHERE string4 = $1 AND (four = $2 OR+| | | ten = $3::bigint OR true = $4 OR odd = $5::int) +| | - | ORDER BY unique1; | | + | ORDER BY unique1 | | q5 | PREPARE q5(int, text) AS +| {integer,text} | {integer,integer,integer,integer,integer,integer,integer,integer,integer,integer,integer,integer,integer,name,name,name} | SELECT * FROM tenk1 WHERE unique1 = $1 OR stringu1 = $2 +| | - | ORDER BY unique1; | | + | ORDER BY unique1 | | q6 | PREPARE q6 AS +| {integer,name} | {integer,integer,integer,integer,integer,integer,integer,integer,integer,integer,integer,integer,integer,name,name,name} - | SELECT * FROM tenk1 WHERE unique1 = $1 AND stringu1 = $2; | | + | SELECT * FROM tenk1 WHERE unique1 = $1 AND stringu1 = $2 | | q7 | PREPARE q7(unknown) AS +| {path} | {text,path} - | SELECT * FROM road WHERE thepath = $1; | | + | SELECT * FROM road WHERE thepath = $1 | | q8 | PREPARE q8 AS +| {integer,name} | - | UPDATE tenk1 SET stringu1 = $2 WHERE unique1 = $1; | | + | UPDATE tenk1 SET stringu1 = $2 WHERE unique1 = $1 | | (6 rows) -- test DEALLOCATE ALL; diff --git a/src/test/regress/sql/prepare.sql b/src/test/regress/sql/prepare.sql index c6098dc95ce..0e7fe44725e 100644 --- a/src/test/regress/sql/prepare.sql +++ b/src/test/regress/sql/prepare.sql @@ -4,7 +4,7 @@ SELECT name, statement, parameter_types, result_types FROM pg_prepared_statements; -PREPARE q1 AS SELECT 1 AS a; +SELECT 'bingo'\; PREPARE q1 AS SELECT 1 AS a \; SELECT 42; EXECUTE q1; SELECT name, statement, parameter_types, result_types FROM pg_prepared_statements; -- 2.52.0
