public inbox for [email protected]
help / color / mirror / Atom feedRe: [PATCH] Optionally record Plan IDs to track plan changes for a query
10+ messages / 7 participants
[nested] [flat]
* Re: [PATCH] Optionally record Plan IDs to track plan changes for a query
@ 2025-02-13 11:25 Alvaro Herrera <[email protected]>
0 siblings, 1 reply; 10+ messages in thread
From: Alvaro Herrera @ 2025-02-13 11:25 UTC (permalink / raw)
To: Sami Imseih <[email protected]>; +Cc: Greg Sabino Mullane <[email protected]>; Michael Paquier <[email protected]>; Lukas Fittl <[email protected]>; PostgreSQL Hackers <[email protected]>; Marko M <[email protected]>; Julien Rouhaud <[email protected]>
On 2025-Feb-12, Sami Imseih wrote:
> Greg S. Mullane wrote:
>
> > I agree fingerprint is the right final word. But "jumble" conveys
> > the *process* better than "fingerprinting". I view it as jumbling
> > produces an object that can be fingerprinted.
>
> hmm, "jumble" describes something that is scrambled
> or not in order, such as the 64-bit hash produced. It
> sounds like the final product.
I don't understand why we would change any naming here at all. I think
you should be looking at a much broader consensus and plus-ones that a
renaming is needed. -1 from me.
--
Álvaro Herrera Breisgau, Deutschland — https://www.EnterpriseDB.com/
"No renuncies a nada. No te aferres a nada."
^ permalink raw reply [nested|flat] 10+ messages in thread
* Re: [PATCH] Optionally record Plan IDs to track plan changes for a query
@ 2025-02-13 16:44 Sami Imseih <[email protected]>
parent: Alvaro Herrera <[email protected]>
0 siblings, 1 reply; 10+ messages in thread
From: Sami Imseih @ 2025-02-13 16:44 UTC (permalink / raw)
To: Alvaro Herrera <[email protected]>; +Cc: Greg Sabino Mullane <[email protected]>; Michael Paquier <[email protected]>; Lukas Fittl <[email protected]>; PostgreSQL Hackers <[email protected]>; Marko M <[email protected]>; Julien Rouhaud <[email protected]>
> I don't understand why we would change any naming here at all. I think
> you should be looking at a much broader consensus and plus-ones that a
> renaming is needed. -1 from me.
The reason for the change is because "query jumble" will no longer
make sense if the jumble code can now be used for other types of
trees, such as Plan.
I do agree that this needs a single-threaded discussion to achieve a
consensus.
--
Sami
^ permalink raw reply [nested|flat] 10+ messages in thread
* Re: [PATCH] Optionally record Plan IDs to track plan changes for a query
@ 2025-03-18 07:31 Michael Paquier <[email protected]>
parent: Sami Imseih <[email protected]>
0 siblings, 1 reply; 10+ messages in thread
From: Michael Paquier @ 2025-03-18 07:31 UTC (permalink / raw)
To: Sami Imseih <[email protected]>; +Cc: Alvaro Herrera <[email protected]>; Greg Sabino Mullane <[email protected]>; Lukas Fittl <[email protected]>; PostgreSQL Hackers <[email protected]>; Marko M <[email protected]>; Julien Rouhaud <[email protected]>
On Thu, Feb 13, 2025 at 10:44:33AM -0600, Sami Imseih wrote:
> The reason for the change is because "query jumble" will no longer
> make sense if the jumble code can now be used for other types of
> trees, such as Plan.
>
> I do agree that this needs a single-threaded discussion to achieve a
> consensus.
FWIW, I was playing with a sub-project where I was jumbling a portion
of nodes other than Query, and it is annoying to not have a direct
access to jumbleNode(). So, how about doing the refactoring proposed
in v5-0002 with an initialization routine and JumbleNode() as the
entry point for the jumbling, but not rename the existing files
queryjumblefuncs.c and queryjumble.h? That seems doable for this
release, at least.
I don't think that we should expose AppendJumble(), either.
--
Michael
Attachments:
[application/pgp-signature] signature.asc (833B, 2-signature.asc)
download
^ permalink raw reply [nested|flat] 10+ messages in thread
* Re: [PATCH] Optionally record Plan IDs to track plan changes for a query
@ 2025-03-18 09:12 Andrei Lepikhov <[email protected]>
parent: Michael Paquier <[email protected]>
0 siblings, 0 replies; 10+ messages in thread
From: Andrei Lepikhov @ 2025-03-18 09:12 UTC (permalink / raw)
To: Michael Paquier <[email protected]>; Sami Imseih <[email protected]>; +Cc: Alvaro Herrera <[email protected]>; Greg Sabino Mullane <[email protected]>; Lukas Fittl <[email protected]>; PostgreSQL Hackers <[email protected]>; Marko M <[email protected]>; Julien Rouhaud <[email protected]>
On 3/18/25 08:31, Michael Paquier wrote:
> On Thu, Feb 13, 2025 at 10:44:33AM -0600, Sami Imseih wrote:
>> The reason for the change is because "query jumble" will no longer
>> make sense if the jumble code can now be used for other types of
>> trees, such as Plan.
>>
>> I do agree that this needs a single-threaded discussion to achieve a
>> consensus.
>
> FWIW, I was playing with a sub-project where I was jumbling a portion
> of nodes other than Query, and it is annoying to not have a direct
> access to jumbleNode(). So, how about doing the refactoring proposed
> in v5-0002 with an initialization routine and JumbleNode() as the
> entry point for the jumbling, but not rename the existing files
> queryjumblefuncs.c and queryjumble.h? That seems doable for this
> release, at least.
It seems pretty helpful to me. Having a code for hashing an expression
or subquery, we may design new optimisations. I personally have such a
necessity in a couple of planner extensions.
At the same time, generalising jumbling code we may decide to work on
the JumbleState structure: code related to constant locations may be
replaced with callbacks - let the caller decide what action to take on
each node (not only constants). Of course, it is not for current release.
>
> I don't think that we should expose AppendJumble(), either.
Agree
--
regards, Andrei Lepikhov
^ permalink raw reply [nested|flat] 10+ messages in thread
* Re: [PATCH] Optionally record Plan IDs to track plan changes for a query
@ 2025-03-18 19:27 Ilia Evdokimov <[email protected]>
0 siblings, 0 replies; 10+ messages in thread
From: Ilia Evdokimov @ 2025-03-18 19:27 UTC (permalink / raw)
To: Alvaro Herrera <[email protected]>; Julien Rouhaud <[email protected]>; +Cc: Sami Imseih <[email protected]>; Michael Paquier <[email protected]>; Lukas Fittl <[email protected]>; PostgreSQL Hackers <[email protected]>; Marko M <[email protected]>
On 12.02.2025 19:00, Alvaro Herrera wrote:
> On 2025-Feb-12, Julien Rouhaud wrote:
>
>> On Wed, Feb 12, 2025 at 01:57:47PM +0100, Alvaro Herrera wrote:
>>> Anyway, I think that's different. We do support compute_query_id=off as
>>> a way for a custom module to compute completely different query IDs
>>> using their own algorithm, which I think is what you're referring to.
>>> However, the ability to affect the way the in-core algorithm works is a
>>> different thing: you still want in-core code to compute the query ID.
>> I don't think that's the actual behavior, or at least not what it was
>> supposed to be.
>>
>> What we should have is the ability to compute queryid, which can be
>> either in core or done by an external module, but one only one can /
>> should be done.
> Yes, that's what I tried to say, but I don't understand why you say I
> said something different.
>
>>> Right now, the proposal in the other thread is that if you want to
>>> affect that algorithm in order to merge arrays to be considered a single
>>> query element regardless of its length, you set the GUC for that.
>>> Initially the GUC was in the core code. Then, based on review, the GUC
>>> was moved to the extension, _BUT_ the implementation was still in the
>>> core code: in order to activate it, the extension calls a function that
>>> modifies core code behavior. So there are more moving parts than
>>> before, and if you for whatever reason want that behavior but not the
>>> extension, then you need to write a C function. To me this is absurd.
>>> So what I suggest we do is return to having the GUC in the core code.
>> I agree, although that probably breaks the queryid extensibility.
> It does?
>
>> I haven't read the patch but IIUC if you want the feature to work you
>> need to both change the queryid calculation but also the way the
>> constants are recorded and the query text is normalized, and I don't
>> know if extensions have access to it.
> Hmm. As for the query text: with Andrey's feature with the GUC in core,
> a query like this
> SELECT foo FROM tab WHERE col1 IN (1,2,3,4)
> will have in pg_stat_activity an identical query_id to a query like this
> SELECT foo WHERE tab WHERE col1 IN (1,2,3,4,5)
> even though the query texts differ (in the number of elements in the
> array). I don't think this is a problem. This means that the query_id
> for two different queries can be identical, but that should be no
> surprise, precisely because the GUC that controls it is documented to do
> that.
>
> If pg_stat_statements is enabled with Andrey's patch, then the same
> query_id will have a single entry (which has stats for both execution of
> those queries) with that query_id, with a normalized query text that is
> going to be different from those two above; without Andrey's feature,
> the text would be
> SELECT foo WHERE tab WHERE col1 IN ($1,$2,$3,$4);
> SELECT foo WHERE tab WHERE col1 IN ($1,$2,$3,$4,$5);
> (that is, pg_stat_statements transformed the values into placeholders,
> but using exactly the same number of items in the array as the original
> queries). With Andrey's feature, it will be
> SELECT foo WHERE tab WHERE col1 IN (...);
> that is, the query text has been modified and no longer matches exactly
> any of the queries in pg_stat_activity. But note that the query text
> already does not match what's in pg_stat_activity, even before Andrey's
> patch.
>
> I don't understand what you mean with "the way the constants are
> recorded". What constants are you talking about? pg_stat_statements
> purposefully discards any constants used in the query (obviously).
>
>> If they have access and fail to do what the GUC asked then of course
>> that's just a bug in that extension.
> I don't understand what bug are you thinking that such hypothetical
> extension would have. (pg_stat_statements does of course have access to
> the query text and to the location of all constants).
>
>>> Now I admit I'm not sure what the solution would be for the problem
>>> discussed in this subthread. Apparently the problem is related to temp
>>> tables and their changing OIDs. I'm not sure what exactly the proposal
>>> for a GUC is.
>> I'm not proposing anything, just explaining why pg_stat_statements is
>> generally useless if you use temp tables as someone asked.
> Ah, okay. Well, where you see a deficiency, I see an opportunity for
> improvement :-)
>
Hi everyone,
I support the idea of computing the planid for temporary tables using
'pg_temp.rel_name'. Moreover, we have already started using this
approach for computing queryid [0]. It seems reasonable to apply the
same logic to the planid calculation as well.
[0]:
https://www.postgresql.org/message-id/flat/Z9mkqplmUpQ4xG52%40msg.df7cb.de#efb20f01bec32aeafd58e5d4a...
--
Best regards,
Ilia Evdokimov,
Tantor Labs LLC.
^ permalink raw reply [nested|flat] 10+ messages in thread
* Re: [PATCH] Optionally record Plan IDs to track plan changes for a query
@ 2025-12-25 14:27 Андрей Казачков <[email protected]>
1 sibling, 0 replies; 10+ messages in thread
From: Андрей Казачков @ 2025-12-25 14:27 UTC (permalink / raw)
To: Sami Imseih <[email protected]>; Lukas Fittl <[email protected]>; Michael Paquier <[email protected]>; +Cc: PostgreSQL Hackers <[email protected]>; Marko M <[email protected]>
------==--bound.900221.49cd4b58-7c78-42e5-a261-f615fc122742
Content-Transfer-Encoding: base64
Content-Type: text/html; charset=utf-8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------==--bound.900221.49cd4b58-7c78-42e5-a261-f615fc122742
Content-Disposition: attachment;
filename="v6-0002-Fix-jumbling-of-empty-arrays-in-plan-nodes.patch"
Content-Transfer-Encoding: base64
Content-Type: text/x-diff;
name="v6-0002-Fix-jumbling-of-empty-arrays-in-plan-nodes.patch"
RnJvbSA3MGM5NzIwYThlZGQ4NGZkMzFjNGU5YTliMTk3ODc2NWRmNWRiYWVhIE1vbiBTZXAgMTcg
MDA6MDA6MDAgMjAwMQpGcm9tOiBBbmRyZXkgS2F6YWNoa292IDxhbmRyZXkua2F6YWNoa292QHRh
bnRvcmxhYnMucnU+CkRhdGU6IFdlZCwgMjQgRGVjIDIwMjUgMTg6NDc6MzQgKzAzMDAKU3ViamVj
dDogW1BBVENIIHY2IDIvMl0gRml4IGp1bWJsaW5nIG9mIGVtcHR5IGFycmF5cyBpbiBwbGFuIG5v
ZGVzCgotLS0KIHNyYy9iYWNrZW5kL25vZGVzL3F1ZXJ5anVtYmxlZnVuY3MuYyB8IDUgKysrKy0K
IDEgZmlsZSBjaGFuZ2VkLCA0IGluc2VydGlvbnMoKyksIDEgZGVsZXRpb24oLSkKCmRpZmYgLS1n
aXQgYS9zcmMvYmFja2VuZC9ub2Rlcy9xdWVyeWp1bWJsZWZ1bmNzLmMgYi9zcmMvYmFja2VuZC9u
b2Rlcy9xdWVyeWp1bWJsZWZ1bmNzLmMKaW5kZXggNTcxNzQ4MGRiZjUuLmEwZDI4ODI3MjY5IDEw
MDY0NAotLS0gYS9zcmMvYmFja2VuZC9ub2Rlcy9xdWVyeWp1bWJsZWZ1bmNzLmMKKysrIGIvc3Jj
L2JhY2tlbmQvbm9kZXMvcXVlcnlqdW1ibGVmdW5jcy5jCkBAIC01NTUsNyArNTU1LDEwIEBAIGRv
IHsgXAogCQlBcHBlbmRKdW1ibGUoanN0YXRlLCAoY29uc3QgdW5zaWduZWQgY2hhciAqKSBleHBy
LT5pdGVtLT53b3Jkcywgc2l6ZW9mKGJpdG1hcHdvcmQpICogZXhwci0+aXRlbS0+bndvcmRzKTsg
XAogfSB3aGlsZSgwKQogI2RlZmluZSBKVU1CTEVfQVJSQVkoaXRlbSwgbGVuKSBcCi0JQXBwZW5k
SnVtYmxlKGpzdGF0ZSwgKGNvbnN0IHVuc2lnbmVkIGNoYXIgKikgZXhwci0+aXRlbSwgc2l6ZW9m
KCooZXhwci0+aXRlbSkpICogbGVuKQorCWRvIHsgXAorCQlpZiAobGVuKSBcCisJCQlBcHBlbmRK
dW1ibGUoanN0YXRlLCAoY29uc3QgdW5zaWduZWQgY2hhciAqKSBleHByLT5pdGVtLCBzaXplb2Yo
KihleHByLT5pdGVtKSkgKiBsZW4pOyBcCisJfSB3aGlsZSAoMCkKICNkZWZpbmUgSlVNQkxFX1NU
UklORyhzdHIpIFwKIGRvIHsgXAogCWlmIChleHByLT5zdHIpIFwKLS0gCjIuNDMuMAoK
------==--bound.900221.49cd4b58-7c78-42e5-a261-f615fc122742
Content-Disposition: attachment;
filename="v6-0001-Added-plan_id-to-the-core.patch"
Content-Transfer-Encoding: base64
Content-Type: text/x-diff;
name="v6-0001-Added-plan_id-to-the-core.patch"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------==--bound.900221.49cd4b58-7c78-42e5-a261-f615fc122742--
Attachments:
[text/x-diff] v6-0002-Fix-jumbling-of-empty-arrays-in-plan-nodes.patch (1020B, 2-v6-0002-Fix-jumbling-of-empty-arrays-in-plan-nodes.patch)
download | inline diff:
From 70c9720a8edd84fd31c4e9a9b1978765df5dbaea Mon Sep 17 00:00:00 2001
From: Andrey Kazachkov <[email protected]>
Date: Wed, 24 Dec 2025 18:47:34 +0300
Subject: [PATCH v6 2/2] Fix jumbling of empty arrays in plan nodes
---
src/backend/nodes/queryjumblefuncs.c | 5 ++++-
1 file changed, 4 insertions(+), 1 deletion(-)
diff --git a/src/backend/nodes/queryjumblefuncs.c b/src/backend/nodes/queryjumblefuncs.c
index 5717480dbf5..a0d28827269 100644
--- a/src/backend/nodes/queryjumblefuncs.c
+++ b/src/backend/nodes/queryjumblefuncs.c
@@ -555,7 +555,10 @@ do { \
AppendJumble(jstate, (const unsigned char *) expr->item->words, sizeof(bitmapword) * expr->item->nwords); \
} while(0)
#define JUMBLE_ARRAY(item, len) \
- AppendJumble(jstate, (const unsigned char *) expr->item, sizeof(*(expr->item)) * len)
+ do { \
+ if (len) \
+ AppendJumble(jstate, (const unsigned char *) expr->item, sizeof(*(expr->item)) * len); \
+ } while (0)
#define JUMBLE_STRING(str) \
do { \
if (expr->str) \
--
2.43.0
[text/x-diff] v6-0001-Added-plan_id-to-the-core.patch (43.9K, 3-v6-0001-Added-plan_id-to-the-core.patch)
download | inline diff:
From 49518713775c3d24ba8e7a802c817042143e548a Mon Sep 17 00:00:00 2001
From: Andrey Kazachkov <[email protected]>
Date: Tue, 16 Dec 2025 19:52:39 +0300
Subject: [PATCH v6 1/2] Added plan_id to the core.
1. Changed a jumbling initialization routine
2. JumbleNode() is an entry point for jumbling
3. AppendJumble() remains static
4. guc-compute-plan-id has been added
5. gen_node_support.pl changed to process plan node structures
6. pg_node_attr has been added to certain structures/fields
---
doc/src/sgml/config.sgml | 34 ++++
doc/src/sgml/monitoring.sgml | 16 ++
src/backend/catalog/system_views.sql | 1 +
src/backend/commands/explain.c | 17 ++
src/backend/executor/execMain.c | 10 +-
src/backend/nodes/gen_node_support.pl | 34 +++-
src/backend/nodes/queryjumblefuncs.c | 180 +++++++++++-------
src/backend/optimizer/plan/planner.c | 19 ++
src/backend/optimizer/plan/setrefs.c | 9 +
src/backend/postmaster/launch_backend.c | 3 +
src/backend/utils/adt/pgstatfuncs.c | 7 +-
src/backend/utils/misc/guc_parameters.dat | 7 +
src/backend/utils/misc/guc_tables.c | 18 ++
src/backend/utils/misc/postgresql.conf.sample | 1 +
src/include/catalog/pg_proc.dat | 6 +-
src/include/nodes/pathnodes.h | 3 +
src/include/nodes/plannodes.h | 50 ++---
src/include/nodes/primnodes.h | 4 +-
src/include/nodes/queryjumble.h | 35 +++-
src/include/utils/backend_status.h | 2 +-
src/test/regress/expected/explain.out | 11 ++
src/test/regress/expected/rules.out | 9 +-
src/test/regress/sql/explain.sql | 4 +
23 files changed, 371 insertions(+), 109 deletions(-)
diff --git a/doc/src/sgml/config.sgml b/doc/src/sgml/config.sgml
index 405c9689bd0..4cdaf9c49ba 100644
--- a/doc/src/sgml/config.sgml
+++ b/doc/src/sgml/config.sgml
@@ -8864,6 +8864,40 @@ COPY postgres_log FROM '/full/path/to/logfile.csv' WITH csv;
</listitem>
</varlistentry>
+ <varlistentry id="guc-compute-plan-id" xreflabel="compute_plan_id">
+ <term><varname>compute_plan_id</varname> (<type>enum</type>)
+ <indexterm>
+ <primary><varname>compute_plan_id</varname> configuration parameter</primary>
+ </indexterm>
+ </term>
+ <listitem>
+ <para>
+ Enables in-core computation of a plan identifier.
+ Plan identifiers can be displayed in the <link
+ linkend="monitoring-pg-stat-activity-view"><structname>pg_stat_activity</structname></link>
+ view or using <command>EXPLAIN</command>.
+ Note that an external module can alternatively be used if the
+ in-core plan identifier computation method is not acceptable.
+ In this case, in-core computation must be always disabled.
+ Valid values are <literal>off</literal> (always disabled),
+ <literal>on</literal> (always enabled), <literal>auto</literal>,
+ which lets modules that utilize plan identifiers enable
+ it automatically, and <literal>regress</literal> which
+ has the same effect as <literal>on</literal>, except that the
+ query identifier is not shown in the <literal>EXPLAIN</literal> output
+ in order to facilitate automated regression testing.
+ The default is <literal>auto</literal>.
+ </para>
+ <note>
+ <para>
+ To ensure that only one plan identifier is calculated and
+ displayed, extensions that calculate plan identifiers should
+ throw an error if a plan identifier has already been computed.
+ </para>
+ </note>
+ </listitem>
+ </varlistentry>
+
<varlistentry id="guc-log-statement-stats">
<term><varname>log_statement_stats</varname> (<type>boolean</type>)
<indexterm>
diff --git a/doc/src/sgml/monitoring.sgml b/doc/src/sgml/monitoring.sgml
index 817fd9f4ca7..9e98fd2c198 100644
--- a/doc/src/sgml/monitoring.sgml
+++ b/doc/src/sgml/monitoring.sgml
@@ -983,6 +983,22 @@ postgres 27093 0.0 0.0 30096 2752 ? Ss 11:34 0:00 postgres: ser
</para></entry>
</row>
+ <row>
+ <entry role="catalog_table_entry"><para role="column_definition">
+ <structfield>plan_id</structfield> <type>bigint</type>
+ </para>
+ <para>
+ Identifier of this backend's most recent query plan. If
+ <structfield>state</structfield> is <literal>active</literal> this
+ field shows the identifier of the currently executing query plan. In
+ all other states, it shows the identifier of last query plan that
+ was executed. Plan identifiers are not computed by default so this
+ field will be null unless <xref linkend="guc-compute-plan-id"/>
+ parameter is enabled or a third-party module that computes plan
+ identifiers is configured.
+ </para></entry>
+ </row>
+
<row>
<entry role="catalog_table_entry"><para role="column_definition">
<structfield>query</structfield> <type>text</type>
diff --git a/src/backend/catalog/system_views.sql b/src/backend/catalog/system_views.sql
index 0a0f95f6bb9..35744a82f0b 100644
--- a/src/backend/catalog/system_views.sql
+++ b/src/backend/catalog/system_views.sql
@@ -919,6 +919,7 @@ CREATE VIEW pg_stat_activity AS
S.backend_xid,
S.backend_xmin,
S.query_id,
+ S.plan_id,
S.query,
S.backend_type
FROM pg_stat_get_activity(NULL) AS S
diff --git a/src/backend/commands/explain.c b/src/backend/commands/explain.c
index 5a6390631eb..b21cd142111 100644
--- a/src/backend/commands/explain.c
+++ b/src/backend/commands/explain.c
@@ -818,6 +818,23 @@ ExplainPrintPlan(ExplainState *es, QueryDesc *queryDesc)
ExplainPropertyInteger("Query Identifier", NULL,
queryDesc->plannedstmt->queryId, es);
}
+
+ /*
+ * COMPUTE_PLAN_ID_REGRESS means COMPUTE_PLAN_ID_YES, but we don't show
+ * the queryid in any of the EXPLAIN plans to keep stable the results
+ * generated by regression test suites.
+ */
+ if (es->verbose && queryDesc->plannedstmt->planId != UINT64CONST(0) &&
+ compute_plan_id != COMPUTE_PLAN_ID_REGRESS)
+ {
+ /*
+ * Output the queryid as an int64 rather than a uint64 so we match
+ * what would be seen in the BIGINT pg_stat_activity.plan_id column.
+ */
+ ExplainPropertyInteger("Plan Identifier", NULL,
+ queryDesc->plannedstmt->planId, es);
+ }
+
}
/*
diff --git a/src/backend/executor/execMain.c b/src/backend/executor/execMain.c
index 797d8b1ca1c..14f107d45b1 100644
--- a/src/backend/executor/execMain.c
+++ b/src/backend/executor/execMain.c
@@ -123,13 +123,15 @@ ExecutorStart(QueryDesc *queryDesc, int eflags)
{
/*
* In some cases (e.g. an EXECUTE statement or an execute message with the
- * extended query protocol) the query_id won't be reported, so do it now.
+ * extended query protocol) the query_id and plan_id won't be reported, so
+ * do it now.
*
- * Note that it's harmless to report the query_id multiple times, as the
- * call will be ignored if the top level query_id has already been
- * reported.
+ * Note that it's harmless to report the identifiers multiple times, as
+ * the call will be ignored if the top level query_id or plan_id has
+ * already been reported.
*/
pgstat_report_query_id(queryDesc->plannedstmt->queryId, false);
+ pgstat_report_plan_id(queryDesc->plannedstmt->planId, false);
if (ExecutorStart_hook)
(*ExecutorStart_hook) (queryDesc, eflags);
diff --git a/src/backend/nodes/gen_node_support.pl b/src/backend/nodes/gen_node_support.pl
index 9ecddb14231..eab144bd962 100644
--- a/src/backend/nodes/gen_node_support.pl
+++ b/src/backend/nodes/gen_node_support.pl
@@ -1291,6 +1291,7 @@ _jumble${n}(JumbleState *jstate, Node *node)
{
my $t = $node_type_info{$n}->{field_types}{$f};
my @a = @{ $node_type_info{$n}->{field_attrs}{$f} };
+ my $array_size_field;
my $query_jumble_ignore = $struct_no_query_jumble;
my $query_jumble_custom = 0;
my $query_jumble_location = 0;
@@ -1303,7 +1304,11 @@ _jumble${n}(JumbleState *jstate, Node *node)
{
$query_jumble_custom = 1;
}
- if ($a eq 'query_jumble_ignore')
+ elsif ($a =~ /^array_size\(([\w.]+)\)$/)
+ {
+ $array_size_field = $1;
+ }
+ elsif ($a eq 'query_jumble_ignore')
{
$query_jumble_ignore = 1;
}
@@ -1317,12 +1322,19 @@ _jumble${n}(JumbleState *jstate, Node *node)
}
}
+ next if $query_jumble_ignore;
+
if ($query_jumble_custom)
{
# Custom function that applies to one field of a node.
print $jff "\tJUMBLE_CUSTOM($n, $f);\n"
unless $query_jumble_ignore;
}
+ elsif ($t eq 'Bitmapset*')
+ {
+ print $jff "\tJUMBLE_BITMAPSET($f);\n"
+ unless $query_jumble_ignore;
+ }
elsif (($t =~ /^(\w+)\*$/ or $t =~ /^struct\s+(\w+)\*$/)
and elem $1, @node_types)
{
@@ -1352,6 +1364,26 @@ _jumble${n}(JumbleState *jstate, Node *node)
print $jff "\tJUMBLE_STRING($f);\n"
unless $query_jumble_ignore;
}
+ elsif ($t =~ /^(\w+)(\*|\[\w+\])$/ and elem $1, @scalar_types)
+ {
+ if (!defined $array_size_field)
+ {
+ die "no array size defined for $n.$f of type $t\n";
+ }
+ if ($node_type_info{$n}->{field_types}{$array_size_field} eq
+ 'List*')
+ {
+ print $jff
+ "\tJUMBLE_ARRAY($f, list_length(expr->$array_size_field));\n"
+ unless $query_jumble_ignore;
+ }
+ else
+ {
+ print $jff
+ "\tJUMBLE_ARRAY($f, expr->$array_size_field);\n"
+ unless $query_jumble_ignore;
+ }
+ }
else
{
print $jff "\tJUMBLE_FIELD($f);\n"
diff --git a/src/backend/nodes/queryjumblefuncs.c b/src/backend/nodes/queryjumblefuncs.c
index ffc230af427..5717480dbf5 100644
--- a/src/backend/nodes/queryjumblefuncs.c
+++ b/src/backend/nodes/queryjumblefuncs.c
@@ -3,32 +3,31 @@
* queryjumblefuncs.c
* Query normalization and fingerprinting.
*
- * Normalization is a process whereby similar queries, typically differing only
- * in their constants (though the exact rules are somewhat more subtle than
- * that) are recognized as equivalent, and are tracked as a single entry. This
- * is particularly useful for non-prepared queries.
+ * Fingerprinting selectively serializes key fields within a tree structure,
+ * such as a Query or Plan tree, to create a unique identifier while ignoring
+ * extraneous details. These essential fields are concatenated into a jumble,
+ * from which a 64-bit hash is computed. Unlike regular serialization, this
+ * approach excludes irrelevant information.
+ *
+ * Use Cases:
*
- * Normalization is implemented by fingerprinting queries, selectively
- * serializing those fields of each query tree's nodes that are judged to be
- * essential to the query. This is referred to as a query jumble. This is
- * distinct from a regular serialization in that various extraneous
- * information is ignored as irrelevant or not essential to the query, such
- * as the collations of Vars and, most notably, the values of constants.
- *
- * This jumble is acquired at the end of parse analysis of each query, and
- * a 64-bit hash of it is stored into the query's Query.queryId field.
- * The server then copies this value around, making it available in plan
- * tree(s) generated from the query. The executor can then use this value
- * to blame query costs on the proper queryId.
- *
- * Arrays of two or more constants and PARAM_EXTERN parameters are "squashed"
- * and contribute only once to the jumble. This has the effect that queries
- * that differ only on the length of such lists have the same queryId.
- *
- *
- * Portions Copyright (c) 1996-2025, PostgreSQL Global Development Group
- * Portions Copyright (c) 1994, Regents of the University of California
+ * 1. In-Core Query Normalization & Identification
*
+ * Fingerprinting is used to normalize query trees by generating a hash stored
+ * in the Query.queryId field. This ID is propagated to plan tree(s), allowing
+ * the executor to attribute query costs on the proper queryId. The process
+ * excludes information like typmod, collation, and most notably, the values
+ * of constants.
+ *
+ * Example: The following queries produce the same queryId:
+ *
+ * SELECT t.* FROM s1.t WHERE c1 = 1;
+ * SELECT t.* FROM s1.t WHERE c1 = 2;
+ *
+ * 2. Modified jumbling logic for extensions
+ *
+ * Extensions can modify the fingerprinting logic for queryId, or fingerprint
+ * other types of trees, such as a plan tree, to compute a plan identifier.
*
* IDENTIFICATION
* src/backend/nodes/queryjumblefuncs.c
@@ -50,6 +49,7 @@
/* GUC parameters */
int compute_query_id = COMPUTE_QUERY_ID_AUTO;
+int compute_plan_id = COMPUTE_PLAN_ID_AUTO;
/*
* True when compute_query_id is ON or AUTO, and a module requests them.
@@ -60,15 +60,21 @@ int compute_query_id = COMPUTE_QUERY_ID_AUTO;
*/
bool query_id_enabled = false;
-static JumbleState *InitJumble(void);
-static int64 DoJumble(JumbleState *jstate, Node *node);
+/*
+ * True when compute_plan_id is ON or AUTO, and a module requests them.
+ *
+ * Note that IsPlanIdEnabled() should be used instead of checking
+ * plan_id_enabled or compute_plan_id directly when we want to know
+ * whether query identifiers are computed in the core or not.
+ */
+bool plan_id_enabled = false;
+
static void AppendJumble(JumbleState *jstate,
const unsigned char *value, Size size);
static void FlushPendingNulls(JumbleState *jstate);
static void RecordConstLocation(JumbleState *jstate,
bool extern_param,
int location, int len);
-static void _jumbleNode(JumbleState *jstate, Node *node);
static void _jumbleList(JumbleState *jstate, Node *node);
static void _jumbleElements(JumbleState *jstate, List *elements, Node *node);
static void _jumbleParam(JumbleState *jstate, Node *node);
@@ -136,13 +142,13 @@ CleanQuerytext(const char *query, int *location, int *len)
JumbleState *
JumbleQuery(Query *query)
{
- JumbleState *jstate;
+ JumbleState *jstate = InitializeJumbleState(true);;
Assert(IsQueryIdEnabled());
- jstate = InitJumble();
-
- query->queryId = DoJumble(jstate, (Node *) query);
+ /* Compute query ID and mark the Query node with it */
+ JumbleNode(jstate, (Node *) query);
+ query->queryId = HashJumbleState(jstate);
/*
* If we are unlucky enough to get a hash of zero, use 1 instead for
@@ -173,44 +179,44 @@ EnableQueryId(void)
}
/*
- * InitJumble
- * Allocate a JumbleState object and make it ready to jumble.
+ * Enables plan identifier computation.
+ *
+ * Third-party plugins can use this function to inform core that they require
+ * a query identifier to be computed.
*/
-static JumbleState *
-InitJumble(void)
+void
+EnablePlanId(void)
{
- JumbleState *jstate;
+ if (compute_plan_id != COMPUTE_PLAN_ID_OFF)
+ plan_id_enabled = true;
+}
- jstate = palloc_object(JumbleState);
+/*
+ * InitializeJumbleState
+ * Allocate a JumbleState object and make it ready to jumble.
+ */
+JumbleState *
+InitializeJumbleState(bool record_clocations)
+{
+ JumbleState *jstate = (JumbleState *) palloc0(sizeof(JumbleState));
/* Set up workspace for query jumbling */
jstate->jumble = (unsigned char *) palloc(JUMBLE_SIZE);
jstate->jumble_len = 0;
- jstate->clocations_buf_size = 32;
- jstate->clocations = (LocationLen *) palloc(jstate->clocations_buf_size *
- sizeof(LocationLen));
- jstate->clocations_count = 0;
- jstate->highest_extern_param_id = 0;
- jstate->pending_nulls = 0;
- jstate->has_squashed_lists = false;
-#ifdef USE_ASSERT_CHECKING
- jstate->total_jumble_len = 0;
-#endif
+
+ if (record_clocations)
+ {
+ jstate->clocations_buf_size = 32;
+ jstate->clocations = (LocationLen *)
+ palloc(jstate->clocations_buf_size * sizeof(LocationLen));
+ }
return jstate;
}
-/*
- * DoJumble
- * Jumble the given Node using the given JumbleState and return the resulting
- * jumble hash.
- */
-static int64
-DoJumble(JumbleState *jstate, Node *node)
+uint64
+HashJumbleState(JumbleState *jstate)
{
- /* Jumble the given node */
- _jumbleNode(jstate, node);
-
/* Flush any pending NULLs before doing the final hash */
if (jstate->pending_nulls > 0)
FlushPendingNulls(jstate);
@@ -219,10 +225,9 @@ DoJumble(JumbleState *jstate, Node *node)
if (jstate->has_squashed_lists)
jstate->highest_extern_param_id = 0;
- /* Process the jumble buffer and produce the hash value */
- return DatumGetInt64(hash_any_extended(jstate->jumble,
- jstate->jumble_len,
- 0));
+ return DatumGetUInt64(hash_any_extended(jstate->jumble,
+ jstate->jumble_len,
+ 0));
}
/*
@@ -398,7 +403,7 @@ static void
RecordConstLocation(JumbleState *jstate, bool extern_param, int location, int len)
{
/* -1 indicates unknown or undefined location */
- if (location >= 0)
+ if (location >= 0 && jstate->clocations_buf_size > 0)
{
/* enlarge array if needed */
if (jstate->clocations_count >= jstate->clocations_buf_size)
@@ -526,7 +531,7 @@ IsSquashableConstantList(List *elements)
}
#define JUMBLE_NODE(item) \
- _jumbleNode(jstate, (Node *) expr->item)
+ JumbleNode(jstate, (Node *) expr->item)
#define JUMBLE_ELEMENTS(list, node) \
_jumbleElements(jstate, (List *) expr->list, node)
#define JUMBLE_LOCATION(location) \
@@ -544,6 +549,13 @@ do { \
else \
AppendJumble(jstate, (const unsigned char *) &(expr->item), sizeof(expr->item)); \
} while (0)
+#define JUMBLE_BITMAPSET(item) \
+do { \
+ if (expr->item) \
+ AppendJumble(jstate, (const unsigned char *) expr->item->words, sizeof(bitmapword) * expr->item->nwords); \
+} while(0)
+#define JUMBLE_ARRAY(item, len) \
+ AppendJumble(jstate, (const unsigned char *) expr->item, sizeof(*(expr->item)) * len)
#define JUMBLE_STRING(str) \
do { \
if (expr->str) \
@@ -557,8 +569,8 @@ do { \
#include "queryjumblefuncs.funcs.c"
-static void
-_jumbleNode(JumbleState *jstate, Node *node)
+void
+JumbleNode(JumbleState *jstate, Node *node)
{
Node *expr = node;
#ifdef USE_ASSERT_CHECKING
@@ -612,7 +624,7 @@ _jumbleList(JumbleState *jstate, Node *node)
{
case T_List:
foreach(l, expr)
- _jumbleNode(jstate, lfirst(l));
+ JumbleNode(jstate, lfirst(l));
break;
case T_IntList:
foreach(l, expr)
@@ -668,7 +680,7 @@ _jumbleElements(JumbleState *jstate, List *elements, Node *node)
if (!normalize_list)
{
- _jumbleNode(jstate, (Node *) elements);
+ JumbleNode(jstate, (Node *) elements);
}
}
@@ -758,6 +770,40 @@ _jumbleVariableSetStmt(JumbleState *jstate, Node *node)
JUMBLE_LOCATION(location);
}
+/*
+ * Jumble the entries in the rangle table to map RT indexes to relations
+ *
+ * This ensures jumbled RT indexes (e.g. in a Scan or Modify node), are
+ * distinguished by the target of the RT entry, even if the index is the same.
+ */
+void
+JumbleRangeTable(JumbleState *jstate, List *rtable)
+{
+ ListCell *lc;
+
+ foreach(lc, rtable)
+ {
+ RangeTblEntry *expr = lfirst_node(RangeTblEntry, lc);
+
+ switch (expr->rtekind)
+ {
+ case RTE_RELATION:
+ JUMBLE_FIELD(relid);
+ break;
+ case RTE_CTE:
+ JUMBLE_STRING(ctename);
+ break;
+ default:
+
+ /*
+ * Ignore other targets, the jumble includes something identifying
+ * about them already
+ */
+ break;
+ }
+ }
+}
+
/*
* Custom query jumble function for RangeTblEntry.eref.
*/
diff --git a/src/backend/optimizer/plan/planner.c b/src/backend/optimizer/plan/planner.c
index 8b22c30559b..0309566f602 100644
--- a/src/backend/optimizer/plan/planner.c
+++ b/src/backend/optimizer/plan/planner.c
@@ -37,6 +37,7 @@
#ifdef OPTIMIZER_DEBUG
#include "nodes/print.h"
#endif
+#include "nodes/queryjumble.h"
#include "nodes/supportnodes.h"
#include "optimizer/appendinfo.h"
#include "optimizer/clauses.h"
@@ -578,6 +579,16 @@ standard_planner(Query *parse, const char *query_string, int cursorOptions,
Assert(glob->finalrowmarks == NIL);
Assert(glob->resultRelations == NIL);
Assert(glob->appendRelations == NIL);
+
+ /*
+ * Initialize plan identifier jumble if needed
+ *
+ * Note the actual jumbling is done in the tree walk in
+ * set_plan_references
+ */
+ if (IsPlanIdEnabled())
+ glob->plan_jumble_state = InitializeJumbleState(false);
+
top_plan = set_plan_references(root, top_plan);
/* ... and the subplans (both regular subplans and initplans) */
Assert(list_length(glob->subplans) == list_length(glob->subroots));
@@ -645,6 +656,14 @@ standard_planner(Query *parse, const char *query_string, int cursorOptions,
result->jitFlags |= PGJIT_DEFORM;
}
+ if (IsPlanIdEnabled())
+ {
+ JumbleRangeTable(glob->plan_jumble_state, glob->finalrtable);
+ result->planId = HashJumbleState(glob->plan_jumble_state);
+ pfree(glob->plan_jumble_state->jumble);
+ pfree(glob->plan_jumble_state);
+ }
+
/* Allow plugins to take control before we discard "glob" */
if (planner_shutdown_hook)
(*planner_shutdown_hook) (glob, parse, query_string, result);
diff --git a/src/backend/optimizer/plan/setrefs.c b/src/backend/optimizer/plan/setrefs.c
index cd7ea1e6b58..947bd980c66 100644
--- a/src/backend/optimizer/plan/setrefs.c
+++ b/src/backend/optimizer/plan/setrefs.c
@@ -19,6 +19,7 @@
#include "catalog/pg_type.h"
#include "nodes/makefuncs.h"
#include "nodes/nodeFuncs.h"
+#include "nodes/queryjumble.h"
#include "optimizer/optimizer.h"
#include "optimizer/pathnode.h"
#include "optimizer/planmain.h"
@@ -1338,6 +1339,14 @@ set_plan_refs(PlannerInfo *root, Plan *plan, int rtoffset)
plan->lefttree = set_plan_refs(root, plan->lefttree, rtoffset);
plan->righttree = set_plan_refs(root, plan->righttree, rtoffset);
+ /*
+ * If enabled, append significant information to the plan identifier
+ * jumble (we do this here since we're already walking the tree in a
+ * near-final state)
+ */
+ if (IsPlanIdEnabled())
+ JumbleNode(root->glob->plan_jumble_state, (Node *) plan);
+
return plan;
}
diff --git a/src/backend/postmaster/launch_backend.c b/src/backend/postmaster/launch_backend.c
index 98f7c4848c9..b64c88db200 100644
--- a/src/backend/postmaster/launch_backend.c
+++ b/src/backend/postmaster/launch_backend.c
@@ -118,6 +118,7 @@ typedef struct
bool redirection_done;
bool IsBinaryUpgrade;
bool query_id_enabled;
+ bool plan_id_enabled;
int max_safe_fds;
int MaxBackends;
int num_pmchild_slots;
@@ -757,6 +758,7 @@ save_backend_variables(BackendParameters *param,
param->redirection_done = redirection_done;
param->IsBinaryUpgrade = IsBinaryUpgrade;
param->query_id_enabled = query_id_enabled;
+ param->plan_id_enabled = plan_id_enabled;
param->max_safe_fds = max_safe_fds;
param->MaxBackends = MaxBackends;
@@ -1019,6 +1021,7 @@ restore_backend_variables(BackendParameters *param)
redirection_done = param->redirection_done;
IsBinaryUpgrade = param->IsBinaryUpgrade;
query_id_enabled = param->query_id_enabled;
+ plan_id_enabled = param->plan_id_enabled;
max_safe_fds = param->max_safe_fds;
MaxBackends = param->MaxBackends;
diff --git a/src/backend/utils/adt/pgstatfuncs.c b/src/backend/utils/adt/pgstatfuncs.c
index ef6fffe60b9..854c9f8bffd 100644
--- a/src/backend/utils/adt/pgstatfuncs.c
+++ b/src/backend/utils/adt/pgstatfuncs.c
@@ -351,7 +351,7 @@ pg_stat_get_progress_info(PG_FUNCTION_ARGS)
Datum
pg_stat_get_activity(PG_FUNCTION_ARGS)
{
-#define PG_STAT_GET_ACTIVITY_COLS 31
+#define PG_STAT_GET_ACTIVITY_COLS 32
int num_backends = pgstat_fetch_stat_numbackends();
int curr_backend;
int pid = PG_ARGISNULL(0) ? -1 : PG_GETARG_INT32(0);
@@ -665,6 +665,10 @@ pg_stat_get_activity(PG_FUNCTION_ARGS)
nulls[30] = true;
else
values[30] = Int64GetDatum(beentry->st_query_id);
+ if (beentry->st_plan_id == INT64CONST(0))
+ nulls[31] = true;
+ else
+ values[31] = UInt64GetDatum(beentry->st_plan_id);
}
else
{
@@ -694,6 +698,7 @@ pg_stat_get_activity(PG_FUNCTION_ARGS)
nulls[28] = true;
nulls[29] = true;
nulls[30] = true;
+ nulls[31] = true;
}
tuplestore_putvalues(rsinfo->setResult, rsinfo->setDesc, values, nulls);
diff --git a/src/backend/utils/misc/guc_parameters.dat b/src/backend/utils/misc/guc_parameters.dat
index 3b9d8349078..d9f5cf31c34 100644
--- a/src/backend/utils/misc/guc_parameters.dat
+++ b/src/backend/utils/misc/guc_parameters.dat
@@ -462,6 +462,13 @@
check_hook => 'check_commit_ts_buffers',
},
+{ name => 'compute_plan_id', type => 'enum', context => 'PGC_SUSET', group => 'STATS_MONITORING',
+ short_desc => 'Enables in-core computation of plan identifiers.',
+ variable => 'compute_plan_id',
+ boot_val => 'COMPUTE_PLAN_ID_AUTO',
+ options => 'compute_plan_id_options',
+},
+
{ name => 'compute_query_id', type => 'enum', context => 'PGC_SUSET', group => 'STATS_MONITORING',
short_desc => 'Enables in-core computation of query identifiers.',
variable => 'compute_query_id',
diff --git a/src/backend/utils/misc/guc_tables.c b/src/backend/utils/misc/guc_tables.c
index f87b558c2c6..3a5d7ee32ab 100644
--- a/src/backend/utils/misc/guc_tables.c
+++ b/src/backend/utils/misc/guc_tables.c
@@ -318,6 +318,24 @@ static const struct config_enum_entry compute_query_id_options[] = {
{NULL, 0, false}
};
+/*
+ * Although only "on" and "off" are documented, we accept
+ * all the likely variants of "on" and "off".
+ */
+static const struct config_enum_entry compute_plan_id_options[] = {
+ {"auto", COMPUTE_PLAN_ID_AUTO, false},
+ {"regress", COMPUTE_PLAN_ID_REGRESS, false},
+ {"on", COMPUTE_PLAN_ID_ON, false},
+ {"off", COMPUTE_PLAN_ID_OFF, false},
+ {"true", COMPUTE_PLAN_ID_ON, true},
+ {"false", COMPUTE_PLAN_ID_OFF, true},
+ {"yes", COMPUTE_PLAN_ID_ON, true},
+ {"no", COMPUTE_PLAN_ID_OFF, true},
+ {"1", COMPUTE_PLAN_ID_ON, true},
+ {"0", COMPUTE_PLAN_ID_OFF, true},
+ {NULL, 0, false}
+};
+
/*
* Although only "on", "off", and "partition" are documented, we
* accept all the likely variants of "on" and "off".
diff --git a/src/backend/utils/misc/postgresql.conf.sample b/src/backend/utils/misc/postgresql.conf.sample
index dc9e2255f8a..3d0e42f083b 100644
--- a/src/backend/utils/misc/postgresql.conf.sample
+++ b/src/backend/utils/misc/postgresql.conf.sample
@@ -674,6 +674,7 @@
# - Monitoring -
#compute_query_id = auto
+#compute_plan_id = auto
#log_statement_stats = off
#log_parser_stats = off
#log_planner_stats = off
diff --git a/src/include/catalog/pg_proc.dat b/src/include/catalog/pg_proc.dat
index fd9448ec7b9..2bf284e2732 100644
--- a/src/include/catalog/pg_proc.dat
+++ b/src/include/catalog/pg_proc.dat
@@ -5653,9 +5653,9 @@
proname => 'pg_stat_get_activity', prorows => '100', proisstrict => 'f',
proretset => 't', provolatile => 's', proparallel => 'r',
prorettype => 'record', proargtypes => 'int4',
- proallargtypes => '{int4,oid,int4,oid,text,text,text,text,text,timestamptz,timestamptz,timestamptz,timestamptz,inet,text,int4,xid,xid,text,bool,text,text,int4,text,numeric,text,bool,text,bool,bool,int4,int8}',
- proargmodes => '{i,o,o,o,o,o,o,o,o,o,o,o,o,o,o,o,o,o,o,o,o,o,o,o,o,o,o,o,o,o,o,o}',
- proargnames => '{pid,datid,pid,usesysid,application_name,state,query,wait_event_type,wait_event,xact_start,query_start,backend_start,state_change,client_addr,client_hostname,client_port,backend_xid,backend_xmin,backend_type,ssl,sslversion,sslcipher,sslbits,ssl_client_dn,ssl_client_serial,ssl_issuer_dn,gss_auth,gss_princ,gss_enc,gss_delegation,leader_pid,query_id}',
+ proallargtypes => '{int4,oid,int4,oid,text,text,text,text,text,timestamptz,timestamptz,timestamptz,timestamptz,inet,text,int4,xid,xid,text,bool,text,text,int4,text,numeric,text,bool,text,bool,bool,int4,int8,int8}',
+ proargmodes => '{i,o,o,o,o,o,o,o,o,o,o,o,o,o,o,o,o,o,o,o,o,o,o,o,o,o,o,o,o,o,o,o,o}',
+ proargnames => '{pid,datid,pid,usesysid,application_name,state,query,wait_event_type,wait_event,xact_start,query_start,backend_start,state_change,client_addr,client_hostname,client_port,backend_xid,backend_xmin,backend_type,ssl,sslversion,sslcipher,sslbits,ssl_client_dn,ssl_client_serial,ssl_issuer_dn,gss_auth,gss_princ,gss_enc,gss_delegation,leader_pid,query_id,plan_id}',
prosrc => 'pg_stat_get_activity' },
{ oid => '6318', descr => 'describe wait events',
proname => 'pg_get_wait_events', procost => '10', prorows => '250',
diff --git a/src/include/nodes/pathnodes.h b/src/include/nodes/pathnodes.h
index b5ff456ef7f..c98f7b97283 100644
--- a/src/include/nodes/pathnodes.h
+++ b/src/include/nodes/pathnodes.h
@@ -189,6 +189,9 @@ typedef struct PlannerGlobal
/* extension state */
void **extension_state pg_node_attr(read_write_ignore);
int extension_state_allocated;
+
+ /* optional jumble state for plan identifier calculation */
+ struct JumbleState *plan_jumble_state pg_node_attr(read_write_ignore);
} PlannerGlobal;
/* macro for fetching the Plan associated with a SubPlan node */
diff --git a/src/include/nodes/plannodes.h b/src/include/nodes/plannodes.h
index c4393a94321..a5a2ccea1f7 100644
--- a/src/include/nodes/plannodes.h
+++ b/src/include/nodes/plannodes.h
@@ -70,7 +70,7 @@ typedef struct PlannedStmt
/* query identifier (copied from Query) */
int64 queryId;
- /* plan identifier (can be set by plugins) */
+ /* plan identifier (set when compute_plan_id is enabled or by plugins) */
int64 planId;
/* origin of plan */
@@ -184,7 +184,7 @@ typedef struct PlannedStmt
*/
typedef struct Plan
{
- pg_node_attr(abstract, no_equal, no_query_jumble)
+ pg_node_attr(abstract, no_equal)
NodeTag type;
@@ -192,19 +192,19 @@ typedef struct Plan
* estimated execution costs for plan (see costsize.c for more info)
*/
/* count of disabled nodes */
- int disabled_nodes;
+ int disabled_nodes pg_node_attr(query_jumble_ignore);
/* cost expended before fetching any tuples */
- Cost startup_cost;
+ Cost startup_cost pg_node_attr(query_jumble_ignore);
/* total cost (assuming all tuples fetched) */
- Cost total_cost;
+ Cost total_cost pg_node_attr(query_jumble_ignore);
/*
* planner's estimate of result size of this plan step
*/
/* number of rows plan is expected to emit */
- Cardinality plan_rows;
+ Cardinality plan_rows pg_node_attr(query_jumble_ignore);
/* average row width in bytes */
- int plan_width;
+ int plan_width pg_node_attr(query_jumble_ignore);
/*
* information needed for parallel query
@@ -230,10 +230,10 @@ typedef struct Plan
/* implicitly-ANDed qual conditions */
List *qual;
/* input plan tree(s) */
- struct Plan *lefttree;
- struct Plan *righttree;
+ struct Plan *lefttree pg_node_attr(query_jumble_ignore);
+ struct Plan *righttree pg_node_attr(query_jumble_ignore);
/* Init Plan nodes (un-correlated expr subselects) */
- List *initPlan;
+ List *initPlan pg_node_attr(query_jumble_ignore);
/*
* Information for management of parameter-change-driven rescanning
@@ -351,7 +351,7 @@ typedef struct ModifyTable
/* per-target-table RETURNING tlists */
List *returningLists;
/* per-target-table FDW private data lists */
- List *fdwPrivLists;
+ List *fdwPrivLists pg_node_attr(query_jumble_ignore);
/* indices of FDW DM plans */
Bitmapset *fdwDirectModifyPlans;
/* PlanRowMarks (non-locking only) */
@@ -390,7 +390,7 @@ typedef struct Append
Plan plan;
/* RTIs of appendrel(s) formed by this node */
Bitmapset *apprelids;
- List *appendplans;
+ List *appendplans pg_node_attr(query_jumble_ignore);
/* # of asynchronous plans */
int nasyncplans;
@@ -420,7 +420,7 @@ typedef struct MergeAppend
/* RTIs of appendrel(s) formed by this node */
Bitmapset *apprelids;
- List *mergeplans;
+ List *mergeplans pg_node_attr(query_jumble_ignore);
/* these fields are just like the sort-key info in struct Sort: */
@@ -475,7 +475,7 @@ typedef struct RecursiveUnion
Oid *dupCollations pg_node_attr(array_size(numCols));
/* estimated number of groups in input */
- Cardinality numGroups;
+ long numGroups pg_node_attr(query_jumble_ignore);
} RecursiveUnion;
/* ----------------
@@ -489,7 +489,7 @@ typedef struct RecursiveUnion
typedef struct BitmapAnd
{
Plan plan;
- List *bitmapplans;
+ List *bitmapplans pg_node_attr(query_jumble_ignore);
} BitmapAnd;
/* ----------------
@@ -504,7 +504,7 @@ typedef struct BitmapOr
{
Plan plan;
bool isshared;
- List *bitmapplans;
+ List *bitmapplans pg_node_attr(query_jumble_ignore);
} BitmapOr;
/*
@@ -752,7 +752,7 @@ typedef enum SubqueryScanStatus
typedef struct SubqueryScan
{
Scan scan;
- Plan *subplan;
+ Plan *subplan pg_node_attr(query_jumble_ignore);
SubqueryScanStatus scanstatus;
} SubqueryScan;
@@ -880,7 +880,7 @@ typedef struct ForeignScan
/* expressions that FDW may evaluate */
List *fdw_exprs;
/* private data for FDW */
- List *fdw_private;
+ List *fdw_private pg_node_attr(query_jumble_ignore);
/* optional tlist describing scan tuple */
List *fdw_scan_tlist;
/* original quals not in scan.plan.qual */
@@ -918,7 +918,7 @@ typedef struct CustomScan
/* expressions that custom code may evaluate */
List *custom_exprs;
/* private data for custom code */
- List *custom_private;
+ List *custom_private pg_node_attr(query_jumble_ignore);
/* optional tlist describing scan tuple */
List *custom_scan_tlist;
/* RTIs generated by this scan */
@@ -929,7 +929,7 @@ typedef struct CustomScan
* static table of callback functions. So we don't copy the table itself,
* just reference the original one.
*/
- const struct CustomScanMethods *methods;
+ const struct CustomScanMethods *methods pg_node_attr(query_jumble_ignore);
} CustomScan;
/*
@@ -991,7 +991,7 @@ typedef struct NestLoop
typedef struct NestLoopParam
{
- pg_node_attr(no_equal, no_query_jumble)
+ pg_node_attr(no_equal)
NodeTag type;
/* number of the PARAM_EXEC Param to set */
@@ -1099,7 +1099,7 @@ typedef struct Memoize
* The maximum number of entries that the planner expects will fit in the
* cache, or 0 if unknown
*/
- uint32 est_entries;
+ uint32 est_entries pg_node_attr(query_jumble_ignore);
/* paramids from param_exprs */
Bitmapset *keyparamids;
@@ -1206,7 +1206,7 @@ typedef struct Agg
Oid *grpCollations pg_node_attr(array_size(numCols));
/* estimated number of groups in input */
- Cardinality numGroups;
+ long numGroups pg_node_attr(query_jumble_ignore);
/* for pass-by-ref transition data */
uint64 transitionSpace;
@@ -1415,7 +1415,7 @@ typedef struct Hash
bool skewInherit;
/* all other info is in the parent HashJoin node */
/* estimate total rows if parallel_aware */
- Cardinality rows_total;
+ Cardinality rows_total pg_node_attr(query_jumble_ignore);
} Hash;
/* ----------------
@@ -1446,7 +1446,7 @@ typedef struct SetOp
bool *cmpNullsFirst pg_node_attr(array_size(numCols));
/* estimated number of groups in left input */
- Cardinality numGroups;
+ long numGroups pg_node_attr(query_jumble_ignore);
} SetOp;
/* ----------------
diff --git a/src/include/nodes/primnodes.h b/src/include/nodes/primnodes.h
index 1b4436f2ff6..4ccba6bcd03 100644
--- a/src/include/nodes/primnodes.h
+++ b/src/include/nodes/primnodes.h
@@ -1123,8 +1123,8 @@ typedef struct SubPlan
List *parParam; /* indices of input Params from parent plan */
List *args; /* exprs to pass as parParam values */
/* Estimated execution costs: */
- Cost startup_cost; /* one-time setup cost */
- Cost per_call_cost; /* cost for each subplan evaluation */
+ Cost startup_cost pg_node_attr(query_jumble_ignore); /* one-time setup cost */
+ Cost per_call_cost pg_node_attr(query_jumble_ignore); /* cost for each subplan evaluation */
} SubPlan;
/*
diff --git a/src/include/nodes/queryjumble.h b/src/include/nodes/queryjumble.h
index dcb36dcb44f..aeb20aa0587 100644
--- a/src/include/nodes/queryjumble.h
+++ b/src/include/nodes/queryjumble.h
@@ -15,6 +15,7 @@
#define QUERYJUMBLE_H
#include "nodes/parsenodes.h"
+#include "nodes/pathnodes.h"
/*
* Struct for tracking locations/lengths of constants during normalization
@@ -86,15 +87,26 @@ enum ComputeQueryIdType
COMPUTE_QUERY_ID_REGRESS,
};
+/* Values for the compute_plan_id GUC */
+enum ComputePlanIdType
+{
+ COMPUTE_PLAN_ID_OFF,
+ COMPUTE_PLAN_ID_ON,
+ COMPUTE_PLAN_ID_AUTO,
+ COMPUTE_PLAN_ID_REGRESS,
+};
+
/* GUC parameters */
extern PGDLLIMPORT int compute_query_id;
-
+extern PGDLLIMPORT int compute_plan_id;
extern const char *CleanQuerytext(const char *query, int *location, int *len);
extern JumbleState *JumbleQuery(Query *query);
extern void EnableQueryId(void);
+extern void EnablePlanId(void);
extern PGDLLIMPORT bool query_id_enabled;
+extern PGDLLIMPORT bool plan_id_enabled;
/*
* Returns whether query identifier computation has been enabled, either
@@ -110,4 +122,25 @@ IsQueryIdEnabled(void)
return query_id_enabled;
}
+/*
+ * Returns whether plan identifier computation has been enabled, either
+ * directly in the GUC or by a module when the setting is 'auto'.
+ */
+static inline bool
+IsPlanIdEnabled(void)
+{
+ if (compute_plan_id == COMPUTE_PLAN_ID_OFF)
+ return false;
+ if (compute_plan_id == COMPUTE_PLAN_ID_ON)
+ return true;
+ return plan_id_enabled;
+}
+
+/* Functions called for plan jumbling or extensions doing their own jumbling */
+extern JumbleState *InitializeJumbleState(bool record_clocations);
+//extern void AppendJumble(JumbleState *jstate, const unsigned char *item, Size size);
+extern void JumbleRangeTable(JumbleState *jstate, List *rtable);
+extern void JumbleNode(JumbleState *jstate, Node *node);
+extern uint64 HashJumbleState(JumbleState *jstate);
+
#endif /* QUERYJUMBLE_H */
diff --git a/src/include/utils/backend_status.h b/src/include/utils/backend_status.h
index 3016501ac05..45f00eb93a8 100644
--- a/src/include/utils/backend_status.h
+++ b/src/include/utils/backend_status.h
@@ -172,7 +172,7 @@ typedef struct PgBackendStatus
/* query identifier, optionally computed using post_parse_analyze_hook */
int64 st_query_id;
- /* plan identifier, optionally computed using planner_hook */
+ /* plan identifier, optionally computed after planning */
int64 st_plan_id;
} PgBackendStatus;
diff --git a/src/test/regress/expected/explain.out b/src/test/regress/expected/explain.out
index 7c1f26b182c..7ac025cca84 100644
--- a/src/test/regress/expected/explain.out
+++ b/src/test/regress/expected/explain.out
@@ -743,6 +743,17 @@ select explain_filter('explain (verbose) create table test_ctas as select 1');
Query Identifier: N
(3 rows)
+-- Test compute_plan_id
+set compute_plan_id = on;
+select explain_filter('explain (verbose) select * from int8_tbl i8');
+ explain_filter
+----------------------------------------------------------------
+ Seq Scan on public.int8_tbl i8 (cost=N.N..N.N rows=N width=N)
+ Output: q1, q2
+ Query Identifier: N
+ Plan Identifier: N
+(4 rows)
+
-- Test SERIALIZE option
select explain_filter('explain (analyze,buffers off,serialize) select * from int8_tbl i8');
explain_filter
diff --git a/src/test/regress/expected/rules.out b/src/test/regress/expected/rules.out
index 4286c266e17..29af9bd2de9 100644
--- a/src/test/regress/expected/rules.out
+++ b/src/test/regress/expected/rules.out
@@ -1794,9 +1794,10 @@ pg_stat_activity| SELECT s.datid,
s.backend_xid,
s.backend_xmin,
s.query_id,
+ s.plan_id,
s.query,
s.backend_type
- FROM ((pg_stat_get_activity(NULL::integer) s(datid, pid, usesysid, application_name, state, query, wait_event_type, wait_event, xact_start, query_start, backend_start, state_change, client_addr, client_hostname, client_port, backend_xid, backend_xmin, backend_type, ssl, sslversion, sslcipher, sslbits, ssl_client_dn, ssl_client_serial, ssl_issuer_dn, gss_auth, gss_princ, gss_enc, gss_delegation, leader_pid, query_id)
+ FROM ((pg_stat_get_activity(NULL::integer) s(datid, pid, usesysid, application_name, state, query, wait_event_type, wait_event, xact_start, query_start, backend_start, state_change, client_addr, client_hostname, client_port, backend_xid, backend_xmin, backend_type, ssl, sslversion, sslcipher, sslbits, ssl_client_dn, ssl_client_serial, ssl_issuer_dn, gss_auth, gss_princ, gss_enc, gss_delegation, leader_pid, query_id, plan_id)
LEFT JOIN pg_database d ON ((s.datid = d.oid)))
LEFT JOIN pg_authid u ON ((s.usesysid = u.oid)));
pg_stat_all_indexes| SELECT c.oid AS relid,
@@ -1926,7 +1927,7 @@ pg_stat_gssapi| SELECT pid,
gss_princ AS principal,
gss_enc AS encrypted,
gss_delegation AS credentials_delegated
- FROM pg_stat_get_activity(NULL::integer) s(datid, pid, usesysid, application_name, state, query, wait_event_type, wait_event, xact_start, query_start, backend_start, state_change, client_addr, client_hostname, client_port, backend_xid, backend_xmin, backend_type, ssl, sslversion, sslcipher, sslbits, ssl_client_dn, ssl_client_serial, ssl_issuer_dn, gss_auth, gss_princ, gss_enc, gss_delegation, leader_pid, query_id)
+ FROM pg_stat_get_activity(NULL::integer) s(datid, pid, usesysid, application_name, state, query, wait_event_type, wait_event, xact_start, query_start, backend_start, state_change, client_addr, client_hostname, client_port, backend_xid, backend_xmin, backend_type, ssl, sslversion, sslcipher, sslbits, ssl_client_dn, ssl_client_serial, ssl_issuer_dn, gss_auth, gss_princ, gss_enc, gss_delegation, leader_pid, query_id, plan_id)
WHERE (client_port IS NOT NULL);
pg_stat_io| SELECT backend_type,
object,
@@ -2156,7 +2157,7 @@ pg_stat_replication| SELECT s.pid,
w.sync_priority,
w.sync_state,
w.reply_time
- FROM ((pg_stat_get_activity(NULL::integer) s(datid, pid, usesysid, application_name, state, query, wait_event_type, wait_event, xact_start, query_start, backend_start, state_change, client_addr, client_hostname, client_port, backend_xid, backend_xmin, backend_type, ssl, sslversion, sslcipher, sslbits, ssl_client_dn, ssl_client_serial, ssl_issuer_dn, gss_auth, gss_princ, gss_enc, gss_delegation, leader_pid, query_id)
+ FROM ((pg_stat_get_activity(NULL::integer) s(datid, pid, usesysid, application_name, state, query, wait_event_type, wait_event, xact_start, query_start, backend_start, state_change, client_addr, client_hostname, client_port, backend_xid, backend_xmin, backend_type, ssl, sslversion, sslcipher, sslbits, ssl_client_dn, ssl_client_serial, ssl_issuer_dn, gss_auth, gss_princ, gss_enc, gss_delegation, leader_pid, query_id, plan_id)
JOIN pg_stat_get_wal_senders() w(pid, state, sent_lsn, write_lsn, flush_lsn, replay_lsn, write_lag, flush_lag, replay_lag, sync_priority, sync_state, reply_time) ON ((s.pid = w.pid)))
LEFT JOIN pg_authid u ON ((s.usesysid = u.oid)));
pg_stat_replication_slots| SELECT s.slot_name,
@@ -2193,7 +2194,7 @@ pg_stat_ssl| SELECT pid,
ssl_client_dn AS client_dn,
ssl_client_serial AS client_serial,
ssl_issuer_dn AS issuer_dn
- FROM pg_stat_get_activity(NULL::integer) s(datid, pid, usesysid, application_name, state, query, wait_event_type, wait_event, xact_start, query_start, backend_start, state_change, client_addr, client_hostname, client_port, backend_xid, backend_xmin, backend_type, ssl, sslversion, sslcipher, sslbits, ssl_client_dn, ssl_client_serial, ssl_issuer_dn, gss_auth, gss_princ, gss_enc, gss_delegation, leader_pid, query_id)
+ FROM pg_stat_get_activity(NULL::integer) s(datid, pid, usesysid, application_name, state, query, wait_event_type, wait_event, xact_start, query_start, backend_start, state_change, client_addr, client_hostname, client_port, backend_xid, backend_xmin, backend_type, ssl, sslversion, sslcipher, sslbits, ssl_client_dn, ssl_client_serial, ssl_issuer_dn, gss_auth, gss_princ, gss_enc, gss_delegation, leader_pid, query_id, plan_id)
WHERE (client_port IS NOT NULL);
pg_stat_subscription| SELECT su.oid AS subid,
su.subname,
diff --git a/src/test/regress/sql/explain.sql b/src/test/regress/sql/explain.sql
index ebdab42604b..0449f05c1e1 100644
--- a/src/test/regress/sql/explain.sql
+++ b/src/test/regress/sql/explain.sql
@@ -173,6 +173,10 @@ select explain_filter('explain (verbose) select * from int8_tbl i8');
select explain_filter('explain (verbose) declare test_cur cursor for select * from int8_tbl');
select explain_filter('explain (verbose) create table test_ctas as select 1');
+-- Test compute_plan_id
+set compute_plan_id = on;
+select explain_filter('explain (verbose) select * from int8_tbl i8');
+
-- Test SERIALIZE option
select explain_filter('explain (analyze,buffers off,serialize) select * from int8_tbl i8');
select explain_filter('explain (analyze,serialize text,buffers,timing off) select * from int8_tbl i8');
base-commit: b39013b7b1b116b5d9be51f0919b472b58b3a28d
--
2.43.0
^ permalink raw reply [nested|flat] 10+ messages in thread
* Re: [PATCH] Optionally record Plan IDs to track plan changes for a query
@ 2025-12-25 14:33 Андрей Казачков <[email protected]>
1 sibling, 1 reply; 10+ messages in thread
From: Андрей Казачков @ 2025-12-25 14:33 UTC (permalink / raw)
To: Sami Imseih <[email protected]>; Lukas Fittl <[email protected]>; Michael Paquier <[email protected]>; +Cc: PostgreSQL Hackers <[email protected]>; Marko M <[email protected]>
------==--bound.198681.069451b5-0ade-47f8-8aff-ed0bea292303
Content-Transfer-Encoding: base64
Content-Type: text/html; charset=utf-8
PGRpdj48ZGl2PjxkaXY+RGVhciBQb3N0Z3JlU1FMIEhhY2tlcnMsPC9kaXY+PGRpdj7CoDwvZGl2
PjxkaXY+SeKAmXZlIGJlZW4gdGVzdGluZyB0aGUgcHJvcG9zZWQgdjUgcGxhbiBpZCB3b3JrIGFu
ZCBmb3VuZCBvdXQgaW5zdGFiaWxpdHkgb2Y8L2Rpdj48ZGl2PmNvbXB1dGluZyB0aGUgcGxhbiBp
ZGVudGlmaWVyIGFmdGVyIGZlZWRpbmcgZGlmZmVyZW50IHF1ZXJ5IHRleHRzIHRoYXQ8L2Rpdj48
ZGl2PnByb2R1Y2VzIHRoZSBzYW1lIHBoeXNpY2FsIHBsYW4gdHJlZXMgYnV0IHdpdGggZGlmZmVy
ZW50IHBsYW4gaWRzLiBUaGUgbWFpbjwvZGl2PjxkaXY+cGF0dGVybiByZWdhcmRzIHdpdGggZmll
bGRzIG9mIFBsYW4gbm9kZSBzdHJ1Y3R1cmVzIHRoYXQgZGVwZW5kIG9uIHBvc2l0aW9ucyBvZjwv
ZGl2PjxkaXY+UlRFcyBpbiBhIFJURSBsaXN0LjwvZGl2PjxkaXY+wqA8L2Rpdj48ZGl2PkZvciB5
b3VyIGNvbnZlbmllbmNlLCBJ4oCZdmUgYXR0YWNoZWQgbWluaW1hbCByZXByb2R1Y2libGUgZXhh
bXBsZXMgdGhhdDwvZGl2PjxkaXY+ZGVtb25zdHJhdGUgdGhpcyBwYXR0ZXJuLiBCb3RoIGFyZSBi
YXNlZCBvbiB0aGUgdjYtMDAwMSBwYXRjaCwgd2hpY2g8L2Rpdj48ZGl2PmluY29ycG9yYXRlcyB2
NS0wMDAxLi52NS0wMDAzIGNoYW5nZXMgYW5kIGZpeGVzIGp1bWJsaW5nIGVtcHR5IGFycmF5cy48
L2Rpdj48ZGl2PsKgPC9kaXY+PGRpdj5gYGA8L2Rpdj48ZGl2PmNyZWF0ZSB0YWJsZSBmb28xIChu
dW0gaW50KTs8L2Rpdj48ZGl2PmNyZWF0ZSB0YWJsZSBmb28yIChudW0gaW50KTs8L2Rpdj48ZGl2
PsKgPC9kaXY+PGRpdj5pbnNlcnQgaW50byBmb28xIChudW0pPC9kaXY+PGRpdj5zZWxlY3QgKjwv
ZGl2PjxkaXY+ZnJvbSBnZW5lcmF0ZV9zZXJpZXMoMSwgMTAwMCk7PC9kaXY+PGRpdj7CoDwvZGl2
PjxkaXY+aW5zZXJ0IGludG8gZm9vMiAobnVtKTwvZGl2PjxkaXY+c2VsZWN0ICo8L2Rpdj48ZGl2
PmZyb20gZ2VuZXJhdGVfc2VyaWVzKDEsIDEwKTs8L2Rpdj48ZGl2PsKgPC9kaXY+PGRpdj5hbmFs
eXplIGZvbzE7PC9kaXY+PGRpdj5hbmFseXplIGZvbzI7PC9kaXY+PGRpdj7CoDwvZGl2PjxkaXY+
c2V0IGNvbXB1dGVfcGxhbl9pZCB0byB0cnVlOzwvZGl2PjxkaXY+YGBgPC9kaXY+PGRpdj7CoDwv
ZGl2PjxkaXY+VGhlIGZpcnN0IGV4YW1wbGUgY2hhbmdlcyBqb2luIG9yZGVyIGJldHdlZW4gdHdv
IHRhYmxlczo8L2Rpdj48ZGl2PmBgYDwvZGl2PjxkaXY+ZXhwbGFpbiAoY29zdHMgb2ZmLCB2ZXJi
b3NlKTwvZGl2PjxkaXY+c2VsZWN0IDEgZnJvbSBmb28xIGpvaW4gZm9vMiBvbiBmb28xLm51bSA9
IGZvbzIubnVtOzwvZGl2PjxkaXY+wqA8L2Rpdj48ZGl2PsKgIMKgIMKgIMKgIMKgIMKgIFFVRVJZ
IFBMQU48L2Rpdj48ZGl2Pi0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS08L2Rp
dj48ZGl2PsKgSGFzaCBKb2luPC9kaXY+PGRpdj7CoCDCoE91dHB1dDogMTwvZGl2PjxkaXY+wqAg
wqBIYXNoIENvbmQ6IChmb28xLm51bSA9IGZvbzIubnVtKTwvZGl2PjxkaXY+wqAgwqAtJmd0OyDC
oFNlcSBTY2FuIG9uIHB1YmxpYy5mb28xPC9kaXY+PGRpdj7CoCDCoCDCoCDCoCDCoE91dHB1dDog
Zm9vMS5udW08L2Rpdj48ZGl2PsKgIMKgLSZndDsgwqBIYXNoPC9kaXY+PGRpdj7CoCDCoCDCoCDC
oCDCoE91dHB1dDogZm9vMi5udW08L2Rpdj48ZGl2PsKgIMKgIMKgIMKgIMKgLSZndDsgwqBTZXEg
U2NhbiBvbiBwdWJsaWMuZm9vMjwvZGl2PjxkaXY+wqAgwqAgwqAgwqAgwqAgwqAgwqAgwqBPdXRw
dXQ6IGZvbzIubnVtPC9kaXY+PGRpdj7CoFBsYW4gSWRlbnRpZmllcjogNTM4NjQzMTYwMTg2MjIy
MTY4PC9kaXY+PGRpdj7CoDwvZGl2PjxkaXY+ZXhwbGFpbiAoY29zdHMgb2ZmLCB2ZXJib3NlKTwv
ZGl2PjxkaXY+c2VsZWN0IDEgZnJvbSBmb28yIGpvaW4gZm9vMSBvbiBmb28xLm51bSA9IGZvbzIu
bnVtOzwvZGl2PjxkaXY+wqA8L2Rpdj48ZGl2PsKgIMKgIMKgIMKgIMKgIMKgIMKgUVVFUlkgUExB
TjwvZGl2PjxkaXY+LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS08L2Rpdj48
ZGl2PsKgSGFzaCBKb2luPC9kaXY+PGRpdj7CoCDCoE91dHB1dDogMTwvZGl2PjxkaXY+wqAgwqBI
YXNoIENvbmQ6IChmb28xLm51bSA9IGZvbzIubnVtKTwvZGl2PjxkaXY+wqAgwqAtJmd0OyDCoFNl
cSBTY2FuIG9uIHB1YmxpYy5mb28xPC9kaXY+PGRpdj7CoCDCoCDCoCDCoCDCoE91dHB1dDogZm9v
MS5udW08L2Rpdj48ZGl2PsKgIMKgLSZndDsgwqBIYXNoPC9kaXY+PGRpdj7CoCDCoCDCoCDCoCDC
oE91dHB1dDogZm9vMi5udW08L2Rpdj48ZGl2PsKgIMKgIMKgIMKgIMKgLSZndDsgwqBTZXEgU2Nh
biBvbiBwdWJsaWMuZm9vMjwvZGl2PjxkaXY+wqAgwqAgwqAgwqAgwqAgwqAgwqAgwqBPdXRwdXQ6
IGZvbzIubnVtPC9kaXY+PGRpdj7CoFBsYW4gSWRlbnRpZmllcjogLTk1MzE0MzAzNDg0MTA4OTQ5
ODwvZGl2PjxkaXY+YGBgPC9kaXY+PGRpdj5IZXJlIHRoZSByZW9yZGVyaW5nIG9mIHJlbGF0aW9u
cyBpbiB0aGUgSk9JTiBvcGVyYXRvciBjaGFuZ2VzIHRoZWlyIG9yZGVyIGluPC9kaXY+PGRpdj50
aGUgUlRFIGxpc3QsIHdoaWNoIGluIHR1cm4gY2hhbmdlcyBSVEUgcG9zaXRpb24tc2Vuc2l0aXZl
IGZpZWxkcyBsaWtlIGB2YXJub2A8L2Rpdj48ZGl2PmluIFZhcnMsIGFuZCB0aG9zZSBkaWZmZXJl
bmNlcyBsZWFrIGludG8ganVtYmxpbmcuPC9kaXY+PGRpdj7CoDwvZGl2PjxkaXY+VGhlIHNlY29u
ZCBleGFtcGxlIGFzc3VtZXMgdHJhbnNmb3JtYXRpb24gb2Ygc29tZSB0YWJsZSBleHByZXNzaW9u
cyB0byBhPC9kaXY+PGRpdj5uZXcgZm9ybSBsaWtlIENURS1pbmxpbmluZyBvciBjb21wbGV0ZWx5
IGl0cyBlbGltaW5hdGluZy4gTGV0J3Mgc2VlIGV4YW1wbGU6PC9kaXY+PGRpdj5gYGA8L2Rpdj48
ZGl2PmV4cGxhaW4gKGNvc3RzIG9mZiwgdmVyYm9zZSk8L2Rpdj48ZGl2PldJVEggZm9vX2N0ZSBh
cyAoPC9kaXY+PGRpdj7CoCBTRUxFQ1QgbnVtIEZST00gZm9vMSk8L2Rpdj48ZGl2PnNlbGVjdCAq
IGZyb20gZm9vX2N0ZTs8L2Rpdj48ZGl2PsKgPC9kaXY+PGRpdj7CoCDCoCDCoCDCoCDCoCDCoCDC
oCBRVUVSWSBQTEFOPC9kaXY+PGRpdj4tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t
LS0tLTwvZGl2PjxkaXY+wqBTZXEgU2NhbiBvbiBwdWJsaWMuZm9vMTwvZGl2PjxkaXY+wqAgwqBP
dXRwdXQ6IGZvbzEubnVtPC9kaXY+PGRpdj7CoFBsYW4gSWRlbnRpZmllcjogMzQ5NDM5NDYzMDc1
NzE3MzA5OTwvZGl2PjxkaXY+wqA8L2Rpdj48ZGl2PmV4cGxhaW4gKGNvc3RzIG9mZiwgdmVyYm9z
ZSk8L2Rpdj48ZGl2PnNlbGVjdCAqIGZyb20gZm9vMTs8L2Rpdj48ZGl2PsKgPC9kaXY+PGRpdj7C
oCDCoCDCoCDCoCDCoCDCoCDCoCBRVUVSWSBQTEFOPC9kaXY+PGRpdj4tLS0tLS0tLS0tLS0tLS0t
LS0tLS0tLS0tLS0tLS0tLS0tLS0tLTwvZGl2PjxkaXY+wqBTZXEgU2NhbiBvbiBwdWJsaWMuZm9v
MTwvZGl2PjxkaXY+wqAgwqBPdXRwdXQ6IG51bTwvZGl2PjxkaXY+wqBQbGFuIElkZW50aWZpZXI6
IDgxMTYxNDM2NzcyNjA3NzEyMjg8L2Rpdj48ZGl2PmBgYDwvZGl2PjxkaXY+SW4gdGhlIGV4YW1w
bGUgd2l0aCBhIENURSwgUlRFIGxpc3QgY29udGFpbnMgdGhlIG91dGRhdGVkIHN1YnF1ZXJ5IGl0
ZW0gYW5kIHRoZTwvZGl2PjxkaXY+cmVsYXRpb24gb25lLCB3aGVyZWFzIHdpdGhvdXQgYSBDVEUg
d2UgaGF2ZSBqdXN0IHRoZSByZWxhdGlvbiBpdGVtLiBBbHRob3VnaDwvZGl2PjxkaXY+dGhlIENU
RSBpcyBpbmxpbmVkLCBpdHMgUlRFIGlzIG5vdCByZW1vdmVkIGZyb20gdGhlIHJ0YWJsZTsgYXMg
YSByZXN1bHQsPC9kaXY+PGRpdj5wb3NpdGlvbi1zZW5zaXRpdmUgZmllbGRzIChzdWNoIGFzIGB2
YXJub2AgZm9yIFZhcnMpIGRpZmZlciBmcm9tIHRoZSBuby1DVEU8L2Rpdj48ZGl2PmNhc2UuPC9k
aXY+PGRpdj7CoDwvZGl2PjxkaXY+QSBwb3NzaWJsZSB3YXkgdG8gYWRkcmVzcyBpdCBkdXJpbmcg
anVtYmxpbmcgcHJvY2Vzczo8L2Rpdj48ZGl2PjEuIFJlbW92ZS9za2lwIHVudXNlZCBSVEUgbGlz
dCBlbGVtZW50cy48L2Rpdj48ZGl2PjIuIFNvcnQgYWN0aXZlIFJURSBsaXN0IGVsZW1lbnRzIGJ5
IHNvbWUgc3RhYmxlIGNyaXRlcmlhLjwvZGl2PjxkaXY+My4gQWRqdXN0IGZpZWxkcyByZWZlcnJp
bmcgdG8gYWN0aXZlIFJURXMuPC9kaXY+PGRpdj7CoDwvZGl2PjxkaXY+QnV0IHRoZSBtYWluIGNo
YWxsZW5nZSBpcyBpZGVudGlmeWluZyBhbGwg4oCccG9zaXRpb24tc2Vuc2l0aXZl4oCdIGZpZWxk
cyBhY3Jvc3M8L2Rpdj48ZGl2Pm5vZGUgdHlwZXMgZWZmaWNpZW50bHkgYW5kIG1haW50YWluYWJs
eS4gSeKAmWQgaGFwcHkgdG8gc2VlIHlvdXIgZmVlZGJhY2sgb248L2Rpdj48ZGl2PnRoaXMgaXNz
dWUuPC9kaXY+PGRpdj7CoDwvZGl2PjxkaXY+QWRkaXRpb25hbGx5LCBJIG5vdGljZWQgdGhhdCB0
aGUgYGxvY2F0aW9uYCBmaWVsZCBpcyBiZWluZyBqdW1ibGVkIGZvciBzZXZlcmFsPC9kaXY+PGRp
dj5zdHJ1Y3R1cmVzIChmb3IgZXhhbXBsZSwgYFZhcmApLiBTaW5jZSBpdOKAmXMgb25seSBhIHRv
a2VuIGxvY2F0aW9uLCBJIGJlbGlldmUgd2U8L2Rpdj48ZGl2PnNob3VsZCBub3QgaW5jbHVkZSBp
dCBpbiB0aGUgZmluYWwgcGxhbiBpZCB2YWx1ZS48L2Rpdj48ZGl2PsKgPC9kaXY+PGRpdj4tLTwv
ZGl2PjxkaXY+U2luY2VyZWx5LDwvZGl2PjxkaXY+QW5kcmV5IEthemFjaGtvdjwvZGl2PjwvZGl2
PjwvZGl2Pg==
------==--bound.198681.069451b5-0ade-47f8-8aff-ed0bea292303
Content-Disposition: attachment;
filename="v6-0001-Add-plan_id-support-to-the-core.patch"
Content-Transfer-Encoding: base64
Content-Type: text/x-diff;
name="v6-0001-Add-plan_id-support-to-the-core.patch"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------==--bound.198681.069451b5-0ade-47f8-8aff-ed0bea292303--
Attachments:
[text/x-diff] v6-0001-Add-plan_id-support-to-the-core.patch (43.7K, 2-v6-0001-Add-plan_id-support-to-the-core.patch)
download | inline diff:
From 3d40912f2cba7ba2c2edae06a4a3d016607a1513 Mon Sep 17 00:00:00 2001
From: Andrey Kazachkov <[email protected]>
Date: Tue, 16 Dec 2025 19:52:39 +0300
Subject: [PATCH v6] Add plan_id support to the core.
---
doc/src/sgml/config.sgml | 34 ++++
doc/src/sgml/monitoring.sgml | 16 ++
src/backend/catalog/system_views.sql | 1 +
src/backend/commands/explain.c | 17 ++
src/backend/executor/execMain.c | 10 +-
src/backend/nodes/gen_node_support.pl | 34 +++-
src/backend/nodes/queryjumblefuncs.c | 183 +++++++++++-------
src/backend/optimizer/plan/planner.c | 19 ++
src/backend/optimizer/plan/setrefs.c | 9 +
src/backend/postmaster/launch_backend.c | 3 +
src/backend/utils/adt/pgstatfuncs.c | 7 +-
src/backend/utils/misc/guc_parameters.dat | 7 +
src/backend/utils/misc/guc_tables.c | 18 ++
src/backend/utils/misc/postgresql.conf.sample | 1 +
src/include/catalog/pg_proc.dat | 6 +-
src/include/nodes/pathnodes.h | 3 +
src/include/nodes/plannodes.h | 50 ++---
src/include/nodes/primnodes.h | 4 +-
src/include/nodes/queryjumble.h | 35 +++-
src/include/utils/backend_status.h | 2 +-
src/test/regress/expected/explain.out | 11 ++
src/test/regress/expected/rules.out | 9 +-
src/test/regress/sql/explain.sql | 4 +
23 files changed, 374 insertions(+), 109 deletions(-)
diff --git a/doc/src/sgml/config.sgml b/doc/src/sgml/config.sgml
index 405c9689bd0..4cdaf9c49ba 100644
--- a/doc/src/sgml/config.sgml
+++ b/doc/src/sgml/config.sgml
@@ -8864,6 +8864,40 @@ COPY postgres_log FROM '/full/path/to/logfile.csv' WITH csv;
</listitem>
</varlistentry>
+ <varlistentry id="guc-compute-plan-id" xreflabel="compute_plan_id">
+ <term><varname>compute_plan_id</varname> (<type>enum</type>)
+ <indexterm>
+ <primary><varname>compute_plan_id</varname> configuration parameter</primary>
+ </indexterm>
+ </term>
+ <listitem>
+ <para>
+ Enables in-core computation of a plan identifier.
+ Plan identifiers can be displayed in the <link
+ linkend="monitoring-pg-stat-activity-view"><structname>pg_stat_activity</structname></link>
+ view or using <command>EXPLAIN</command>.
+ Note that an external module can alternatively be used if the
+ in-core plan identifier computation method is not acceptable.
+ In this case, in-core computation must be always disabled.
+ Valid values are <literal>off</literal> (always disabled),
+ <literal>on</literal> (always enabled), <literal>auto</literal>,
+ which lets modules that utilize plan identifiers enable
+ it automatically, and <literal>regress</literal> which
+ has the same effect as <literal>on</literal>, except that the
+ query identifier is not shown in the <literal>EXPLAIN</literal> output
+ in order to facilitate automated regression testing.
+ The default is <literal>auto</literal>.
+ </para>
+ <note>
+ <para>
+ To ensure that only one plan identifier is calculated and
+ displayed, extensions that calculate plan identifiers should
+ throw an error if a plan identifier has already been computed.
+ </para>
+ </note>
+ </listitem>
+ </varlistentry>
+
<varlistentry id="guc-log-statement-stats">
<term><varname>log_statement_stats</varname> (<type>boolean</type>)
<indexterm>
diff --git a/doc/src/sgml/monitoring.sgml b/doc/src/sgml/monitoring.sgml
index 817fd9f4ca7..9e98fd2c198 100644
--- a/doc/src/sgml/monitoring.sgml
+++ b/doc/src/sgml/monitoring.sgml
@@ -983,6 +983,22 @@ postgres 27093 0.0 0.0 30096 2752 ? Ss 11:34 0:00 postgres: ser
</para></entry>
</row>
+ <row>
+ <entry role="catalog_table_entry"><para role="column_definition">
+ <structfield>plan_id</structfield> <type>bigint</type>
+ </para>
+ <para>
+ Identifier of this backend's most recent query plan. If
+ <structfield>state</structfield> is <literal>active</literal> this
+ field shows the identifier of the currently executing query plan. In
+ all other states, it shows the identifier of last query plan that
+ was executed. Plan identifiers are not computed by default so this
+ field will be null unless <xref linkend="guc-compute-plan-id"/>
+ parameter is enabled or a third-party module that computes plan
+ identifiers is configured.
+ </para></entry>
+ </row>
+
<row>
<entry role="catalog_table_entry"><para role="column_definition">
<structfield>query</structfield> <type>text</type>
diff --git a/src/backend/catalog/system_views.sql b/src/backend/catalog/system_views.sql
index 0a0f95f6bb9..35744a82f0b 100644
--- a/src/backend/catalog/system_views.sql
+++ b/src/backend/catalog/system_views.sql
@@ -919,6 +919,7 @@ CREATE VIEW pg_stat_activity AS
S.backend_xid,
S.backend_xmin,
S.query_id,
+ S.plan_id,
S.query,
S.backend_type
FROM pg_stat_get_activity(NULL) AS S
diff --git a/src/backend/commands/explain.c b/src/backend/commands/explain.c
index 5a6390631eb..b21cd142111 100644
--- a/src/backend/commands/explain.c
+++ b/src/backend/commands/explain.c
@@ -818,6 +818,23 @@ ExplainPrintPlan(ExplainState *es, QueryDesc *queryDesc)
ExplainPropertyInteger("Query Identifier", NULL,
queryDesc->plannedstmt->queryId, es);
}
+
+ /*
+ * COMPUTE_PLAN_ID_REGRESS means COMPUTE_PLAN_ID_YES, but we don't show
+ * the queryid in any of the EXPLAIN plans to keep stable the results
+ * generated by regression test suites.
+ */
+ if (es->verbose && queryDesc->plannedstmt->planId != UINT64CONST(0) &&
+ compute_plan_id != COMPUTE_PLAN_ID_REGRESS)
+ {
+ /*
+ * Output the queryid as an int64 rather than a uint64 so we match
+ * what would be seen in the BIGINT pg_stat_activity.plan_id column.
+ */
+ ExplainPropertyInteger("Plan Identifier", NULL,
+ queryDesc->plannedstmt->planId, es);
+ }
+
}
/*
diff --git a/src/backend/executor/execMain.c b/src/backend/executor/execMain.c
index 797d8b1ca1c..14f107d45b1 100644
--- a/src/backend/executor/execMain.c
+++ b/src/backend/executor/execMain.c
@@ -123,13 +123,15 @@ ExecutorStart(QueryDesc *queryDesc, int eflags)
{
/*
* In some cases (e.g. an EXECUTE statement or an execute message with the
- * extended query protocol) the query_id won't be reported, so do it now.
+ * extended query protocol) the query_id and plan_id won't be reported, so
+ * do it now.
*
- * Note that it's harmless to report the query_id multiple times, as the
- * call will be ignored if the top level query_id has already been
- * reported.
+ * Note that it's harmless to report the identifiers multiple times, as
+ * the call will be ignored if the top level query_id or plan_id has
+ * already been reported.
*/
pgstat_report_query_id(queryDesc->plannedstmt->queryId, false);
+ pgstat_report_plan_id(queryDesc->plannedstmt->planId, false);
if (ExecutorStart_hook)
(*ExecutorStart_hook) (queryDesc, eflags);
diff --git a/src/backend/nodes/gen_node_support.pl b/src/backend/nodes/gen_node_support.pl
index 9ecddb14231..eab144bd962 100644
--- a/src/backend/nodes/gen_node_support.pl
+++ b/src/backend/nodes/gen_node_support.pl
@@ -1291,6 +1291,7 @@ _jumble${n}(JumbleState *jstate, Node *node)
{
my $t = $node_type_info{$n}->{field_types}{$f};
my @a = @{ $node_type_info{$n}->{field_attrs}{$f} };
+ my $array_size_field;
my $query_jumble_ignore = $struct_no_query_jumble;
my $query_jumble_custom = 0;
my $query_jumble_location = 0;
@@ -1303,7 +1304,11 @@ _jumble${n}(JumbleState *jstate, Node *node)
{
$query_jumble_custom = 1;
}
- if ($a eq 'query_jumble_ignore')
+ elsif ($a =~ /^array_size\(([\w.]+)\)$/)
+ {
+ $array_size_field = $1;
+ }
+ elsif ($a eq 'query_jumble_ignore')
{
$query_jumble_ignore = 1;
}
@@ -1317,12 +1322,19 @@ _jumble${n}(JumbleState *jstate, Node *node)
}
}
+ next if $query_jumble_ignore;
+
if ($query_jumble_custom)
{
# Custom function that applies to one field of a node.
print $jff "\tJUMBLE_CUSTOM($n, $f);\n"
unless $query_jumble_ignore;
}
+ elsif ($t eq 'Bitmapset*')
+ {
+ print $jff "\tJUMBLE_BITMAPSET($f);\n"
+ unless $query_jumble_ignore;
+ }
elsif (($t =~ /^(\w+)\*$/ or $t =~ /^struct\s+(\w+)\*$/)
and elem $1, @node_types)
{
@@ -1352,6 +1364,26 @@ _jumble${n}(JumbleState *jstate, Node *node)
print $jff "\tJUMBLE_STRING($f);\n"
unless $query_jumble_ignore;
}
+ elsif ($t =~ /^(\w+)(\*|\[\w+\])$/ and elem $1, @scalar_types)
+ {
+ if (!defined $array_size_field)
+ {
+ die "no array size defined for $n.$f of type $t\n";
+ }
+ if ($node_type_info{$n}->{field_types}{$array_size_field} eq
+ 'List*')
+ {
+ print $jff
+ "\tJUMBLE_ARRAY($f, list_length(expr->$array_size_field));\n"
+ unless $query_jumble_ignore;
+ }
+ else
+ {
+ print $jff
+ "\tJUMBLE_ARRAY($f, expr->$array_size_field);\n"
+ unless $query_jumble_ignore;
+ }
+ }
else
{
print $jff "\tJUMBLE_FIELD($f);\n"
diff --git a/src/backend/nodes/queryjumblefuncs.c b/src/backend/nodes/queryjumblefuncs.c
index ffc230af427..a0d28827269 100644
--- a/src/backend/nodes/queryjumblefuncs.c
+++ b/src/backend/nodes/queryjumblefuncs.c
@@ -3,32 +3,31 @@
* queryjumblefuncs.c
* Query normalization and fingerprinting.
*
- * Normalization is a process whereby similar queries, typically differing only
- * in their constants (though the exact rules are somewhat more subtle than
- * that) are recognized as equivalent, and are tracked as a single entry. This
- * is particularly useful for non-prepared queries.
+ * Fingerprinting selectively serializes key fields within a tree structure,
+ * such as a Query or Plan tree, to create a unique identifier while ignoring
+ * extraneous details. These essential fields are concatenated into a jumble,
+ * from which a 64-bit hash is computed. Unlike regular serialization, this
+ * approach excludes irrelevant information.
+ *
+ * Use Cases:
*
- * Normalization is implemented by fingerprinting queries, selectively
- * serializing those fields of each query tree's nodes that are judged to be
- * essential to the query. This is referred to as a query jumble. This is
- * distinct from a regular serialization in that various extraneous
- * information is ignored as irrelevant or not essential to the query, such
- * as the collations of Vars and, most notably, the values of constants.
- *
- * This jumble is acquired at the end of parse analysis of each query, and
- * a 64-bit hash of it is stored into the query's Query.queryId field.
- * The server then copies this value around, making it available in plan
- * tree(s) generated from the query. The executor can then use this value
- * to blame query costs on the proper queryId.
- *
- * Arrays of two or more constants and PARAM_EXTERN parameters are "squashed"
- * and contribute only once to the jumble. This has the effect that queries
- * that differ only on the length of such lists have the same queryId.
- *
- *
- * Portions Copyright (c) 1996-2025, PostgreSQL Global Development Group
- * Portions Copyright (c) 1994, Regents of the University of California
+ * 1. In-Core Query Normalization & Identification
*
+ * Fingerprinting is used to normalize query trees by generating a hash stored
+ * in the Query.queryId field. This ID is propagated to plan tree(s), allowing
+ * the executor to attribute query costs on the proper queryId. The process
+ * excludes information like typmod, collation, and most notably, the values
+ * of constants.
+ *
+ * Example: The following queries produce the same queryId:
+ *
+ * SELECT t.* FROM s1.t WHERE c1 = 1;
+ * SELECT t.* FROM s1.t WHERE c1 = 2;
+ *
+ * 2. Modified jumbling logic for extensions
+ *
+ * Extensions can modify the fingerprinting logic for queryId, or fingerprint
+ * other types of trees, such as a plan tree, to compute a plan identifier.
*
* IDENTIFICATION
* src/backend/nodes/queryjumblefuncs.c
@@ -50,6 +49,7 @@
/* GUC parameters */
int compute_query_id = COMPUTE_QUERY_ID_AUTO;
+int compute_plan_id = COMPUTE_PLAN_ID_AUTO;
/*
* True when compute_query_id is ON or AUTO, and a module requests them.
@@ -60,15 +60,21 @@ int compute_query_id = COMPUTE_QUERY_ID_AUTO;
*/
bool query_id_enabled = false;
-static JumbleState *InitJumble(void);
-static int64 DoJumble(JumbleState *jstate, Node *node);
+/*
+ * True when compute_plan_id is ON or AUTO, and a module requests them.
+ *
+ * Note that IsPlanIdEnabled() should be used instead of checking
+ * plan_id_enabled or compute_plan_id directly when we want to know
+ * whether query identifiers are computed in the core or not.
+ */
+bool plan_id_enabled = false;
+
static void AppendJumble(JumbleState *jstate,
const unsigned char *value, Size size);
static void FlushPendingNulls(JumbleState *jstate);
static void RecordConstLocation(JumbleState *jstate,
bool extern_param,
int location, int len);
-static void _jumbleNode(JumbleState *jstate, Node *node);
static void _jumbleList(JumbleState *jstate, Node *node);
static void _jumbleElements(JumbleState *jstate, List *elements, Node *node);
static void _jumbleParam(JumbleState *jstate, Node *node);
@@ -136,13 +142,13 @@ CleanQuerytext(const char *query, int *location, int *len)
JumbleState *
JumbleQuery(Query *query)
{
- JumbleState *jstate;
+ JumbleState *jstate = InitializeJumbleState(true);;
Assert(IsQueryIdEnabled());
- jstate = InitJumble();
-
- query->queryId = DoJumble(jstate, (Node *) query);
+ /* Compute query ID and mark the Query node with it */
+ JumbleNode(jstate, (Node *) query);
+ query->queryId = HashJumbleState(jstate);
/*
* If we are unlucky enough to get a hash of zero, use 1 instead for
@@ -173,44 +179,44 @@ EnableQueryId(void)
}
/*
- * InitJumble
- * Allocate a JumbleState object and make it ready to jumble.
+ * Enables plan identifier computation.
+ *
+ * Third-party plugins can use this function to inform core that they require
+ * a query identifier to be computed.
*/
-static JumbleState *
-InitJumble(void)
+void
+EnablePlanId(void)
{
- JumbleState *jstate;
+ if (compute_plan_id != COMPUTE_PLAN_ID_OFF)
+ plan_id_enabled = true;
+}
- jstate = palloc_object(JumbleState);
+/*
+ * InitializeJumbleState
+ * Allocate a JumbleState object and make it ready to jumble.
+ */
+JumbleState *
+InitializeJumbleState(bool record_clocations)
+{
+ JumbleState *jstate = (JumbleState *) palloc0(sizeof(JumbleState));
/* Set up workspace for query jumbling */
jstate->jumble = (unsigned char *) palloc(JUMBLE_SIZE);
jstate->jumble_len = 0;
- jstate->clocations_buf_size = 32;
- jstate->clocations = (LocationLen *) palloc(jstate->clocations_buf_size *
- sizeof(LocationLen));
- jstate->clocations_count = 0;
- jstate->highest_extern_param_id = 0;
- jstate->pending_nulls = 0;
- jstate->has_squashed_lists = false;
-#ifdef USE_ASSERT_CHECKING
- jstate->total_jumble_len = 0;
-#endif
+
+ if (record_clocations)
+ {
+ jstate->clocations_buf_size = 32;
+ jstate->clocations = (LocationLen *)
+ palloc(jstate->clocations_buf_size * sizeof(LocationLen));
+ }
return jstate;
}
-/*
- * DoJumble
- * Jumble the given Node using the given JumbleState and return the resulting
- * jumble hash.
- */
-static int64
-DoJumble(JumbleState *jstate, Node *node)
+uint64
+HashJumbleState(JumbleState *jstate)
{
- /* Jumble the given node */
- _jumbleNode(jstate, node);
-
/* Flush any pending NULLs before doing the final hash */
if (jstate->pending_nulls > 0)
FlushPendingNulls(jstate);
@@ -219,10 +225,9 @@ DoJumble(JumbleState *jstate, Node *node)
if (jstate->has_squashed_lists)
jstate->highest_extern_param_id = 0;
- /* Process the jumble buffer and produce the hash value */
- return DatumGetInt64(hash_any_extended(jstate->jumble,
- jstate->jumble_len,
- 0));
+ return DatumGetUInt64(hash_any_extended(jstate->jumble,
+ jstate->jumble_len,
+ 0));
}
/*
@@ -398,7 +403,7 @@ static void
RecordConstLocation(JumbleState *jstate, bool extern_param, int location, int len)
{
/* -1 indicates unknown or undefined location */
- if (location >= 0)
+ if (location >= 0 && jstate->clocations_buf_size > 0)
{
/* enlarge array if needed */
if (jstate->clocations_count >= jstate->clocations_buf_size)
@@ -526,7 +531,7 @@ IsSquashableConstantList(List *elements)
}
#define JUMBLE_NODE(item) \
- _jumbleNode(jstate, (Node *) expr->item)
+ JumbleNode(jstate, (Node *) expr->item)
#define JUMBLE_ELEMENTS(list, node) \
_jumbleElements(jstate, (List *) expr->list, node)
#define JUMBLE_LOCATION(location) \
@@ -544,6 +549,16 @@ do { \
else \
AppendJumble(jstate, (const unsigned char *) &(expr->item), sizeof(expr->item)); \
} while (0)
+#define JUMBLE_BITMAPSET(item) \
+do { \
+ if (expr->item) \
+ AppendJumble(jstate, (const unsigned char *) expr->item->words, sizeof(bitmapword) * expr->item->nwords); \
+} while(0)
+#define JUMBLE_ARRAY(item, len) \
+ do { \
+ if (len) \
+ AppendJumble(jstate, (const unsigned char *) expr->item, sizeof(*(expr->item)) * len); \
+ } while (0)
#define JUMBLE_STRING(str) \
do { \
if (expr->str) \
@@ -557,8 +572,8 @@ do { \
#include "queryjumblefuncs.funcs.c"
-static void
-_jumbleNode(JumbleState *jstate, Node *node)
+void
+JumbleNode(JumbleState *jstate, Node *node)
{
Node *expr = node;
#ifdef USE_ASSERT_CHECKING
@@ -612,7 +627,7 @@ _jumbleList(JumbleState *jstate, Node *node)
{
case T_List:
foreach(l, expr)
- _jumbleNode(jstate, lfirst(l));
+ JumbleNode(jstate, lfirst(l));
break;
case T_IntList:
foreach(l, expr)
@@ -668,7 +683,7 @@ _jumbleElements(JumbleState *jstate, List *elements, Node *node)
if (!normalize_list)
{
- _jumbleNode(jstate, (Node *) elements);
+ JumbleNode(jstate, (Node *) elements);
}
}
@@ -758,6 +773,40 @@ _jumbleVariableSetStmt(JumbleState *jstate, Node *node)
JUMBLE_LOCATION(location);
}
+/*
+ * Jumble the entries in the rangle table to map RT indexes to relations
+ *
+ * This ensures jumbled RT indexes (e.g. in a Scan or Modify node), are
+ * distinguished by the target of the RT entry, even if the index is the same.
+ */
+void
+JumbleRangeTable(JumbleState *jstate, List *rtable)
+{
+ ListCell *lc;
+
+ foreach(lc, rtable)
+ {
+ RangeTblEntry *expr = lfirst_node(RangeTblEntry, lc);
+
+ switch (expr->rtekind)
+ {
+ case RTE_RELATION:
+ JUMBLE_FIELD(relid);
+ break;
+ case RTE_CTE:
+ JUMBLE_STRING(ctename);
+ break;
+ default:
+
+ /*
+ * Ignore other targets, the jumble includes something identifying
+ * about them already
+ */
+ break;
+ }
+ }
+}
+
/*
* Custom query jumble function for RangeTblEntry.eref.
*/
diff --git a/src/backend/optimizer/plan/planner.c b/src/backend/optimizer/plan/planner.c
index 8b22c30559b..0309566f602 100644
--- a/src/backend/optimizer/plan/planner.c
+++ b/src/backend/optimizer/plan/planner.c
@@ -37,6 +37,7 @@
#ifdef OPTIMIZER_DEBUG
#include "nodes/print.h"
#endif
+#include "nodes/queryjumble.h"
#include "nodes/supportnodes.h"
#include "optimizer/appendinfo.h"
#include "optimizer/clauses.h"
@@ -578,6 +579,16 @@ standard_planner(Query *parse, const char *query_string, int cursorOptions,
Assert(glob->finalrowmarks == NIL);
Assert(glob->resultRelations == NIL);
Assert(glob->appendRelations == NIL);
+
+ /*
+ * Initialize plan identifier jumble if needed
+ *
+ * Note the actual jumbling is done in the tree walk in
+ * set_plan_references
+ */
+ if (IsPlanIdEnabled())
+ glob->plan_jumble_state = InitializeJumbleState(false);
+
top_plan = set_plan_references(root, top_plan);
/* ... and the subplans (both regular subplans and initplans) */
Assert(list_length(glob->subplans) == list_length(glob->subroots));
@@ -645,6 +656,14 @@ standard_planner(Query *parse, const char *query_string, int cursorOptions,
result->jitFlags |= PGJIT_DEFORM;
}
+ if (IsPlanIdEnabled())
+ {
+ JumbleRangeTable(glob->plan_jumble_state, glob->finalrtable);
+ result->planId = HashJumbleState(glob->plan_jumble_state);
+ pfree(glob->plan_jumble_state->jumble);
+ pfree(glob->plan_jumble_state);
+ }
+
/* Allow plugins to take control before we discard "glob" */
if (planner_shutdown_hook)
(*planner_shutdown_hook) (glob, parse, query_string, result);
diff --git a/src/backend/optimizer/plan/setrefs.c b/src/backend/optimizer/plan/setrefs.c
index cd7ea1e6b58..947bd980c66 100644
--- a/src/backend/optimizer/plan/setrefs.c
+++ b/src/backend/optimizer/plan/setrefs.c
@@ -19,6 +19,7 @@
#include "catalog/pg_type.h"
#include "nodes/makefuncs.h"
#include "nodes/nodeFuncs.h"
+#include "nodes/queryjumble.h"
#include "optimizer/optimizer.h"
#include "optimizer/pathnode.h"
#include "optimizer/planmain.h"
@@ -1338,6 +1339,14 @@ set_plan_refs(PlannerInfo *root, Plan *plan, int rtoffset)
plan->lefttree = set_plan_refs(root, plan->lefttree, rtoffset);
plan->righttree = set_plan_refs(root, plan->righttree, rtoffset);
+ /*
+ * If enabled, append significant information to the plan identifier
+ * jumble (we do this here since we're already walking the tree in a
+ * near-final state)
+ */
+ if (IsPlanIdEnabled())
+ JumbleNode(root->glob->plan_jumble_state, (Node *) plan);
+
return plan;
}
diff --git a/src/backend/postmaster/launch_backend.c b/src/backend/postmaster/launch_backend.c
index 98f7c4848c9..b64c88db200 100644
--- a/src/backend/postmaster/launch_backend.c
+++ b/src/backend/postmaster/launch_backend.c
@@ -118,6 +118,7 @@ typedef struct
bool redirection_done;
bool IsBinaryUpgrade;
bool query_id_enabled;
+ bool plan_id_enabled;
int max_safe_fds;
int MaxBackends;
int num_pmchild_slots;
@@ -757,6 +758,7 @@ save_backend_variables(BackendParameters *param,
param->redirection_done = redirection_done;
param->IsBinaryUpgrade = IsBinaryUpgrade;
param->query_id_enabled = query_id_enabled;
+ param->plan_id_enabled = plan_id_enabled;
param->max_safe_fds = max_safe_fds;
param->MaxBackends = MaxBackends;
@@ -1019,6 +1021,7 @@ restore_backend_variables(BackendParameters *param)
redirection_done = param->redirection_done;
IsBinaryUpgrade = param->IsBinaryUpgrade;
query_id_enabled = param->query_id_enabled;
+ plan_id_enabled = param->plan_id_enabled;
max_safe_fds = param->max_safe_fds;
MaxBackends = param->MaxBackends;
diff --git a/src/backend/utils/adt/pgstatfuncs.c b/src/backend/utils/adt/pgstatfuncs.c
index ef6fffe60b9..854c9f8bffd 100644
--- a/src/backend/utils/adt/pgstatfuncs.c
+++ b/src/backend/utils/adt/pgstatfuncs.c
@@ -351,7 +351,7 @@ pg_stat_get_progress_info(PG_FUNCTION_ARGS)
Datum
pg_stat_get_activity(PG_FUNCTION_ARGS)
{
-#define PG_STAT_GET_ACTIVITY_COLS 31
+#define PG_STAT_GET_ACTIVITY_COLS 32
int num_backends = pgstat_fetch_stat_numbackends();
int curr_backend;
int pid = PG_ARGISNULL(0) ? -1 : PG_GETARG_INT32(0);
@@ -665,6 +665,10 @@ pg_stat_get_activity(PG_FUNCTION_ARGS)
nulls[30] = true;
else
values[30] = Int64GetDatum(beentry->st_query_id);
+ if (beentry->st_plan_id == INT64CONST(0))
+ nulls[31] = true;
+ else
+ values[31] = UInt64GetDatum(beentry->st_plan_id);
}
else
{
@@ -694,6 +698,7 @@ pg_stat_get_activity(PG_FUNCTION_ARGS)
nulls[28] = true;
nulls[29] = true;
nulls[30] = true;
+ nulls[31] = true;
}
tuplestore_putvalues(rsinfo->setResult, rsinfo->setDesc, values, nulls);
diff --git a/src/backend/utils/misc/guc_parameters.dat b/src/backend/utils/misc/guc_parameters.dat
index 3b9d8349078..d9f5cf31c34 100644
--- a/src/backend/utils/misc/guc_parameters.dat
+++ b/src/backend/utils/misc/guc_parameters.dat
@@ -462,6 +462,13 @@
check_hook => 'check_commit_ts_buffers',
},
+{ name => 'compute_plan_id', type => 'enum', context => 'PGC_SUSET', group => 'STATS_MONITORING',
+ short_desc => 'Enables in-core computation of plan identifiers.',
+ variable => 'compute_plan_id',
+ boot_val => 'COMPUTE_PLAN_ID_AUTO',
+ options => 'compute_plan_id_options',
+},
+
{ name => 'compute_query_id', type => 'enum', context => 'PGC_SUSET', group => 'STATS_MONITORING',
short_desc => 'Enables in-core computation of query identifiers.',
variable => 'compute_query_id',
diff --git a/src/backend/utils/misc/guc_tables.c b/src/backend/utils/misc/guc_tables.c
index f87b558c2c6..3a5d7ee32ab 100644
--- a/src/backend/utils/misc/guc_tables.c
+++ b/src/backend/utils/misc/guc_tables.c
@@ -318,6 +318,24 @@ static const struct config_enum_entry compute_query_id_options[] = {
{NULL, 0, false}
};
+/*
+ * Although only "on" and "off" are documented, we accept
+ * all the likely variants of "on" and "off".
+ */
+static const struct config_enum_entry compute_plan_id_options[] = {
+ {"auto", COMPUTE_PLAN_ID_AUTO, false},
+ {"regress", COMPUTE_PLAN_ID_REGRESS, false},
+ {"on", COMPUTE_PLAN_ID_ON, false},
+ {"off", COMPUTE_PLAN_ID_OFF, false},
+ {"true", COMPUTE_PLAN_ID_ON, true},
+ {"false", COMPUTE_PLAN_ID_OFF, true},
+ {"yes", COMPUTE_PLAN_ID_ON, true},
+ {"no", COMPUTE_PLAN_ID_OFF, true},
+ {"1", COMPUTE_PLAN_ID_ON, true},
+ {"0", COMPUTE_PLAN_ID_OFF, true},
+ {NULL, 0, false}
+};
+
/*
* Although only "on", "off", and "partition" are documented, we
* accept all the likely variants of "on" and "off".
diff --git a/src/backend/utils/misc/postgresql.conf.sample b/src/backend/utils/misc/postgresql.conf.sample
index dc9e2255f8a..3d0e42f083b 100644
--- a/src/backend/utils/misc/postgresql.conf.sample
+++ b/src/backend/utils/misc/postgresql.conf.sample
@@ -674,6 +674,7 @@
# - Monitoring -
#compute_query_id = auto
+#compute_plan_id = auto
#log_statement_stats = off
#log_parser_stats = off
#log_planner_stats = off
diff --git a/src/include/catalog/pg_proc.dat b/src/include/catalog/pg_proc.dat
index fd9448ec7b9..2bf284e2732 100644
--- a/src/include/catalog/pg_proc.dat
+++ b/src/include/catalog/pg_proc.dat
@@ -5653,9 +5653,9 @@
proname => 'pg_stat_get_activity', prorows => '100', proisstrict => 'f',
proretset => 't', provolatile => 's', proparallel => 'r',
prorettype => 'record', proargtypes => 'int4',
- proallargtypes => '{int4,oid,int4,oid,text,text,text,text,text,timestamptz,timestamptz,timestamptz,timestamptz,inet,text,int4,xid,xid,text,bool,text,text,int4,text,numeric,text,bool,text,bool,bool,int4,int8}',
- proargmodes => '{i,o,o,o,o,o,o,o,o,o,o,o,o,o,o,o,o,o,o,o,o,o,o,o,o,o,o,o,o,o,o,o}',
- proargnames => '{pid,datid,pid,usesysid,application_name,state,query,wait_event_type,wait_event,xact_start,query_start,backend_start,state_change,client_addr,client_hostname,client_port,backend_xid,backend_xmin,backend_type,ssl,sslversion,sslcipher,sslbits,ssl_client_dn,ssl_client_serial,ssl_issuer_dn,gss_auth,gss_princ,gss_enc,gss_delegation,leader_pid,query_id}',
+ proallargtypes => '{int4,oid,int4,oid,text,text,text,text,text,timestamptz,timestamptz,timestamptz,timestamptz,inet,text,int4,xid,xid,text,bool,text,text,int4,text,numeric,text,bool,text,bool,bool,int4,int8,int8}',
+ proargmodes => '{i,o,o,o,o,o,o,o,o,o,o,o,o,o,o,o,o,o,o,o,o,o,o,o,o,o,o,o,o,o,o,o,o}',
+ proargnames => '{pid,datid,pid,usesysid,application_name,state,query,wait_event_type,wait_event,xact_start,query_start,backend_start,state_change,client_addr,client_hostname,client_port,backend_xid,backend_xmin,backend_type,ssl,sslversion,sslcipher,sslbits,ssl_client_dn,ssl_client_serial,ssl_issuer_dn,gss_auth,gss_princ,gss_enc,gss_delegation,leader_pid,query_id,plan_id}',
prosrc => 'pg_stat_get_activity' },
{ oid => '6318', descr => 'describe wait events',
proname => 'pg_get_wait_events', procost => '10', prorows => '250',
diff --git a/src/include/nodes/pathnodes.h b/src/include/nodes/pathnodes.h
index b5ff456ef7f..c98f7b97283 100644
--- a/src/include/nodes/pathnodes.h
+++ b/src/include/nodes/pathnodes.h
@@ -189,6 +189,9 @@ typedef struct PlannerGlobal
/* extension state */
void **extension_state pg_node_attr(read_write_ignore);
int extension_state_allocated;
+
+ /* optional jumble state for plan identifier calculation */
+ struct JumbleState *plan_jumble_state pg_node_attr(read_write_ignore);
} PlannerGlobal;
/* macro for fetching the Plan associated with a SubPlan node */
diff --git a/src/include/nodes/plannodes.h b/src/include/nodes/plannodes.h
index c4393a94321..a5a2ccea1f7 100644
--- a/src/include/nodes/plannodes.h
+++ b/src/include/nodes/plannodes.h
@@ -70,7 +70,7 @@ typedef struct PlannedStmt
/* query identifier (copied from Query) */
int64 queryId;
- /* plan identifier (can be set by plugins) */
+ /* plan identifier (set when compute_plan_id is enabled or by plugins) */
int64 planId;
/* origin of plan */
@@ -184,7 +184,7 @@ typedef struct PlannedStmt
*/
typedef struct Plan
{
- pg_node_attr(abstract, no_equal, no_query_jumble)
+ pg_node_attr(abstract, no_equal)
NodeTag type;
@@ -192,19 +192,19 @@ typedef struct Plan
* estimated execution costs for plan (see costsize.c for more info)
*/
/* count of disabled nodes */
- int disabled_nodes;
+ int disabled_nodes pg_node_attr(query_jumble_ignore);
/* cost expended before fetching any tuples */
- Cost startup_cost;
+ Cost startup_cost pg_node_attr(query_jumble_ignore);
/* total cost (assuming all tuples fetched) */
- Cost total_cost;
+ Cost total_cost pg_node_attr(query_jumble_ignore);
/*
* planner's estimate of result size of this plan step
*/
/* number of rows plan is expected to emit */
- Cardinality plan_rows;
+ Cardinality plan_rows pg_node_attr(query_jumble_ignore);
/* average row width in bytes */
- int plan_width;
+ int plan_width pg_node_attr(query_jumble_ignore);
/*
* information needed for parallel query
@@ -230,10 +230,10 @@ typedef struct Plan
/* implicitly-ANDed qual conditions */
List *qual;
/* input plan tree(s) */
- struct Plan *lefttree;
- struct Plan *righttree;
+ struct Plan *lefttree pg_node_attr(query_jumble_ignore);
+ struct Plan *righttree pg_node_attr(query_jumble_ignore);
/* Init Plan nodes (un-correlated expr subselects) */
- List *initPlan;
+ List *initPlan pg_node_attr(query_jumble_ignore);
/*
* Information for management of parameter-change-driven rescanning
@@ -351,7 +351,7 @@ typedef struct ModifyTable
/* per-target-table RETURNING tlists */
List *returningLists;
/* per-target-table FDW private data lists */
- List *fdwPrivLists;
+ List *fdwPrivLists pg_node_attr(query_jumble_ignore);
/* indices of FDW DM plans */
Bitmapset *fdwDirectModifyPlans;
/* PlanRowMarks (non-locking only) */
@@ -390,7 +390,7 @@ typedef struct Append
Plan plan;
/* RTIs of appendrel(s) formed by this node */
Bitmapset *apprelids;
- List *appendplans;
+ List *appendplans pg_node_attr(query_jumble_ignore);
/* # of asynchronous plans */
int nasyncplans;
@@ -420,7 +420,7 @@ typedef struct MergeAppend
/* RTIs of appendrel(s) formed by this node */
Bitmapset *apprelids;
- List *mergeplans;
+ List *mergeplans pg_node_attr(query_jumble_ignore);
/* these fields are just like the sort-key info in struct Sort: */
@@ -475,7 +475,7 @@ typedef struct RecursiveUnion
Oid *dupCollations pg_node_attr(array_size(numCols));
/* estimated number of groups in input */
- Cardinality numGroups;
+ long numGroups pg_node_attr(query_jumble_ignore);
} RecursiveUnion;
/* ----------------
@@ -489,7 +489,7 @@ typedef struct RecursiveUnion
typedef struct BitmapAnd
{
Plan plan;
- List *bitmapplans;
+ List *bitmapplans pg_node_attr(query_jumble_ignore);
} BitmapAnd;
/* ----------------
@@ -504,7 +504,7 @@ typedef struct BitmapOr
{
Plan plan;
bool isshared;
- List *bitmapplans;
+ List *bitmapplans pg_node_attr(query_jumble_ignore);
} BitmapOr;
/*
@@ -752,7 +752,7 @@ typedef enum SubqueryScanStatus
typedef struct SubqueryScan
{
Scan scan;
- Plan *subplan;
+ Plan *subplan pg_node_attr(query_jumble_ignore);
SubqueryScanStatus scanstatus;
} SubqueryScan;
@@ -880,7 +880,7 @@ typedef struct ForeignScan
/* expressions that FDW may evaluate */
List *fdw_exprs;
/* private data for FDW */
- List *fdw_private;
+ List *fdw_private pg_node_attr(query_jumble_ignore);
/* optional tlist describing scan tuple */
List *fdw_scan_tlist;
/* original quals not in scan.plan.qual */
@@ -918,7 +918,7 @@ typedef struct CustomScan
/* expressions that custom code may evaluate */
List *custom_exprs;
/* private data for custom code */
- List *custom_private;
+ List *custom_private pg_node_attr(query_jumble_ignore);
/* optional tlist describing scan tuple */
List *custom_scan_tlist;
/* RTIs generated by this scan */
@@ -929,7 +929,7 @@ typedef struct CustomScan
* static table of callback functions. So we don't copy the table itself,
* just reference the original one.
*/
- const struct CustomScanMethods *methods;
+ const struct CustomScanMethods *methods pg_node_attr(query_jumble_ignore);
} CustomScan;
/*
@@ -991,7 +991,7 @@ typedef struct NestLoop
typedef struct NestLoopParam
{
- pg_node_attr(no_equal, no_query_jumble)
+ pg_node_attr(no_equal)
NodeTag type;
/* number of the PARAM_EXEC Param to set */
@@ -1099,7 +1099,7 @@ typedef struct Memoize
* The maximum number of entries that the planner expects will fit in the
* cache, or 0 if unknown
*/
- uint32 est_entries;
+ uint32 est_entries pg_node_attr(query_jumble_ignore);
/* paramids from param_exprs */
Bitmapset *keyparamids;
@@ -1206,7 +1206,7 @@ typedef struct Agg
Oid *grpCollations pg_node_attr(array_size(numCols));
/* estimated number of groups in input */
- Cardinality numGroups;
+ long numGroups pg_node_attr(query_jumble_ignore);
/* for pass-by-ref transition data */
uint64 transitionSpace;
@@ -1415,7 +1415,7 @@ typedef struct Hash
bool skewInherit;
/* all other info is in the parent HashJoin node */
/* estimate total rows if parallel_aware */
- Cardinality rows_total;
+ Cardinality rows_total pg_node_attr(query_jumble_ignore);
} Hash;
/* ----------------
@@ -1446,7 +1446,7 @@ typedef struct SetOp
bool *cmpNullsFirst pg_node_attr(array_size(numCols));
/* estimated number of groups in left input */
- Cardinality numGroups;
+ long numGroups pg_node_attr(query_jumble_ignore);
} SetOp;
/* ----------------
diff --git a/src/include/nodes/primnodes.h b/src/include/nodes/primnodes.h
index 1b4436f2ff6..4ccba6bcd03 100644
--- a/src/include/nodes/primnodes.h
+++ b/src/include/nodes/primnodes.h
@@ -1123,8 +1123,8 @@ typedef struct SubPlan
List *parParam; /* indices of input Params from parent plan */
List *args; /* exprs to pass as parParam values */
/* Estimated execution costs: */
- Cost startup_cost; /* one-time setup cost */
- Cost per_call_cost; /* cost for each subplan evaluation */
+ Cost startup_cost pg_node_attr(query_jumble_ignore); /* one-time setup cost */
+ Cost per_call_cost pg_node_attr(query_jumble_ignore); /* cost for each subplan evaluation */
} SubPlan;
/*
diff --git a/src/include/nodes/queryjumble.h b/src/include/nodes/queryjumble.h
index dcb36dcb44f..aeb20aa0587 100644
--- a/src/include/nodes/queryjumble.h
+++ b/src/include/nodes/queryjumble.h
@@ -15,6 +15,7 @@
#define QUERYJUMBLE_H
#include "nodes/parsenodes.h"
+#include "nodes/pathnodes.h"
/*
* Struct for tracking locations/lengths of constants during normalization
@@ -86,15 +87,26 @@ enum ComputeQueryIdType
COMPUTE_QUERY_ID_REGRESS,
};
+/* Values for the compute_plan_id GUC */
+enum ComputePlanIdType
+{
+ COMPUTE_PLAN_ID_OFF,
+ COMPUTE_PLAN_ID_ON,
+ COMPUTE_PLAN_ID_AUTO,
+ COMPUTE_PLAN_ID_REGRESS,
+};
+
/* GUC parameters */
extern PGDLLIMPORT int compute_query_id;
-
+extern PGDLLIMPORT int compute_plan_id;
extern const char *CleanQuerytext(const char *query, int *location, int *len);
extern JumbleState *JumbleQuery(Query *query);
extern void EnableQueryId(void);
+extern void EnablePlanId(void);
extern PGDLLIMPORT bool query_id_enabled;
+extern PGDLLIMPORT bool plan_id_enabled;
/*
* Returns whether query identifier computation has been enabled, either
@@ -110,4 +122,25 @@ IsQueryIdEnabled(void)
return query_id_enabled;
}
+/*
+ * Returns whether plan identifier computation has been enabled, either
+ * directly in the GUC or by a module when the setting is 'auto'.
+ */
+static inline bool
+IsPlanIdEnabled(void)
+{
+ if (compute_plan_id == COMPUTE_PLAN_ID_OFF)
+ return false;
+ if (compute_plan_id == COMPUTE_PLAN_ID_ON)
+ return true;
+ return plan_id_enabled;
+}
+
+/* Functions called for plan jumbling or extensions doing their own jumbling */
+extern JumbleState *InitializeJumbleState(bool record_clocations);
+//extern void AppendJumble(JumbleState *jstate, const unsigned char *item, Size size);
+extern void JumbleRangeTable(JumbleState *jstate, List *rtable);
+extern void JumbleNode(JumbleState *jstate, Node *node);
+extern uint64 HashJumbleState(JumbleState *jstate);
+
#endif /* QUERYJUMBLE_H */
diff --git a/src/include/utils/backend_status.h b/src/include/utils/backend_status.h
index 3016501ac05..45f00eb93a8 100644
--- a/src/include/utils/backend_status.h
+++ b/src/include/utils/backend_status.h
@@ -172,7 +172,7 @@ typedef struct PgBackendStatus
/* query identifier, optionally computed using post_parse_analyze_hook */
int64 st_query_id;
- /* plan identifier, optionally computed using planner_hook */
+ /* plan identifier, optionally computed after planning */
int64 st_plan_id;
} PgBackendStatus;
diff --git a/src/test/regress/expected/explain.out b/src/test/regress/expected/explain.out
index 7c1f26b182c..7ac025cca84 100644
--- a/src/test/regress/expected/explain.out
+++ b/src/test/regress/expected/explain.out
@@ -743,6 +743,17 @@ select explain_filter('explain (verbose) create table test_ctas as select 1');
Query Identifier: N
(3 rows)
+-- Test compute_plan_id
+set compute_plan_id = on;
+select explain_filter('explain (verbose) select * from int8_tbl i8');
+ explain_filter
+----------------------------------------------------------------
+ Seq Scan on public.int8_tbl i8 (cost=N.N..N.N rows=N width=N)
+ Output: q1, q2
+ Query Identifier: N
+ Plan Identifier: N
+(4 rows)
+
-- Test SERIALIZE option
select explain_filter('explain (analyze,buffers off,serialize) select * from int8_tbl i8');
explain_filter
diff --git a/src/test/regress/expected/rules.out b/src/test/regress/expected/rules.out
index 4286c266e17..29af9bd2de9 100644
--- a/src/test/regress/expected/rules.out
+++ b/src/test/regress/expected/rules.out
@@ -1794,9 +1794,10 @@ pg_stat_activity| SELECT s.datid,
s.backend_xid,
s.backend_xmin,
s.query_id,
+ s.plan_id,
s.query,
s.backend_type
- FROM ((pg_stat_get_activity(NULL::integer) s(datid, pid, usesysid, application_name, state, query, wait_event_type, wait_event, xact_start, query_start, backend_start, state_change, client_addr, client_hostname, client_port, backend_xid, backend_xmin, backend_type, ssl, sslversion, sslcipher, sslbits, ssl_client_dn, ssl_client_serial, ssl_issuer_dn, gss_auth, gss_princ, gss_enc, gss_delegation, leader_pid, query_id)
+ FROM ((pg_stat_get_activity(NULL::integer) s(datid, pid, usesysid, application_name, state, query, wait_event_type, wait_event, xact_start, query_start, backend_start, state_change, client_addr, client_hostname, client_port, backend_xid, backend_xmin, backend_type, ssl, sslversion, sslcipher, sslbits, ssl_client_dn, ssl_client_serial, ssl_issuer_dn, gss_auth, gss_princ, gss_enc, gss_delegation, leader_pid, query_id, plan_id)
LEFT JOIN pg_database d ON ((s.datid = d.oid)))
LEFT JOIN pg_authid u ON ((s.usesysid = u.oid)));
pg_stat_all_indexes| SELECT c.oid AS relid,
@@ -1926,7 +1927,7 @@ pg_stat_gssapi| SELECT pid,
gss_princ AS principal,
gss_enc AS encrypted,
gss_delegation AS credentials_delegated
- FROM pg_stat_get_activity(NULL::integer) s(datid, pid, usesysid, application_name, state, query, wait_event_type, wait_event, xact_start, query_start, backend_start, state_change, client_addr, client_hostname, client_port, backend_xid, backend_xmin, backend_type, ssl, sslversion, sslcipher, sslbits, ssl_client_dn, ssl_client_serial, ssl_issuer_dn, gss_auth, gss_princ, gss_enc, gss_delegation, leader_pid, query_id)
+ FROM pg_stat_get_activity(NULL::integer) s(datid, pid, usesysid, application_name, state, query, wait_event_type, wait_event, xact_start, query_start, backend_start, state_change, client_addr, client_hostname, client_port, backend_xid, backend_xmin, backend_type, ssl, sslversion, sslcipher, sslbits, ssl_client_dn, ssl_client_serial, ssl_issuer_dn, gss_auth, gss_princ, gss_enc, gss_delegation, leader_pid, query_id, plan_id)
WHERE (client_port IS NOT NULL);
pg_stat_io| SELECT backend_type,
object,
@@ -2156,7 +2157,7 @@ pg_stat_replication| SELECT s.pid,
w.sync_priority,
w.sync_state,
w.reply_time
- FROM ((pg_stat_get_activity(NULL::integer) s(datid, pid, usesysid, application_name, state, query, wait_event_type, wait_event, xact_start, query_start, backend_start, state_change, client_addr, client_hostname, client_port, backend_xid, backend_xmin, backend_type, ssl, sslversion, sslcipher, sslbits, ssl_client_dn, ssl_client_serial, ssl_issuer_dn, gss_auth, gss_princ, gss_enc, gss_delegation, leader_pid, query_id)
+ FROM ((pg_stat_get_activity(NULL::integer) s(datid, pid, usesysid, application_name, state, query, wait_event_type, wait_event, xact_start, query_start, backend_start, state_change, client_addr, client_hostname, client_port, backend_xid, backend_xmin, backend_type, ssl, sslversion, sslcipher, sslbits, ssl_client_dn, ssl_client_serial, ssl_issuer_dn, gss_auth, gss_princ, gss_enc, gss_delegation, leader_pid, query_id, plan_id)
JOIN pg_stat_get_wal_senders() w(pid, state, sent_lsn, write_lsn, flush_lsn, replay_lsn, write_lag, flush_lag, replay_lag, sync_priority, sync_state, reply_time) ON ((s.pid = w.pid)))
LEFT JOIN pg_authid u ON ((s.usesysid = u.oid)));
pg_stat_replication_slots| SELECT s.slot_name,
@@ -2193,7 +2194,7 @@ pg_stat_ssl| SELECT pid,
ssl_client_dn AS client_dn,
ssl_client_serial AS client_serial,
ssl_issuer_dn AS issuer_dn
- FROM pg_stat_get_activity(NULL::integer) s(datid, pid, usesysid, application_name, state, query, wait_event_type, wait_event, xact_start, query_start, backend_start, state_change, client_addr, client_hostname, client_port, backend_xid, backend_xmin, backend_type, ssl, sslversion, sslcipher, sslbits, ssl_client_dn, ssl_client_serial, ssl_issuer_dn, gss_auth, gss_princ, gss_enc, gss_delegation, leader_pid, query_id)
+ FROM pg_stat_get_activity(NULL::integer) s(datid, pid, usesysid, application_name, state, query, wait_event_type, wait_event, xact_start, query_start, backend_start, state_change, client_addr, client_hostname, client_port, backend_xid, backend_xmin, backend_type, ssl, sslversion, sslcipher, sslbits, ssl_client_dn, ssl_client_serial, ssl_issuer_dn, gss_auth, gss_princ, gss_enc, gss_delegation, leader_pid, query_id, plan_id)
WHERE (client_port IS NOT NULL);
pg_stat_subscription| SELECT su.oid AS subid,
su.subname,
diff --git a/src/test/regress/sql/explain.sql b/src/test/regress/sql/explain.sql
index ebdab42604b..0449f05c1e1 100644
--- a/src/test/regress/sql/explain.sql
+++ b/src/test/regress/sql/explain.sql
@@ -173,6 +173,10 @@ select explain_filter('explain (verbose) select * from int8_tbl i8');
select explain_filter('explain (verbose) declare test_cur cursor for select * from int8_tbl');
select explain_filter('explain (verbose) create table test_ctas as select 1');
+-- Test compute_plan_id
+set compute_plan_id = on;
+select explain_filter('explain (verbose) select * from int8_tbl i8');
+
-- Test SERIALIZE option
select explain_filter('explain (analyze,buffers off,serialize) select * from int8_tbl i8');
select explain_filter('explain (analyze,serialize text,buffers,timing off) select * from int8_tbl i8');
base-commit: b39013b7b1b116b5d9be51f0919b472b58b3a28d
--
2.43.0
^ permalink raw reply [nested|flat] 10+ messages in thread
* Re: [PATCH] Optionally record Plan IDs to track plan changes for a query
@ 2025-12-25 23:01 Michael Paquier <[email protected]>
parent: Андрей Казачков <[email protected]>
0 siblings, 1 reply; 10+ messages in thread
From: Michael Paquier @ 2025-12-25 23:01 UTC (permalink / raw)
To: Андрей Казачков <[email protected]>; +Cc: Sami Imseih <[email protected]>; Lukas Fittl <[email protected]>; PostgreSQL Hackers <[email protected]>; Marko M <[email protected]>
On Thu, Dec 25, 2025 at 05:33:11PM +0300, Андрей Казачков wrote:
> I’ve been testing the proposed v5 plan id work and found out instability of
> computing the plan identifier after feeding different query texts that
> produces the same physical plan trees but with different plan ids. The main
> pattern regards with fields of Plan node structures that depend on positions of
> RTEs in a RTE list.
FWIW, I don't think that we have a clear agreement about what would be
a good enough ID for plan trees, as it may be also a per-vendor
computation that fills specific user requirements.
+ /*
+ * COMPUTE_PLAN_ID_REGRESS means COMPUTE_PLAN_ID_YES, but we don't show
+ * the queryid in any of the EXPLAIN plans to keep stable the results
+ * generated by regression test suites.
+ */
+ if (es->verbose && queryDesc->plannedstmt->planId != UINT64CONST(0) &&
+ compute_plan_id != COMPUTE_PLAN_ID_REGRESS)
+ {
+ /*
+ * Output the queryid as an int64 rather than a uint64 so we match
+ * what would be seen in the BIGINT pg_stat_activity.plan_id column.
+ */
+ ExplainPropertyInteger("Plan Identifier", NULL,
+ queryDesc->plannedstmt->planId, es);
+ }
Now, looking at this block of code, I am wondering if you don't have a
point here even without compute_plan_id.. Could there be merit in
showing this information for an EXPLAIN if this field is not zero?
With EXPLAIN being pluggable in a hook, I doubt that it matters much,
but I am wondering if providing this information could make the work
of some extensions easier.
--
Michael
Attachments:
[application/pgp-signature] signature.asc (833B, 2-signature.asc)
download
^ permalink raw reply [nested|flat] 10+ messages in thread
* Re: [PATCH] Optionally record Plan IDs to track plan changes for a query
@ 2026-03-19 07:15 Lukas Fittl <[email protected]>
parent: Michael Paquier <[email protected]>
0 siblings, 1 reply; 10+ messages in thread
From: Lukas Fittl @ 2026-03-19 07:15 UTC (permalink / raw)
To: Michael Paquier <[email protected]>; +Cc: Андрей Казачков <[email protected]>; Sami Imseih <[email protected]>; PostgreSQL Hackers <[email protected]>; Marko M <[email protected]>
On Thu, Dec 25, 2025 at 3:02 PM Michael Paquier <[email protected]> wrote:
> + /*
> + * COMPUTE_PLAN_ID_REGRESS means COMPUTE_PLAN_ID_YES, but we don't show
> + * the queryid in any of the EXPLAIN plans to keep stable the results
> + * generated by regression test suites.
> + */
> + if (es->verbose && queryDesc->plannedstmt->planId != UINT64CONST(0) &&
> + compute_plan_id != COMPUTE_PLAN_ID_REGRESS)
> + {
> + /*
> + * Output the queryid as an int64 rather than a uint64 so we match
> + * what would be seen in the BIGINT pg_stat_activity.plan_id column.
> + */
> + ExplainPropertyInteger("Plan Identifier", NULL,
> + queryDesc->plannedstmt->planId, es);
> + }
>
> Now, looking at this block of code, I am wondering if you don't have a
> point here even without compute_plan_id.. Could there be merit in
> showing this information for an EXPLAIN if this field is not zero?
> With EXPLAIN being pluggable in a hook, I doubt that it matters much,
> but I am wondering if providing this information could make the work
> of some extensions easier.
I missed this at the time, but happened to run across this by coincidence.
Consider this a late +1 on the idea, i.e. I do think that emitting the
plan ID as "plan identifier" in EXPLAIN seems reasonable when a plugin
sets it - the cost is negligible, and it'd make it easier to work with
extensions like pg_stat_plans.
Thanks,
Lukas
--
Lukas Fittl
^ permalink raw reply [nested|flat] 10+ messages in thread
* Re: [PATCH] Optionally record Plan IDs to track plan changes for a query
@ 2026-03-19 15:13 Sami Imseih <[email protected]>
parent: Lukas Fittl <[email protected]>
0 siblings, 0 replies; 10+ messages in thread
From: Sami Imseih @ 2026-03-19 15:13 UTC (permalink / raw)
To: Lukas Fittl <[email protected]>; +Cc: Michael Paquier <[email protected]>; Андрей Казачков <[email protected]>; PostgreSQL Hackers <[email protected]>; Marko M <[email protected]>
> I missed this at the time, but happened to run across this by coincidence.
>
> Consider this a late +1 on the idea, i.e. I do think that emitting the
> plan ID as "plan identifier" in EXPLAIN seems reasonable when a plugin
> sets it - the cost is negligible, and it'd make it easier to work with
> extensions like pg_stat_plans.
FWIW, the per plan hooks introduced in 4fd02bf7cf94c can allow an extension
to emit the plan identifier in EXPLAIN as well.
--
Sami Imseih
Amazon Web Services (AWS)
^ permalink raw reply [nested|flat] 10+ messages in thread
end of thread, other threads:[~2026-03-19 15:13 UTC | newest]
Thread overview: 10+ messages (download: mbox mbox.gz follow: Atom feed)
-- links below jump to the message on this page --
2025-02-13 11:25 Re: [PATCH] Optionally record Plan IDs to track plan changes for a query Alvaro Herrera <[email protected]>
2025-02-13 16:44 ` Sami Imseih <[email protected]>
2025-03-18 07:31 ` Michael Paquier <[email protected]>
2025-03-18 09:12 ` Andrei Lepikhov <[email protected]>
2025-03-18 19:27 Re: [PATCH] Optionally record Plan IDs to track plan changes for a query Ilia Evdokimov <[email protected]>
2025-12-25 14:27 ` Андрей Казачков <[email protected]>
2025-12-25 14:33 ` Андрей Казачков <[email protected]>
2025-12-25 23:01 ` Michael Paquier <[email protected]>
2026-03-19 07:15 ` Lukas Fittl <[email protected]>
2026-03-19 15:13 ` Sami Imseih <[email protected]>
This inbox is served by agora; see mirroring instructions
for how to clone and mirror all data and code used for this inbox