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:33:11 +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.198681.069451b5-0ade-47f8-8aff-ed0bea292303
Content-Transfer-Encoding: base64
Content-Type: text/html; charset=utf-8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------==--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
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