Received: from malur.postgresql.org ([217.196.149.56]) by arkaria.postgresql.org with esmtps (TLS1.3) tls TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384 (Exim 4.96) (envelope-from ) id 1vjzgt-007XM5-1A for pgsql-hackers@arkaria.postgresql.org; Sun, 25 Jan 2026 12:58:08 +0000 Received: from localhost ([127.0.0.1] helo=malur.postgresql.org) by malur.postgresql.org with esmtp (Exim 4.96) (envelope-from ) id 1vjzgr-004we0-1c for pgsql-hackers@arkaria.postgresql.org; Sun, 25 Jan 2026 12:58:05 +0000 Received: from magus.postgresql.org ([2a02:c0:301:0:ffff::29]) by malur.postgresql.org with esmtps (TLS1.3) tls TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384 (Exim 4.96) (envelope-from ) id 1vjzgr-004wdr-0T for pgsql-hackers@lists.postgresql.org; Sun, 25 Jan 2026 12:58:05 +0000 Received: from mail-pf1-x42b.google.com ([2607:f8b0:4864:20::42b]) by magus.postgresql.org with esmtps (TLS1.3) tls TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256 (Exim 4.98.2) (envelope-from ) id 1vjzgp-00000000NRB-19I2 for pgsql-hackers@lists.postgresql.org; Sun, 25 Jan 2026 12:58:05 +0000 Received: by mail-pf1-x42b.google.com with SMTP id d2e1a72fcca58-81f39438187so1866500b3a.2 for ; Sun, 25 Jan 2026 04:58:02 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20230601; t=1769345880; x=1769950680; darn=lists.postgresql.org; h=in-reply-to:content-disposition:mime-version:references:message-id :subject:cc:to:from:date:from:to:cc:subject:date:message-id:reply-to; bh=GLzR/G/jpFEyZyLxQiiiGsHI1Dex6DPz8jyYzSbAtFk=; b=SLPmOBxeKGKplyDoUkw9/9LIdVjjo1oASaS/xsPlY2H58BFvItucXyge0K7CThWgKA KtbVd9VLYM9kEBQk3BTy4JVrjTK3RJlI/MANigyFQoJSvhT6Djjwe2tW9LgKG1QCaO3l yKl+ju7Rq+z1SmVFQZDcLwuEMusT7qkyMdE6tVIPUecEpTDs1Syl4yYZGxa6vbczda3r Mk27qqLBsdIP7z+Kj/8tANDUaxW2/iw/w1nGUUg55WdcIO3Sq4TbM5EiE8BaKwzuhi5u GoMt0eofbqChOZeZdpimYgJI4oCAjtuamHK8hg32yK4r8Dbr0253mMu+hPW86YKLTAvM xtZw== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1769345880; x=1769950680; h=in-reply-to:content-disposition:mime-version:references:message-id :subject:cc:to:from:date:x-gm-gg:x-gm-message-state:from:to:cc :subject:date:message-id:reply-to; bh=GLzR/G/jpFEyZyLxQiiiGsHI1Dex6DPz8jyYzSbAtFk=; b=u+TGoitvgSJfCZI2Nh9y1zc4eHY+9dLbNKtOaUlKh/Gb4blleuxHObLZzACLEPfd38 I6CqAMi/dF2L6BGAnqI+GiPL3G9Nz4J8V2HnOlt5MSQuBo0yd/BV50fUVvw7VXcDEzTs A/tSVxb1tF6ltw9aN+HqPtPM99OFRw/2gW87l1X0bm3hdw8vkyOgRB69ezfwfSoKxppv NvNFphvw5kKPc3u0GROg6DVJZqWCJXhO4PGotAoSeTIGGtfE3w6lA6zkihIWU1Ez8bOa 8d/Gtg8rUAEAMQm2hXJipG5toKu0J8OlLVeFKk+ybTOpCa6GUjy2qE1H9cZt+g5YCmrt 18Iw== X-Forwarded-Encrypted: i=1; AJvYcCXT/GpHQ6ZHmsZCYKFI5R08UyuZKtkgetNFm36+Ub/f8lqV3ZZTNdvmLo6VPG7fT4vs/vNJyIJaFYU5/z0j@lists.postgresql.org X-Gm-Message-State: AOJu0Yw8VBgcYXC1yaZn8GMUz+07C6Xc+X0cBavFpA1Ecc1R40fHubqO kUO3W4ZA2omVyXIBqiZC8EMWTLAGMc9flAmbI5M7j2pQPuge7H8bXMFucM4LrA== X-Gm-Gg: AZuq6aKBEVF/ntvqESnLMmGL06MC3PMa0mUixzRFxicMMm8IjyGTGlDAz1HKG///aRO jD9LFBU8IzCUZ+IAw+28cg44Ke/dlXkbUSDC34LaEQKoHtEOovuKMZC+id39txJmn4G9uKjLvuK +2ZrevB39KsgyueV/5tsPMMRANhWvWfPmIWDZWy91n8kcYr1mTj3R989rjkEEFnd7HuC2NzZNwB buc8JB1nMgvrRrib4u1tRKF1eH2wzOW57Rd0BFPiWFO/5P+LNqT2ZBDSLisvW9eoXqu/uKg3iHZ Fe2DLdjHcEso5QR/Q8YxqluA2ruCgakGunEROac0MXJz1m19BTISzBtpjbDNB/9UuVfFw0sgYs3 fh3+cq59ptURunZ4Up2dpsfk6K/GDt1tmt7TyLFsHif5EJ4LxGy33FCFbaIWZnxqNrUSoJ92w6T VynQw= X-Received: by 2002:a05:6a00:92a4:b0:7e8:4398:b360 with SMTP id d2e1a72fcca58-823412b86c9mr1190438b3a.51.1769345880439; Sun, 25 Jan 2026 04:58:00 -0800 (PST) Received: from jrouhaud ([115.43.41.38]) by smtp.gmail.com with ESMTPSA id d2e1a72fcca58-82318674728sm6925118b3a.28.2026.01.25.04.57.52 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Sun, 25 Jan 2026 04:57:59 -0800 (PST) Date: Sun, 25 Jan 2026 20:57:31 +0800 From: Julien Rouhaud To: Sami Imseih Cc: Tom Lane , pgsql-hackers@lists.postgresql.org Subject: Re: Cleaning up PREPARE query strings? Message-ID: References: MIME-Version: 1.0 Content-Type: multipart/mixed; boundary="xBRJzsblsXcilRYX" Content-Disposition: inline In-Reply-To: List-Id: List-Help: List-Subscribe: List-Post: List-Owner: List-Archive: Archived-At: Precedence: bulk --xBRJzsblsXcilRYX Content-Type: text/plain; charset=us-ascii Content-Disposition: inline Hi, On Mon, Jan 19, 2026 at 12:43:53AM -0600, Sami Imseih wrote: > > However, the error reporting does break with the patch. Notice with the patch > the cursor for the error reporting shifts incorrectly. This is due to the fact > rawstmt->stmt_location/length are no longer representative of the original > qurey text. > > ## unpatched > ``` > postgres=# SELECT 1 \; PREPARE stmt AS SELECT nonexistent_column > FROM users\; SELECT 2; > ?column? > ---------- > 1 > (1 row) > > ERROR: relation "users" does not exist > LINE 1: ... ; PREPARE stmt AS SELECT nonexistent_column FROM users; SEL... > > ^ > ``` > > ## patched > ``` > postgres=# SELECT 1 \; PREPARE stmt AS SELECT nonexistent_column > FROM users\; SELECT 2; > ?column? > ---------- > 1 > (1 row) > > ERROR: relation "users" does not exist > LINE 1: ...LECT 1 ; PREPARE stmt AS SELECT nonexistent_column FROM u... > > ^ > ``` This was already reported by Tom Lane on his first message, although his complaint was about execution time error reporting while this is during parse-analysis. However, I think that the exact same approach can be used to fixed both, either updating the position of every single element (which no one wants) or teaching the executor (and evidently the planstate) about a new "query offset" so that parser_errposition and executor_errposition report the correct location. I'm still waiting on whether the latter would be acceptable or not before implementing it. Note that I wasn't able to hit the execution time error so at least with parse-analysis time error I could at least have some regression tests, so thanks a lot! In the meantime, the cfbot shows that a rebase is needed, so v3 attached. --xBRJzsblsXcilRYX Content-Type: text/plain; charset=us-ascii Content-Disposition: attachment; filename=v3-0001-Cleanup-explicit-PREPARE-query-strings.patch From 5f958d51d978de959f11396dc67903cf9b4b2838 Mon Sep 17 00:00:00 2001 From: Julien Rouhaud Date: Wed, 24 Dec 2025 22:31:52 +0800 Subject: [PATCH v3] 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 | 1 + .../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(+), 26 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 c27e9529bb6..ac967687796 100644 --- a/contrib/pg_stat_statements/Makefile +++ b/contrib/pg_stat_statements/Makefile @@ -36,6 +36,7 @@ REGRESS = \ parallel \ plancache \ squashing \ + prepare \ cleanup \ oldextversions 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 9d78cb88b7d..c9e1d446d39 100644 --- a/contrib/pg_stat_statements/meson.build +++ b/contrib/pg_stat_statements/meson.build @@ -58,6 +58,7 @@ tests += { 'parallel', 'plancache', 'squashing', + 'prepare', 'cleanup', 'oldextversions', ], 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 --xBRJzsblsXcilRYX--