public inbox for [email protected]
help / color / mirror / Atom feedFrom: Андрей Казачков <[email protected]>
To: Sami Imseih <[email protected]>
To: Lukas Fittl <[email protected]>
To: Michael Paquier <[email protected]>
Cc: PostgreSQL Hackers <[email protected]>
Cc: Marko M <[email protected]>
Subject: Re: [PATCH] Optionally record Plan IDs to track plan changes for a query
Date: Thu, 25 Dec 2025 17:27:19 +0300
Message-ID: <[email protected]> (raw)
In-Reply-To: <CAA5RZ0u6yJdFL=p5vdpbZFS-2YY+Z6vtzmt4gejgZa3RcNiWMQ@mail.gmail.com>
References: <CAP53Pkyow59ajFMHGpmb1BK9WHDypaWtUsS_5DoYUEfsa_Hktg@mail.gmail.com>
<[email protected]>
<CAA5RZ0sUPPOpkRZD=Za83op2ngcPC7dp249vcHA-X5YS7p3n8Q@mail.gmail.com>
<CAP53PkwuFbo3NkwZgxwNRMjMfqPEqidD-SggaoQ4ijotBVLJAA@mail.gmail.com>
<[email protected]>
<[email protected]>
<CAP53Pkw1QJHH9UDjkArS=XdAxtK7XWMpZLGHnVMDmhRTp_HYYw@mail.gmail.com>
<[email protected]>
<CAA5RZ0vM9AsEqvKued2drKZJ1opt3wbYaDbxGzi-khkNzwn7og@mail.gmail.com>
<[email protected]>
<CAA5RZ0sfRbd1xcq_oHNA0TPr57yM8qkg-GoD6A0nUfyxZhs33Q@mail.gmail.com>
<CAP53PkxocbNr+eRag3FEJp3-7S1U80FspOg8UQjO902TWMG=6A@mail.gmail.com>
<CAA5RZ0u6yJdFL=p5vdpbZFS-2YY+Z6vtzmt4gejgZa3RcNiWMQ@mail.gmail.com>
------==--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
view thread (36+ messages) latest in thread
reply
Reply instructions:
You may reply publicly to this message via plain-text email
using any one of the following methods:
* Reply to all the recipients using the --to and --cc options:
reply via email
To: [email protected]
Cc: [email protected], [email protected], [email protected], [email protected], [email protected], [email protected]
Subject: Re: [PATCH] Optionally record Plan IDs to track plan changes for a query
In-Reply-To: <[email protected]>
* Save the following mbox file, import it into your mail client,
and reply-to-all from there: mbox
This inbox is served by agora; see mirroring instructions
for how to clone and mirror all data and code used for this inbox