Re: plan shape work - Mailing list pgsql-hackers
| From | Tom Lane |
|---|---|
| Subject | Re: plan shape work |
| Date | |
| Msg-id | 3641043.1758751399@sss.pgh.pa.us Whole thread Raw |
| In response to | Re: plan shape work (Robert Haas <robertmhaas@gmail.com>) |
| Responses |
Re: plan shape work
|
| List | pgsql-hackers |
Robert Haas <robertmhaas@gmail.com> writes:
> Here's a new patch set. 0004 is now 0001 and similarly all other patch
> numbers are -3, since the old 0001 and 0002 were committed together
> and the 0003 is abandoned. I made the following changes to
> old-0004/new-0001:
I've not looked at all of these patches, but here's a review of v9-0001.
> - I rewrote the commit message. I'm not really sure this is any
> clearer about the motivation for this patch, but I tried. Suggestions
> appreciated.
It's much better, thanks.
> - You (Tom) complained about the lack of const on
> sublinktype_to_string, so this version has been const-ified. The const
> bled into the arguments to choose_plan_name() and subquery_planner(),
> and into the plan_name structure members within PlannerInfo and
> SubPlan. I don't know if this is the right thing to do, so feel free
> to set me straight.
I don't think so. We do not have a nice story on marking Node fields
const: it's very unclear for example what consequences that ought to
have for copyObject(). Maybe somebody will tackle that issue someday,
but it's not something to touch casually in a patch with other
objectives. So I don't think we can make the plan_name fields const.
The best solution I think is to make choose_plan_name() take a const
string and return a non-const one. The attached v10-0001 is just like
your v9-0001 except for doing the const stuff this way. I chose to
fix the impedance mismatch within choose_plan_name() by having it
pstrdup when it wants to just return the "name" string, but you could
make a case for holding your nose and just casting away const there.
> - You (Tom) also asked why not print InitPlan/SubPlan wherever we
> refer to subplans, so this version restores that behavior.
Thanks. I'm good with the output now (modulo the bug described
below). Someone could potentially argue that this exposes more
of the internals than we really ought to, such as the difference
between expr and multiexpr SubLinks, but I'm okay with that.
Aside from the const issue, something I don't really like at the
coding level is the use of an "allroots" list. One reason is that
it's partially redundant with the adjacent "subroots" list, but
a bigger one is that we have transient roots that shouldn't be
in there. An example here is pull_up_simple_subquery: it builds
a clone of the query's PlannerInfo to help it use various
infrastructure along the way to flattening the subquery, but
that clone is not referenced anymore after the function exits.
You were putting that into allroots, which seems to me to be
a fundamental error, even more so because it went in with the
same plan_name as the root it was cloned from.
I think a better idea is to keep a list of just the subplan
names that we've assigned so far. That has a far clearer
charter, plus it can be updated immediately by choose_plan_name()
instead of relying on the caller to do the right thing later.
I coded this up, and was rather surprised to find that it changed
some regression outputs. On investigation, that's because
build_minmax_path() was actually doing the wrong thing later:
it was putting the wrong root into allroots, so that "minmax_1"
never became assigned and could be re-used later.
I also observed that SS_process_ctes() was not using
choose_plan_name() but simply assigning the user-written CTE
name. I believe it's possible to use the same CTE name in
different parts of a query tree, so this fails to achieve
the stated purpose of making the names unique.
I'm still a little bit uncomfortable about whether
it's okay for pull_up_simple_subquery() to just do
+ subroot->plan_name = root->plan_name;
rather than giving some other name to the transient subroot.
I think it's okay because we are not making any meaningful planning
decisions during the life of the subroot, just seeing if we can
transform the subquery into a form that allows it to be pulled up.
But you might think differently. Perhaps a potential compromise
is to set the transient subroot's plan_name to NULL instead?
Anyway, v10-0002 is a delta patch to use a list of subplan
names instead of "allroots", and there are a couple of trivial
cosmetic changes too.
regards, tom lane
From 1dae91029098fb60c1dfeb5d713601336d674c18 Mon Sep 17 00:00:00 2001
From: Tom Lane <tgl@sss.pgh.pa.us>
Date: Wed, 24 Sep 2025 16:13:28 -0400
Subject: [PATCH v10 1/2] Assign each subquery a unique name prior to planning
it.
This is the same as v9-0001 except for rearranging the use of
"const" a bit, so that we're not assuming that we can mark random
Node fields const.
---
.../postgres_fdw/expected/postgres_fdw.out | 70 ++--
src/backend/commands/explain.c | 15 +-
src/backend/optimizer/path/allpaths.c | 6 +-
src/backend/optimizer/plan/planagg.c | 6 +
src/backend/optimizer/plan/planner.c | 71 ++++-
src/backend/optimizer/plan/subselect.c | 84 +++--
src/backend/optimizer/prep/prepjointree.c | 4 +
src/backend/optimizer/prep/prepunion.c | 5 +-
src/backend/utils/adt/ruleutils.c | 33 +-
src/include/nodes/pathnodes.h | 6 +
src/include/nodes/primnodes.h | 1 +
src/include/optimizer/planner.h | 4 +
src/test/regress/expected/aggregates.out | 58 ++--
src/test/regress/expected/create_index.out | 14 +-
src/test/regress/expected/groupingsets.out | 94 +++---
.../regress/expected/incremental_sort.out | 8 +-
src/test/regress/expected/inherit.out | 32 +-
src/test/regress/expected/insert_conflict.out | 4 +-
src/test/regress/expected/join.out | 78 ++---
src/test/regress/expected/join_hash.out | 32 +-
src/test/regress/expected/memoize.out | 4 +-
src/test/regress/expected/merge.out | 12 +-
src/test/regress/expected/partition_prune.out | 300 +++++++++---------
src/test/regress/expected/portals.out | 12 +-
src/test/regress/expected/predicate.out | 8 +-
src/test/regress/expected/returning.out | 24 +-
src/test/regress/expected/rowsecurity.out | 138 ++++----
src/test/regress/expected/rowtypes.out | 12 +-
src/test/regress/expected/select_parallel.out | 56 ++--
src/test/regress/expected/sqljson.out | 4 +-
src/test/regress/expected/subselect.out | 174 +++++-----
src/test/regress/expected/updatable_views.out | 52 +--
src/test/regress/expected/update.out | 8 +-
src/test/regress/expected/window.out | 10 +-
src/test/regress/expected/with.out | 20 +-
35 files changed, 807 insertions(+), 652 deletions(-)
diff --git a/contrib/postgres_fdw/expected/postgres_fdw.out b/contrib/postgres_fdw/expected/postgres_fdw.out
index 6dc04e916dc..f2f8130af87 100644
--- a/contrib/postgres_fdw/expected/postgres_fdw.out
+++ b/contrib/postgres_fdw/expected/postgres_fdw.out
@@ -3175,13 +3175,13 @@ select sum(c1) from ft1 group by c2 having avg(c1 * (random() <= 1)::int) > 100
-- of an initplan) can be trouble, per bug #15781
explain (verbose, costs off)
select exists(select 1 from pg_enum), sum(c1) from ft1;
- QUERY PLAN
---------------------------------------------------
+ QUERY PLAN
+---------------------------------------------------
Foreign Scan
- Output: (InitPlan 1).col1, (sum(ft1.c1))
+ Output: (InitPlan exists_1).col1, (sum(ft1.c1))
Relations: Aggregate on (public.ft1)
Remote SQL: SELECT sum("C 1") FROM "S 1"."T 1"
- InitPlan 1
+ InitPlan exists_1
-> Seq Scan on pg_catalog.pg_enum
(6 rows)
@@ -3196,8 +3196,8 @@ select exists(select 1 from pg_enum), sum(c1) from ft1 group by 1;
QUERY PLAN
---------------------------------------------------
GroupAggregate
- Output: (InitPlan 1).col1, sum(ft1.c1)
- InitPlan 1
+ Output: (InitPlan exists_1).col1, sum(ft1.c1)
+ InitPlan exists_1
-> Seq Scan on pg_catalog.pg_enum
-> Foreign Scan on public.ft1
Output: ft1.c1
@@ -3356,15 +3356,15 @@ select distinct (select count(*) filter (where t2.c2 = 6 and t2.c1 < 10) from ft
QUERY PLAN
------------------------------------------------------------------------------------------------------------------------------
Unique
- Output: ((SubPlan 1))
+ Output: ((SubPlan expr_1))
-> Sort
- Output: ((SubPlan 1))
- Sort Key: ((SubPlan 1))
+ Output: ((SubPlan expr_1))
+ Sort Key: ((SubPlan expr_1))
-> Foreign Scan
- Output: (SubPlan 1)
+ Output: (SubPlan expr_1)
Relations: Aggregate on (public.ft2 t2)
Remote SQL: SELECT count(*) FILTER (WHERE ((c2 = 6) AND ("C 1" < 10))) FROM "S 1"."T 1" WHERE (((c2 %
6)= 0))
- SubPlan 1
+ SubPlan expr_1
-> Foreign Scan on public.ft1 t1
Output: (count(*) FILTER (WHERE ((t2.c2 = 6) AND (t2.c1 < 10))))
Remote SQL: SELECT NULL FROM "S 1"."T 1" WHERE (("C 1" = 6))
@@ -3382,14 +3382,14 @@ select distinct (select count(t1.c1) filter (where t2.c2 = 6 and t2.c1 < 10) fro
QUERY PLAN
------------------------------------------------------------------------------------------------------------------------------------------------------
Unique
- Output: ((SubPlan 1))
+ Output: ((SubPlan expr_1))
-> Sort
- Output: ((SubPlan 1))
- Sort Key: ((SubPlan 1))
+ Output: ((SubPlan expr_1))
+ Sort Key: ((SubPlan expr_1))
-> Foreign Scan on public.ft2 t2
- Output: (SubPlan 1)
+ Output: (SubPlan expr_1)
Remote SQL: SELECT "C 1", c2 FROM "S 1"."T 1" WHERE (((c2 % 6) = 0))
- SubPlan 1
+ SubPlan expr_1
-> Foreign Scan
Output: (count(t1.c1) FILTER (WHERE ((t2.c2 = 6) AND (t2.c1 < 10))))
Relations: Aggregate on (public.ft1 t1)
@@ -3421,14 +3421,14 @@ select sum(c1) filter (where (c1 / c1) * random() <= 1) from ft1 group by c2 ord
explain (verbose, costs off)
select sum(c2) filter (where c2 in (select c2 from ft1 where c2 < 5)) from ft1;
- QUERY PLAN
--------------------------------------------------------------------------------
+ QUERY PLAN
+-----------------------------------------------------------------------------------
Aggregate
- Output: sum(ft1.c2) FILTER (WHERE (ANY (ft1.c2 = (hashed SubPlan 1).col1)))
+ Output: sum(ft1.c2) FILTER (WHERE (ANY (ft1.c2 = (hashed SubPlan any_1).col1)))
-> Foreign Scan on public.ft1
Output: ft1.c2
Remote SQL: SELECT c2 FROM "S 1"."T 1"
- SubPlan 1
+ SubPlan any_1
-> Foreign Scan on public.ft1 ft1_1
Output: ft1_1.c2
Remote SQL: SELECT c2 FROM "S 1"."T 1" WHERE ((c2 < 5))
@@ -6444,14 +6444,14 @@ UPDATE ft2 AS target SET (c2, c7) = (
FROM ft2 AS src
WHERE target.c1 = src.c1
) WHERE c1 > 1100;
- QUERY PLAN
------------------------------------------------------------------------------------------------------------------------
+ QUERY PLAN
+-----------------------------------------------------------------------------------------------------------------------------
Update on public.ft2 target
Remote SQL: UPDATE "S 1"."T 1" SET c2 = $2, c7 = $3 WHERE ctid = $1
-> Foreign Scan on public.ft2 target
- Output: (SubPlan 1).col1, (SubPlan 1).col2, (rescan SubPlan 1), target.ctid, target.*
+ Output: (SubPlan multiexpr_1).col1, (SubPlan multiexpr_1).col2, (rescan SubPlan multiexpr_1), target.ctid,
target.*
Remote SQL: SELECT "C 1", c2, c3, c4, c5, c6, c7, c8, ctid FROM "S 1"."T 1" WHERE (("C 1" > 1100)) FOR UPDATE
- SubPlan 1
+ SubPlan multiexpr_1
-> Foreign Scan on public.ft2 src
Output: (src.c2 * 10), src.c7
Remote SQL: SELECT c2, c7 FROM "S 1"."T 1" WHERE (($1::integer = "C 1"))
@@ -12132,12 +12132,12 @@ INSERT INTO local_tbl VALUES (1505, 505, 'foo');
ANALYZE local_tbl;
EXPLAIN (VERBOSE, COSTS OFF)
SELECT * FROM local_tbl t1 LEFT JOIN (SELECT *, (SELECT count(*) FROM async_pt WHERE a < 3000) FROM async_pt WHERE a <
3000)t2 ON t1.a = t2.a;
- QUERY PLAN
-----------------------------------------------------------------------------------------
+ QUERY PLAN
+------------------------------------------------------------------------------------------
Nested Loop Left Join
- Output: t1.a, t1.b, t1.c, async_pt.a, async_pt.b, async_pt.c, ((InitPlan 1).col1)
+ Output: t1.a, t1.b, t1.c, async_pt.a, async_pt.b, async_pt.c, ((InitPlan expr_1).col1)
Join Filter: (t1.a = async_pt.a)
- InitPlan 1
+ InitPlan expr_1
-> Aggregate
Output: count(*)
-> Append
@@ -12149,10 +12149,10 @@ SELECT * FROM local_tbl t1 LEFT JOIN (SELECT *, (SELECT count(*) FROM async_pt W
Output: t1.a, t1.b, t1.c
-> Append
-> Async Foreign Scan on public.async_p1 async_pt_1
- Output: async_pt_1.a, async_pt_1.b, async_pt_1.c, (InitPlan 1).col1
+ Output: async_pt_1.a, async_pt_1.b, async_pt_1.c, (InitPlan expr_1).col1
Remote SQL: SELECT a, b, c FROM public.base_tbl1 WHERE ((a < 3000))
-> Async Foreign Scan on public.async_p2 async_pt_2
- Output: async_pt_2.a, async_pt_2.b, async_pt_2.c, (InitPlan 1).col1
+ Output: async_pt_2.a, async_pt_2.b, async_pt_2.c, (InitPlan expr_1).col1
Remote SQL: SELECT a, b, c FROM public.base_tbl2 WHERE ((a < 3000))
(20 rows)
@@ -12163,7 +12163,7 @@ SELECT * FROM local_tbl t1 LEFT JOIN (SELECT *, (SELECT count(*) FROM async_pt W
Nested Loop Left Join (actual rows=1.00 loops=1)
Join Filter: (t1.a = async_pt.a)
Rows Removed by Join Filter: 399
- InitPlan 1
+ InitPlan expr_1
-> Aggregate (actual rows=1.00 loops=1)
-> Append (actual rows=400.00 loops=1)
-> Async Foreign Scan on async_p1 async_pt_4 (actual rows=200.00 loops=1)
@@ -12386,12 +12386,12 @@ CREATE FOREIGN TABLE foreign_tbl2 () INHERITS (foreign_tbl)
SERVER loopback OPTIONS (table_name 'base_tbl');
EXPLAIN (VERBOSE, COSTS OFF)
SELECT a FROM base_tbl WHERE (a, random() > 0) IN (SELECT a, random() > 0 FROM foreign_tbl);
- QUERY PLAN
----------------------------------------------------------------------------------------------------------------
+ QUERY PLAN
+-----------------------------------------------------------------------------------------------------------------------
Seq Scan on public.base_tbl
Output: base_tbl.a
- Filter: (ANY ((base_tbl.a = (SubPlan 1).col1) AND ((random() > '0'::double precision) = (SubPlan 1).col2)))
- SubPlan 1
+ Filter: (ANY ((base_tbl.a = (SubPlan any_1).col1) AND ((random() > '0'::double precision) = (SubPlan any_1).col2)))
+ SubPlan any_1
-> Result
Output: base_tbl.a, (random() > '0'::double precision)
-> Append
diff --git a/src/backend/commands/explain.c b/src/backend/commands/explain.c
index 207f86f1d39..06191cd8a85 100644
--- a/src/backend/commands/explain.c
+++ b/src/backend/commands/explain.c
@@ -4901,6 +4901,7 @@ ExplainSubPlans(List *plans, List *ancestors,
{
SubPlanState *sps = (SubPlanState *) lfirst(lst);
SubPlan *sp = sps->subplan;
+ char *cooked_plan_name;
/*
* There can be multiple SubPlan nodes referencing the same physical
@@ -4924,8 +4925,20 @@ ExplainSubPlans(List *plans, List *ancestors,
*/
ancestors = lcons(sp, ancestors);
+ /*
+ * The plan has a name like exists_1 or rowcompare_2, but here we want
+ * to prefix that with CTE, InitPlan, or SubPlan, as appropriate, for
+ * display purposes.
+ */
+ if (sp->subLinkType == CTE_SUBLINK)
+ cooked_plan_name = psprintf("CTE %s", sp->plan_name);
+ else if (sp->isInitPlan)
+ cooked_plan_name = psprintf("InitPlan %s", sp->plan_name);
+ else
+ cooked_plan_name = psprintf("SubPlan %s", sp->plan_name);
+
ExplainNode(sps->planstate, ancestors,
- relationship, sp->plan_name, es);
+ relationship, cooked_plan_name, es);
ancestors = list_delete_first(ancestors);
}
diff --git a/src/backend/optimizer/path/allpaths.c b/src/backend/optimizer/path/allpaths.c
index 6cc6966b060..593f5361b58 100644
--- a/src/backend/optimizer/path/allpaths.c
+++ b/src/backend/optimizer/path/allpaths.c
@@ -2532,6 +2532,7 @@ set_subquery_pathlist(PlannerInfo *root, RelOptInfo *rel,
RelOptInfo *sub_final_rel;
Bitmapset *run_cond_attrs = NULL;
ListCell *lc;
+ char *plan_name;
/*
* Must copy the Query so that planning doesn't mess up the RTE contents
@@ -2674,8 +2675,9 @@ set_subquery_pathlist(PlannerInfo *root, RelOptInfo *rel,
Assert(root->plan_params == NIL);
/* Generate a subroot and Paths for the subquery */
- rel->subroot = subquery_planner(root->glob, subquery, root, false,
- tuple_fraction, NULL);
+ plan_name = choose_plan_name(root->glob, rte->eref->aliasname, false);
+ rel->subroot = subquery_planner(root->glob, subquery, plan_name,
+ root, false, tuple_fraction, NULL);
/* Isolate the params needed by this specific subplan */
rel->subplan_params = root->plan_params;
diff --git a/src/backend/optimizer/plan/planagg.c b/src/backend/optimizer/plan/planagg.c
index 2ef0bb7f663..0ce35cabaf5 100644
--- a/src/backend/optimizer/plan/planagg.c
+++ b/src/backend/optimizer/plan/planagg.c
@@ -38,6 +38,7 @@
#include "optimizer/pathnode.h"
#include "optimizer/paths.h"
#include "optimizer/planmain.h"
+#include "optimizer/planner.h"
#include "optimizer/subselect.h"
#include "optimizer/tlist.h"
#include "parser/parse_clause.h"
@@ -339,6 +340,8 @@ build_minmax_path(PlannerInfo *root, MinMaxAggInfo *mminfo,
memcpy(subroot, root, sizeof(PlannerInfo));
subroot->query_level++;
subroot->parent_root = root;
+ subroot->plan_name = choose_plan_name(root->glob, "minmax", true);
+
/* reset subplan-related stuff */
subroot->plan_params = NIL;
subroot->outer_params = NULL;
@@ -359,6 +362,9 @@ build_minmax_path(PlannerInfo *root, MinMaxAggInfo *mminfo,
/* and we haven't created PlaceHolderInfos, either */
Assert(subroot->placeholder_list == NIL);
+ /* Add this to list of all PlannerInfo objects. */
+ root->glob->allroots = lappend(root->glob->allroots, root);
+
/*----------
* Generate modified query of the form
* (SELECT col FROM tab
diff --git a/src/backend/optimizer/plan/planner.c b/src/backend/optimizer/plan/planner.c
index 41bd8353430..acd1356a721 100644
--- a/src/backend/optimizer/plan/planner.c
+++ b/src/backend/optimizer/plan/planner.c
@@ -439,7 +439,8 @@ standard_planner(Query *parse, const char *query_string, int cursorOptions,
}
/* primary planning entry point (may recurse for subqueries) */
- root = subquery_planner(glob, parse, NULL, false, tuple_fraction, NULL);
+ root = subquery_planner(glob, parse, NULL, NULL, false, tuple_fraction,
+ NULL);
/* Select best Path and turn it into a Plan */
final_rel = fetch_upper_rel(root, UPPERREL_FINAL, NULL);
@@ -656,9 +657,9 @@ standard_planner(Query *parse, const char *query_string, int cursorOptions,
*--------------------
*/
PlannerInfo *
-subquery_planner(PlannerGlobal *glob, Query *parse, PlannerInfo *parent_root,
- bool hasRecursion, double tuple_fraction,
- SetOperationStmt *setops)
+subquery_planner(PlannerGlobal *glob, Query *parse, char *plan_name,
+ PlannerInfo *parent_root, bool hasRecursion,
+ double tuple_fraction, SetOperationStmt *setops)
{
PlannerInfo *root;
List *newWithCheckOptions;
@@ -673,6 +674,7 @@ subquery_planner(PlannerGlobal *glob, Query *parse, PlannerInfo *parent_root,
root->parse = parse;
root->glob = glob;
root->query_level = parent_root ? parent_root->query_level + 1 : 1;
+ root->plan_name = plan_name;
root->parent_root = parent_root;
root->plan_params = NIL;
root->outer_params = NULL;
@@ -710,6 +712,9 @@ subquery_planner(PlannerGlobal *glob, Query *parse, PlannerInfo *parent_root,
root->non_recursive_path = NULL;
root->partColsUpdated = false;
+ /* Add this to list of all PlannerInfo objects. */
+ root->glob->allroots = lappend(root->glob->allroots, root);
+
/*
* Create the top-level join domain. This won't have valid contents until
* deconstruct_jointree fills it in, but the node needs to exist before
@@ -8833,3 +8838,61 @@ create_partial_unique_paths(PlannerInfo *root, RelOptInfo *input_rel,
sjinfo, unique_rel);
}
}
+
+/*
+ * Choose a unique plan name for subroot.
+ */
+char *
+choose_plan_name(PlannerGlobal *glob, const char *name, bool always_number)
+{
+ unsigned n;
+
+ /*
+ * If a numeric suffix is not required, then search the list of roots for
+ * a plan with the requested name. If none is found, then we can use the
+ * provided name without modification.
+ */
+ if (!always_number)
+ {
+ bool found = false;
+
+ foreach_node(PlannerInfo, root, glob->allroots)
+ {
+ if (root->plan_name != NULL &&
+ strcmp(name, root->plan_name) == 0)
+ {
+ found = true;
+ break;
+ }
+ }
+
+ if (!found)
+ return pstrdup(name);
+ }
+
+ /*
+ * If a numeric suffix is required or if the un-suffixed name is already
+ * in use, then loop until we find a positive integer that produces a
+ * novel name.
+ */
+ for (n = 1; true; ++n)
+ {
+ char *proposed_name = psprintf("%s_%u", name, n);
+ bool found = false;
+
+ foreach_node(PlannerInfo, root, glob->allroots)
+ {
+ if (root->plan_name != NULL &&
+ strcmp(proposed_name, root->plan_name) == 0)
+ {
+ found = true;
+ break;
+ }
+ }
+
+ if (!found)
+ return proposed_name;
+
+ pfree(proposed_name);
+ }
+}
diff --git a/src/backend/optimizer/plan/subselect.c b/src/backend/optimizer/plan/subselect.c
index fae18548e07..5f8306bc421 100644
--- a/src/backend/optimizer/plan/subselect.c
+++ b/src/backend/optimizer/plan/subselect.c
@@ -103,6 +103,7 @@ static Bitmapset *finalize_plan(PlannerInfo *root,
Bitmapset *scan_params);
static bool finalize_primnode(Node *node, finalize_primnode_context *context);
static bool finalize_agg_primnode(Node *node, finalize_primnode_context *context);
+static const char *sublinktype_to_string(SubLinkType subLinkType);
/*
@@ -172,6 +173,7 @@ make_subplan(PlannerInfo *root, Query *orig_subquery,
Plan *plan;
List *plan_params;
Node *result;
+ const char *sublinkstr = sublinktype_to_string(subLinkType);
/*
* Copy the source Query node. This is a quick and dirty kluge to resolve
@@ -218,8 +220,9 @@ make_subplan(PlannerInfo *root, Query *orig_subquery,
Assert(root->plan_params == NIL);
/* Generate Paths for the subquery */
- subroot = subquery_planner(root->glob, subquery, root, false,
- tuple_fraction, NULL);
+ subroot = subquery_planner(root->glob, subquery,
+ choose_plan_name(root->glob, sublinkstr, true),
+ root, false, tuple_fraction, NULL);
/* Isolate the params needed by this specific subplan */
plan_params = root->plan_params;
@@ -264,9 +267,12 @@ make_subplan(PlannerInfo *root, Query *orig_subquery,
&newtestexpr, ¶mIds);
if (subquery)
{
+ char *plan_name;
+
/* Generate Paths for the ANY subquery; we'll need all rows */
- subroot = subquery_planner(root->glob, subquery, root, false, 0.0,
- NULL);
+ plan_name = choose_plan_name(root->glob, sublinkstr, true);
+ subroot = subquery_planner(root->glob, subquery, plan_name,
+ root, false, 0.0, NULL);
/* Isolate the params needed by this specific subplan */
plan_params = root->plan_params;
@@ -324,15 +330,16 @@ build_subplan(PlannerInfo *root, Plan *plan, Path *path,
{
Node *result;
SubPlan *splan;
- bool isInitPlan;
ListCell *lc;
/*
- * Initialize the SubPlan node. Note plan_id, plan_name, and cost fields
- * are set further down.
+ * Initialize the SubPlan node.
+ *
+ * Note: plan_id and cost fields are set further down.
*/
splan = makeNode(SubPlan);
splan->subLinkType = subLinkType;
+ splan->plan_name = subroot->plan_name;
splan->testexpr = NULL;
splan->paramIds = NIL;
get_first_col_type(plan, &splan->firstColType, &splan->firstColTypmod,
@@ -391,7 +398,7 @@ build_subplan(PlannerInfo *root, Plan *plan, Path *path,
Assert(testexpr == NULL);
prm = generate_new_exec_param(root, BOOLOID, -1, InvalidOid);
splan->setParam = list_make1_int(prm->paramid);
- isInitPlan = true;
+ splan->isInitPlan = true;
result = (Node *) prm;
}
else if (splan->parParam == NIL && subLinkType == EXPR_SUBLINK)
@@ -406,7 +413,7 @@ build_subplan(PlannerInfo *root, Plan *plan, Path *path,
exprTypmod((Node *) te->expr),
exprCollation((Node *) te->expr));
splan->setParam = list_make1_int(prm->paramid);
- isInitPlan = true;
+ splan->isInitPlan = true;
result = (Node *) prm;
}
else if (splan->parParam == NIL && subLinkType == ARRAY_SUBLINK)
@@ -426,7 +433,7 @@ build_subplan(PlannerInfo *root, Plan *plan, Path *path,
exprTypmod((Node *) te->expr),
exprCollation((Node *) te->expr));
splan->setParam = list_make1_int(prm->paramid);
- isInitPlan = true;
+ splan->isInitPlan = true;
result = (Node *) prm;
}
else if (splan->parParam == NIL && subLinkType == ROWCOMPARE_SUBLINK)
@@ -442,7 +449,7 @@ build_subplan(PlannerInfo *root, Plan *plan, Path *path,
testexpr,
params);
splan->setParam = list_copy(splan->paramIds);
- isInitPlan = true;
+ splan->isInitPlan = true;
/*
* The executable expression is returned to become part of the outer
@@ -476,12 +483,12 @@ build_subplan(PlannerInfo *root, Plan *plan, Path *path,
/* It can be an initplan if there are no parParams. */
if (splan->parParam == NIL)
{
- isInitPlan = true;
+ splan->isInitPlan = true;
result = (Node *) makeNullConst(RECORDOID, -1, InvalidOid);
}
else
{
- isInitPlan = false;
+ splan->isInitPlan = false;
result = (Node *) splan;
}
}
@@ -536,7 +543,7 @@ build_subplan(PlannerInfo *root, Plan *plan, Path *path,
plan = materialize_finished_plan(plan);
result = (Node *) splan;
- isInitPlan = false;
+ splan->isInitPlan = false;
}
/*
@@ -547,7 +554,7 @@ build_subplan(PlannerInfo *root, Plan *plan, Path *path,
root->glob->subroots = lappend(root->glob->subroots, subroot);
splan->plan_id = list_length(root->glob->subplans);
- if (isInitPlan)
+ if (splan->isInitPlan)
root->init_plans = lappend(root->init_plans, splan);
/*
@@ -557,15 +564,10 @@ build_subplan(PlannerInfo *root, Plan *plan, Path *path,
* there's no point since it won't get re-run without parameter changes
* anyway. The input of a hashed subplan doesn't need REWIND either.
*/
- if (splan->parParam == NIL && !isInitPlan && !splan->useHashTable)
+ if (splan->parParam == NIL && !splan->isInitPlan && !splan->useHashTable)
root->glob->rewindPlanIDs = bms_add_member(root->glob->rewindPlanIDs,
splan->plan_id);
- /* Label the subplan for EXPLAIN purposes */
- splan->plan_name = psprintf("%s %d",
- isInitPlan ? "InitPlan" : "SubPlan",
- splan->plan_id);
-
/* Lastly, fill in the cost estimates for use later */
cost_subplan(root, splan, plan);
@@ -965,7 +967,7 @@ SS_process_ctes(PlannerInfo *root)
* Generate Paths for the CTE query. Always plan for full retrieval
* --- we don't have enough info to predict otherwise.
*/
- subroot = subquery_planner(root->glob, subquery, root,
+ subroot = subquery_planner(root->glob, subquery, cte->ctename, root,
cte->cterecursive, 0.0, NULL);
/*
@@ -989,10 +991,11 @@ SS_process_ctes(PlannerInfo *root)
* Make a SubPlan node for it. This is just enough unlike
* build_subplan that we can't share code.
*
- * Note plan_id, plan_name, and cost fields are set further down.
+ * Note: plan_id and cost fields are set further down.
*/
splan = makeNode(SubPlan);
splan->subLinkType = CTE_SUBLINK;
+ splan->plan_name = subroot->plan_name;
splan->testexpr = NULL;
splan->paramIds = NIL;
get_first_col_type(plan, &splan->firstColType, &splan->firstColTypmod,
@@ -1039,9 +1042,6 @@ SS_process_ctes(PlannerInfo *root)
root->cte_plan_ids = lappend_int(root->cte_plan_ids, splan->plan_id);
- /* Label the subplan for EXPLAIN purposes */
- splan->plan_name = psprintf("CTE %s", cte->ctename);
-
/* Lastly, fill in the cost estimates for use later */
cost_subplan(root, splan, plan);
}
@@ -3185,7 +3185,8 @@ SS_make_initplan_from_plan(PlannerInfo *root,
node = makeNode(SubPlan);
node->subLinkType = EXPR_SUBLINK;
node->plan_id = list_length(root->glob->subplans);
- node->plan_name = psprintf("InitPlan %d", node->plan_id);
+ node->plan_name = subroot->plan_name;
+ node->isInitPlan = true;
get_first_col_type(plan, &node->firstColType, &node->firstColTypmod,
&node->firstColCollation);
node->parallel_safe = plan->parallel_safe;
@@ -3201,3 +3202,32 @@ SS_make_initplan_from_plan(PlannerInfo *root,
/* Set costs of SubPlan using info from the plan tree */
cost_subplan(subroot, node, plan);
}
+
+/*
+ * Get a string equivalent of a given subLinkType.
+ */
+static const char *
+sublinktype_to_string(SubLinkType subLinkType)
+{
+ switch (subLinkType)
+ {
+ case EXISTS_SUBLINK:
+ return "exists";
+ case ALL_SUBLINK:
+ return "all";
+ case ANY_SUBLINK:
+ return "any";
+ case ROWCOMPARE_SUBLINK:
+ return "rowcompare";
+ case EXPR_SUBLINK:
+ return "expr";
+ case MULTIEXPR_SUBLINK:
+ return "multiexpr";
+ case ARRAY_SUBLINK:
+ return "array";
+ case CTE_SUBLINK:
+ return "cte";
+ }
+ Assert(false);
+ return "???";
+}
diff --git a/src/backend/optimizer/prep/prepjointree.c b/src/backend/optimizer/prep/prepjointree.c
index 35e8d3c183b..2ec13637d16 100644
--- a/src/backend/optimizer/prep/prepjointree.c
+++ b/src/backend/optimizer/prep/prepjointree.c
@@ -1356,6 +1356,7 @@ pull_up_simple_subquery(PlannerInfo *root, Node *jtnode, RangeTblEntry *rte,
subroot->parse = subquery;
subroot->glob = root->glob;
subroot->query_level = root->query_level;
+ subroot->plan_name = root->plan_name;
subroot->parent_root = root->parent_root;
subroot->plan_params = NIL;
subroot->outer_params = NULL;
@@ -1387,6 +1388,9 @@ pull_up_simple_subquery(PlannerInfo *root, Node *jtnode, RangeTblEntry *rte,
subroot->non_recursive_path = NULL;
/* We don't currently need a top JoinDomain for the subroot */
+ /* Add new subroot to master list of PlannerInfo objects. */
+ root->glob->allroots = lappend(root->glob->allroots, subroot);
+
/* No CTEs to worry about */
Assert(subquery->cteList == NIL);
diff --git a/src/backend/optimizer/prep/prepunion.c b/src/backend/optimizer/prep/prepunion.c
index 28a4ae64440..d55eb39e552 100644
--- a/src/backend/optimizer/prep/prepunion.c
+++ b/src/backend/optimizer/prep/prepunion.c
@@ -228,6 +228,7 @@ recurse_set_operations(Node *setOp, PlannerInfo *root,
PlannerInfo *subroot;
List *tlist;
bool trivial_tlist;
+ char *plan_name;
Assert(subquery != NULL);
@@ -242,7 +243,9 @@ recurse_set_operations(Node *setOp, PlannerInfo *root,
* parentOp, pass that down to encourage subquery_planner to consider
* suitably-sorted Paths.
*/
- subroot = rel->subroot = subquery_planner(root->glob, subquery, root,
+ plan_name = choose_plan_name(root->glob, "setop", true);
+ subroot = rel->subroot = subquery_planner(root->glob, subquery,
+ plan_name, root,
false, root->tuple_fraction,
parentOp);
diff --git a/src/backend/utils/adt/ruleutils.c b/src/backend/utils/adt/ruleutils.c
index 0408a95941d..277a4ffabbc 100644
--- a/src/backend/utils/adt/ruleutils.c
+++ b/src/backend/utils/adt/ruleutils.c
@@ -8750,8 +8750,16 @@ get_parameter(Param *param, deparse_context *context)
subplan = find_param_generator(param, context, &column);
if (subplan)
{
- appendStringInfo(context->buf, "(%s%s).col%d",
+ const char *nameprefix;
+
+ if (subplan->isInitPlan)
+ nameprefix = "InitPlan ";
+ else
+ nameprefix = "SubPlan ";
+
+ appendStringInfo(context->buf, "(%s%s%s).col%d",
subplan->useHashTable ? "hashed " : "",
+ nameprefix,
subplan->plan_name, column + 1);
return;
@@ -9588,11 +9596,19 @@ get_rule_expr(Node *node, deparse_context *context,
}
else
{
+ const char *nameprefix;
+
/* No referencing Params, so show the SubPlan's name */
+ if (subplan->isInitPlan)
+ nameprefix = "InitPlan ";
+ else
+ nameprefix = "SubPlan ";
if (subplan->useHashTable)
- appendStringInfo(buf, "hashed %s)", subplan->plan_name);
+ appendStringInfo(buf, "hashed %s%s)",
+ nameprefix, subplan->plan_name);
else
- appendStringInfo(buf, "%s)", subplan->plan_name);
+ appendStringInfo(buf, "%s%s)",
+ nameprefix, subplan->plan_name);
}
}
break;
@@ -9612,11 +9628,18 @@ get_rule_expr(Node *node, deparse_context *context,
foreach(lc, asplan->subplans)
{
SubPlan *splan = lfirst_node(SubPlan, lc);
+ const char *nameprefix;
+ if (splan->isInitPlan)
+ nameprefix = "InitPlan ";
+ else
+ nameprefix = "SubPlan ";
if (splan->useHashTable)
- appendStringInfo(buf, "hashed %s", splan->plan_name);
+ appendStringInfo(buf, "hashed %s%s", nameprefix,
+ splan->plan_name);
else
- appendStringInfoString(buf, splan->plan_name);
+ appendStringInfo(buf, "%s%s", nameprefix,
+ splan->plan_name);
if (lnext(asplan->subplans, lc))
appendStringInfoString(buf, " or ");
}
diff --git a/src/include/nodes/pathnodes.h b/src/include/nodes/pathnodes.h
index b12a2508d8c..a341b01a1e1 100644
--- a/src/include/nodes/pathnodes.h
+++ b/src/include/nodes/pathnodes.h
@@ -110,6 +110,9 @@ typedef struct PlannerGlobal
/* PlannerInfos for SubPlan nodes */
List *subroots pg_node_attr(read_write_ignore);
+ /* every PlannerInfo regardless of whether it's an InitPlan/SubPlan */
+ List *allroots pg_node_attr(read_write_ignore);
+
/* indices of subplans that require REWIND */
Bitmapset *rewindPlanIDs;
@@ -228,6 +231,9 @@ struct PlannerInfo
/* NULL at outermost Query */
PlannerInfo *parent_root pg_node_attr(read_write_ignore);
+ /* Name for EXPLAIN and debugging purposes */
+ char *plan_name;
+
/*
* plan_params contains the expressions that this query level needs to
* make available to a lower query level that is currently being planned.
diff --git a/src/include/nodes/primnodes.h b/src/include/nodes/primnodes.h
index 6dfca3cb35b..1e84321a478 100644
--- a/src/include/nodes/primnodes.h
+++ b/src/include/nodes/primnodes.h
@@ -1095,6 +1095,7 @@ typedef struct SubPlan
Oid firstColCollation; /* Collation of first column of subplan
* result */
/* Information about execution strategy: */
+ bool isInitPlan; /* true if it's an InitPlan */
bool useHashTable; /* true to store subselect output in a hash
* table (implies we are doing "IN") */
bool unknownEqFalse; /* true if it's okay to return FALSE when the
diff --git a/src/include/optimizer/planner.h b/src/include/optimizer/planner.h
index f220e9a270d..1bbef0018d5 100644
--- a/src/include/optimizer/planner.h
+++ b/src/include/optimizer/planner.h
@@ -43,6 +43,7 @@ extern PlannedStmt *standard_planner(Query *parse, const char *query_string,
ParamListInfo boundParams);
extern PlannerInfo *subquery_planner(PlannerGlobal *glob, Query *parse,
+ char *plan_name,
PlannerInfo *parent_root,
bool hasRecursion, double tuple_fraction,
SetOperationStmt *setops);
@@ -62,4 +63,7 @@ extern Expr *preprocess_phv_expression(PlannerInfo *root, Expr *expr);
extern RelOptInfo *create_unique_paths(PlannerInfo *root, RelOptInfo *rel,
SpecialJoinInfo *sjinfo);
+extern char *choose_plan_name(PlannerGlobal *glob, const char *name,
+ bool always_number);
+
#endif /* PLANNER_H */
diff --git a/src/test/regress/expected/aggregates.out b/src/test/regress/expected/aggregates.out
index 1f24f6ffd1f..a9503e810c5 100644
--- a/src/test/regress/expected/aggregates.out
+++ b/src/test/regress/expected/aggregates.out
@@ -782,9 +782,9 @@ select array(select sum(x+y) s
QUERY PLAN
-------------------------------------------------------------------
Function Scan on pg_catalog.generate_series x
- Output: ARRAY(SubPlan 1)
+ Output: ARRAY(SubPlan array_1)
Function Call: generate_series(1, 3)
- SubPlan 1
+ SubPlan array_1
-> Sort
Output: (sum((x.x + y.y))), y.y
Sort Key: (sum((x.x + y.y)))
@@ -960,7 +960,7 @@ explain (costs off)
------------------------------------------------------------
Result
Replaces: MinMaxAggregate
- InitPlan 1
+ InitPlan minmax_1
-> Limit
-> Index Only Scan using tenk1_unique1 on tenk1
Index Cond: (unique1 IS NOT NULL)
@@ -978,7 +978,7 @@ explain (costs off)
---------------------------------------------------------------------
Result
Replaces: MinMaxAggregate
- InitPlan 1
+ InitPlan minmax_1
-> Limit
-> Index Only Scan Backward using tenk1_unique1 on tenk1
Index Cond: (unique1 IS NOT NULL)
@@ -996,7 +996,7 @@ explain (costs off)
------------------------------------------------------------------------
Result
Replaces: MinMaxAggregate
- InitPlan 1
+ InitPlan minmax_1
-> Limit
-> Index Only Scan Backward using tenk1_unique1 on tenk1
Index Cond: ((unique1 IS NOT NULL) AND (unique1 < 42))
@@ -1014,7 +1014,7 @@ explain (costs off)
------------------------------------------------------------------------
Result
Replaces: MinMaxAggregate
- InitPlan 1
+ InitPlan minmax_1
-> Limit
-> Index Only Scan Backward using tenk1_unique1 on tenk1
Index Cond: ((unique1 IS NOT NULL) AND (unique1 > 42))
@@ -1038,7 +1038,7 @@ explain (costs off)
---------------------------------------------------------------------------
Result
Replaces: MinMaxAggregate
- InitPlan 1
+ InitPlan minmax_1
-> Limit
-> Index Only Scan Backward using tenk1_unique1 on tenk1
Index Cond: ((unique1 IS NOT NULL) AND (unique1 > 42000))
@@ -1058,7 +1058,7 @@ explain (costs off)
----------------------------------------------------------------------------
Result
Replaces: MinMaxAggregate
- InitPlan 1
+ InitPlan minmax_1
-> Limit
-> Index Only Scan Backward using tenk1_thous_tenthous on tenk1
Index Cond: ((thousand = 33) AND (tenthous IS NOT NULL))
@@ -1076,7 +1076,7 @@ explain (costs off)
--------------------------------------------------------------------------
Result
Replaces: MinMaxAggregate
- InitPlan 1
+ InitPlan minmax_1
-> Limit
-> Index Only Scan using tenk1_thous_tenthous on tenk1
Index Cond: ((thousand = 33) AND (tenthous IS NOT NULL))
@@ -1095,10 +1095,10 @@ explain (costs off)
QUERY PLAN
-----------------------------------------------------------------------------------------
Seq Scan on int4_tbl
- SubPlan 2
+ SubPlan expr_1
-> Result
Replaces: MinMaxAggregate
- InitPlan 1
+ InitPlan minmax_1
-> Limit
-> Index Only Scan using tenk1_unique1 on tenk1
Index Cond: ((unique1 IS NOT NULL) AND (unique1 > int4_tbl.f1))
@@ -1121,8 +1121,8 @@ explain (costs off)
QUERY PLAN
---------------------------------------------------------------------
HashAggregate
- Group Key: (InitPlan 1).col1
- InitPlan 1
+ Group Key: (InitPlan minmax_1).col1
+ InitPlan minmax_1
-> Limit
-> Index Only Scan Backward using tenk1_unique2 on tenk1
Index Cond: (unique2 IS NOT NULL)
@@ -1141,8 +1141,8 @@ explain (costs off)
QUERY PLAN
---------------------------------------------------------------------
Sort
- Sort Key: ((InitPlan 1).col1)
- InitPlan 1
+ Sort Key: ((InitPlan minmax_1).col1)
+ InitPlan minmax_1
-> Limit
-> Index Only Scan Backward using tenk1_unique2 on tenk1
Index Cond: (unique2 IS NOT NULL)
@@ -1161,8 +1161,8 @@ explain (costs off)
QUERY PLAN
---------------------------------------------------------------------
Sort
- Sort Key: ((InitPlan 1).col1)
- InitPlan 1
+ Sort Key: ((InitPlan minmax_1).col1)
+ InitPlan minmax_1
-> Limit
-> Index Only Scan Backward using tenk1_unique2 on tenk1
Index Cond: (unique2 IS NOT NULL)
@@ -1181,8 +1181,8 @@ explain (costs off)
QUERY PLAN
---------------------------------------------------------------------
Sort
- Sort Key: (((InitPlan 1).col1 + 1))
- InitPlan 1
+ Sort Key: (((InitPlan minmax_1).col1 + 1))
+ InitPlan minmax_1
-> Limit
-> Index Only Scan Backward using tenk1_unique2 on tenk1
Index Cond: (unique2 IS NOT NULL)
@@ -1202,7 +1202,7 @@ explain (costs off)
---------------------------------------------------------------------
Sort
Sort Key: (generate_series(1, 3)) DESC
- InitPlan 1
+ InitPlan minmax_1
-> Limit
-> Index Only Scan Backward using tenk1_unique2 on tenk1
Index Cond: (unique2 IS NOT NULL)
@@ -1226,7 +1226,7 @@ explain (costs off)
----------------------------------------------------
Result
Replaces: MinMaxAggregate
- InitPlan 1
+ InitPlan minmax_1
-> Limit
-> Result
One-Time Filter: (100 IS NOT NULL)
@@ -1258,7 +1258,7 @@ explain (costs off)
---------------------------------------------------------------------------------------------
Result
Replaces: MinMaxAggregate
- InitPlan 1
+ InitPlan minmax_1
-> Limit
-> Merge Append
Sort Key: minmaxtest.f1
@@ -1269,7 +1269,7 @@ explain (costs off)
-> Index Only Scan Backward using minmaxtest2i on minmaxtest2 minmaxtest_3
Index Cond: (f1 IS NOT NULL)
-> Index Only Scan using minmaxtest3i on minmaxtest3 minmaxtest_4
- InitPlan 2
+ InitPlan minmax_1
-> Limit
-> Merge Append
Sort Key: minmaxtest_5.f1 DESC
@@ -1294,7 +1294,7 @@ explain (costs off)
QUERY PLAN
---------------------------------------------------------------------------------------------
Unique
- InitPlan 1
+ InitPlan minmax_1
-> Limit
-> Merge Append
Sort Key: minmaxtest.f1
@@ -1305,7 +1305,7 @@ explain (costs off)
-> Index Only Scan Backward using minmaxtest2i on minmaxtest2 minmaxtest_3
Index Cond: (f1 IS NOT NULL)
-> Index Only Scan using minmaxtest3i on minmaxtest3 minmaxtest_4
- InitPlan 2
+ InitPlan minmax_1
-> Limit
-> Merge Append
Sort Key: minmaxtest_5.f1 DESC
@@ -1317,7 +1317,7 @@ explain (costs off)
Index Cond: (f1 IS NOT NULL)
-> Index Only Scan Backward using minmaxtest3i on minmaxtest3 minmaxtest_9
-> Sort
- Sort Key: ((InitPlan 1).col1), ((InitPlan 2).col1)
+ Sort Key: ((InitPlan minmax_1).col1), ((InitPlan minmax_1).col1)
-> Result
Replaces: MinMaxAggregate
(27 rows)
@@ -1342,10 +1342,10 @@ explain (costs off)
QUERY PLAN
---------------------------------------------------------------------
Seq Scan on int4_tbl t0
- SubPlan 2
+ SubPlan expr_1
-> HashAggregate
- Group Key: (InitPlan 1).col1
- InitPlan 1
+ Group Key: (InitPlan minmax_1).col1
+ InitPlan minmax_1
-> Limit
-> Seq Scan on int4_tbl t1
Filter: ((f1 IS NOT NULL) AND (f1 = t0.f1))
diff --git a/src/test/regress/expected/create_index.out b/src/test/regress/expected/create_index.out
index 98e68e972be..c743fc769cb 100644
--- a/src/test/regress/expected/create_index.out
+++ b/src/test/regress/expected/create_index.out
@@ -593,7 +593,7 @@ SELECT point(x,x), (SELECT f1 FROM gpolygon_tbl ORDER BY f1 <-> point(x,x) LIMIT
QUERY PLAN
--------------------------------------------------------------------------------------------
Function Scan on generate_series x
- SubPlan 1
+ SubPlan expr_1
-> Limit
-> Index Scan using ggpolygonind on gpolygon_tbl
Order By: (f1 <-> point((x.x)::double precision, (x.x)::double precision))
@@ -1908,11 +1908,11 @@ SELECT * FROM tenk1
EXPLAIN (COSTS OFF)
SELECT * FROM tenk1
WHERE thousand = 42 AND (tenthous = 1 OR tenthous = (SELECT 1 + 2) OR tenthous = 42);
- QUERY PLAN
-----------------------------------------------------------------------------------------
+ QUERY PLAN
+---------------------------------------------------------------------------------------------
Index Scan using tenk1_thous_tenthous on tenk1
- Index Cond: ((thousand = 42) AND (tenthous = ANY (ARRAY[1, (InitPlan 1).col1, 42])))
- InitPlan 1
+ Index Cond: ((thousand = 42) AND (tenthous = ANY (ARRAY[1, (InitPlan expr_1).col1, 42])))
+ InitPlan expr_1
-> Result
(4 rows)
@@ -2043,8 +2043,8 @@ SELECT count(*) FROM tenk1 t1
----------------------------------------------------------------------------
Aggregate
-> Index Only Scan using tenk1_thous_tenthous on tenk1 t1
- Filter: ((thousand = 42) OR (thousand = (SubPlan 1)))
- SubPlan 1
+ Filter: ((thousand = 42) OR (thousand = (SubPlan expr_1)))
+ SubPlan expr_1
-> Limit
-> Index Only Scan using tenk1_thous_tenthous on tenk1 t2
Index Cond: (thousand = (t1.tenthous + 1))
diff --git a/src/test/regress/expected/groupingsets.out b/src/test/regress/expected/groupingsets.out
index 210bbe307a7..991121545c5 100644
--- a/src/test/regress/expected/groupingsets.out
+++ b/src/test/regress/expected/groupingsets.out
@@ -504,17 +504,17 @@ select grouping(ss.x)
from int8_tbl i1
cross join lateral (select (select i1.q1) as x) ss
group by ss.x;
- QUERY PLAN
-------------------------------------------------
+ QUERY PLAN
+----------------------------------------------------------
GroupAggregate
- Output: GROUPING((SubPlan 1)), ((SubPlan 2))
- Group Key: ((SubPlan 2))
+ Output: GROUPING((SubPlan expr_1)), ((SubPlan expr_2))
+ Group Key: ((SubPlan expr_2))
-> Sort
- Output: ((SubPlan 2)), i1.q1
- Sort Key: ((SubPlan 2))
+ Output: ((SubPlan expr_2)), i1.q1
+ Sort Key: ((SubPlan expr_2))
-> Seq Scan on public.int8_tbl i1
- Output: (SubPlan 2), i1.q1
- SubPlan 2
+ Output: (SubPlan expr_2), i1.q1
+ SubPlan expr_2
-> Result
Output: i1.q1
(11 rows)
@@ -534,22 +534,22 @@ select (select grouping(ss.x))
from int8_tbl i1
cross join lateral (select (select i1.q1) as x) ss
group by ss.x;
- QUERY PLAN
---------------------------------------------
+ QUERY PLAN
+------------------------------------------------
GroupAggregate
- Output: (SubPlan 2), ((SubPlan 3))
- Group Key: ((SubPlan 3))
+ Output: (SubPlan expr_1), ((SubPlan expr_3))
+ Group Key: ((SubPlan expr_3))
-> Sort
- Output: ((SubPlan 3)), i1.q1
- Sort Key: ((SubPlan 3))
+ Output: ((SubPlan expr_3)), i1.q1
+ Sort Key: ((SubPlan expr_3))
-> Seq Scan on public.int8_tbl i1
- Output: (SubPlan 3), i1.q1
- SubPlan 3
+ Output: (SubPlan expr_3), i1.q1
+ SubPlan expr_3
-> Result
Output: i1.q1
- SubPlan 2
+ SubPlan expr_1
-> Result
- Output: GROUPING((SubPlan 1))
+ Output: GROUPING((SubPlan expr_2))
(14 rows)
select (select grouping(ss.x))
@@ -592,7 +592,7 @@ explain (costs off)
------------------------------------------------------------
Result
Replaces: MinMaxAggregate
- InitPlan 1
+ InitPlan minmax_1
-> Limit
-> Index Only Scan using tenk1_unique1 on tenk1
Index Cond: (unique1 IS NOT NULL)
@@ -881,7 +881,7 @@ explain (costs off)
Sort
Sort Key: "*VALUES*".column1
-> Values Scan on "*VALUES*"
- SubPlan 1
+ SubPlan expr_1
-> Aggregate
Group Key: ()
Filter: "*VALUES*".column1
@@ -2169,17 +2169,17 @@ order by a, b, c;
-- test handling of outer GroupingFunc within subqueries
explain (costs off)
select (select grouping(v1)) from (values ((select 1))) v(v1) group by cube(v1);
- QUERY PLAN
--------------------------------
+ QUERY PLAN
+------------------------------------
MixedAggregate
- Hash Key: (InitPlan 3).col1
+ Hash Key: (InitPlan expr_3).col1
Group Key: ()
- InitPlan 1
+ InitPlan expr_2
-> Result
- InitPlan 3
+ InitPlan expr_3
-> Result
-> Result
- SubPlan 2
+ SubPlan expr_1
-> Result
(10 rows)
@@ -2192,15 +2192,15 @@ select (select grouping(v1)) from (values ((select 1))) v(v1) group by cube(v1);
explain (costs off)
select (select grouping(v1)) from (values ((select 1))) v(v1) group by v1;
- QUERY PLAN
-----------------
+ QUERY PLAN
+-------------------
GroupAggregate
- InitPlan 1
+ InitPlan expr_2
-> Result
- InitPlan 3
+ InitPlan expr_3
-> Result
-> Result
- SubPlan 2
+ SubPlan expr_1
-> Result
(8 rows)
@@ -2222,18 +2222,18 @@ order by case when grouping((select t1.v from gstest5 t2 where id = t1.id)) = 0
then (select t1.v from gstest5 t2 where id = t1.id)
else null end
nulls first;
- QUERY PLAN
----------------------------------------------------------------------------------------------------------------------------------------------
+ QUERY PLAN
+-----------------------------------------------------------------------------------------------------------------------------------------------------------------
Sort
- Output: (GROUPING((SubPlan 1))), ((SubPlan 3)), (CASE WHEN (GROUPING((SubPlan 2)) = 0) THEN ((SubPlan 3)) ELSE
NULL::integerEND), t1.v
- Sort Key: (CASE WHEN (GROUPING((SubPlan 2)) = 0) THEN ((SubPlan 3)) ELSE NULL::integer END) NULLS FIRST
+ Output: (GROUPING((SubPlan expr_1))), ((SubPlan expr_3)), (CASE WHEN (GROUPING((SubPlan expr_2)) = 0) THEN
((SubPlanexpr_3)) ELSE NULL::integer END), t1.v
+ Sort Key: (CASE WHEN (GROUPING((SubPlan expr_2)) = 0) THEN ((SubPlan expr_3)) ELSE NULL::integer END) NULLS FIRST
-> HashAggregate
- Output: GROUPING((SubPlan 1)), ((SubPlan 3)), CASE WHEN (GROUPING((SubPlan 2)) = 0) THEN ((SubPlan 3)) ELSE
NULL::integerEND, t1.v
+ Output: GROUPING((SubPlan expr_1)), ((SubPlan expr_3)), CASE WHEN (GROUPING((SubPlan expr_2)) = 0) THEN
((SubPlanexpr_3)) ELSE NULL::integer END, t1.v
Hash Key: t1.v
- Hash Key: (SubPlan 3)
+ Hash Key: (SubPlan expr_3)
-> Seq Scan on pg_temp.gstest5 t1
- Output: (SubPlan 3), t1.v, t1.id
- SubPlan 3
+ Output: (SubPlan expr_3), t1.v, t1.id
+ SubPlan expr_3
-> Bitmap Heap Scan on pg_temp.gstest5 t2
Output: t1.v
Recheck Cond: (t2.id = t1.id)
@@ -2272,18 +2272,18 @@ select grouping((select t1.v from gstest5 t2 where id = t1.id)),
from gstest5 t1
group by grouping sets(v, s)
order by o nulls first;
- QUERY PLAN
----------------------------------------------------------------------------------------------------------------------------------------------
+ QUERY PLAN
+-----------------------------------------------------------------------------------------------------------------------------------------------------------------
Sort
- Output: (GROUPING((SubPlan 1))), ((SubPlan 3)), (CASE WHEN (GROUPING((SubPlan 2)) = 0) THEN ((SubPlan 3)) ELSE
NULL::integerEND), t1.v
- Sort Key: (CASE WHEN (GROUPING((SubPlan 2)) = 0) THEN ((SubPlan 3)) ELSE NULL::integer END) NULLS FIRST
+ Output: (GROUPING((SubPlan expr_1))), ((SubPlan expr_3)), (CASE WHEN (GROUPING((SubPlan expr_2)) = 0) THEN
((SubPlanexpr_3)) ELSE NULL::integer END), t1.v
+ Sort Key: (CASE WHEN (GROUPING((SubPlan expr_2)) = 0) THEN ((SubPlan expr_3)) ELSE NULL::integer END) NULLS FIRST
-> HashAggregate
- Output: GROUPING((SubPlan 1)), ((SubPlan 3)), CASE WHEN (GROUPING((SubPlan 2)) = 0) THEN ((SubPlan 3)) ELSE
NULL::integerEND, t1.v
+ Output: GROUPING((SubPlan expr_1)), ((SubPlan expr_3)), CASE WHEN (GROUPING((SubPlan expr_2)) = 0) THEN
((SubPlanexpr_3)) ELSE NULL::integer END, t1.v
Hash Key: t1.v
- Hash Key: (SubPlan 3)
+ Hash Key: (SubPlan expr_3)
-> Seq Scan on pg_temp.gstest5 t1
- Output: (SubPlan 3), t1.v, t1.id
- SubPlan 3
+ Output: (SubPlan expr_3), t1.v, t1.id
+ SubPlan expr_3
-> Bitmap Heap Scan on pg_temp.gstest5 t2
Output: t1.v
Recheck Cond: (t2.id = t1.id)
diff --git a/src/test/regress/expected/incremental_sort.out b/src/test/regress/expected/incremental_sort.out
index 5a1dd9fc022..fdec5b9ba52 100644
--- a/src/test/regress/expected/incremental_sort.out
+++ b/src/test/regress/expected/incremental_sort.out
@@ -1609,13 +1609,13 @@ from tenk1 t, generate_series(1, 1000);
---------------------------------------------------------------------------------
Unique
-> Sort
- Sort Key: t.unique1, ((SubPlan 1))
+ Sort Key: t.unique1, ((SubPlan expr_1))
-> Gather
Workers Planned: 2
-> Nested Loop
-> Parallel Index Only Scan using tenk1_unique1 on tenk1 t
-> Function Scan on generate_series
- SubPlan 1
+ SubPlan expr_1
-> Index Only Scan using tenk1_unique1 on tenk1
Index Cond: (unique1 = t.unique1)
(11 rows)
@@ -1628,13 +1628,13 @@ order by 1, 2;
QUERY PLAN
---------------------------------------------------------------------------
Sort
- Sort Key: t.unique1, ((SubPlan 1))
+ Sort Key: t.unique1, ((SubPlan expr_1))
-> Gather
Workers Planned: 2
-> Nested Loop
-> Parallel Index Only Scan using tenk1_unique1 on tenk1 t
-> Function Scan on generate_series
- SubPlan 1
+ SubPlan expr_1
-> Index Only Scan using tenk1_unique1 on tenk1
Index Cond: (unique1 = t.unique1)
(10 rows)
diff --git a/src/test/regress/expected/inherit.out b/src/test/regress/expected/inherit.out
index 031dd87424a..6dbbd26f56b 100644
--- a/src/test/regress/expected/inherit.out
+++ b/src/test/regress/expected/inherit.out
@@ -1758,9 +1758,9 @@ explain (verbose, costs off) select min(1-id) from matest0;
QUERY PLAN
---------------------------------------------------------------------------------
Result
- Output: (InitPlan 1).col1
+ Output: (InitPlan minmax_1).col1
Replaces: MinMaxAggregate
- InitPlan 1
+ InitPlan minmax_1
-> Limit
Output: ((1 - matest0.id))
-> Result
@@ -1948,7 +1948,7 @@ SELECT min(x) FROM
--------------------------------------------------------------------
Result
Replaces: MinMaxAggregate
- InitPlan 1
+ InitPlan minmax_1
-> Limit
-> Merge Append
Sort Key: a.unique1
@@ -1967,7 +1967,7 @@ SELECT min(y) FROM
--------------------------------------------------------------------
Result
Replaces: MinMaxAggregate
- InitPlan 1
+ InitPlan minmax_1
-> Limit
-> Merge Append
Sort Key: a.unique1
@@ -2008,7 +2008,7 @@ FROM generate_series(1, 3) g(i);
QUERY PLAN
----------------------------------------------------------------
Function Scan on generate_series g
- SubPlan 1
+ SubPlan array_1
-> Limit
-> Merge Append
Sort Key: ((d.d + g.i))
@@ -2048,19 +2048,19 @@ insert into inhpar select x, x::text from generate_series(1,5) x;
insert into inhcld select x::text, x from generate_series(6,10) x;
explain (verbose, costs off)
update inhpar i set (f1, f2) = (select i.f1, i.f2 || '-' from int4_tbl limit 1);
- QUERY PLAN
---------------------------------------------------------------------------------------------
+ QUERY PLAN
+--------------------------------------------------------------------------------------------------------------------------
Update on public.inhpar i
Update on public.inhpar i_1
Update on public.inhcld i_2
-> Result
- Output: (SubPlan 1).col1, (SubPlan 1).col2, (rescan SubPlan 1), i.tableoid, i.ctid
+ Output: (SubPlan multiexpr_1).col1, (SubPlan multiexpr_1).col2, (rescan SubPlan multiexpr_1), i.tableoid,
i.ctid
-> Append
-> Seq Scan on public.inhpar i_1
Output: i_1.f1, i_1.f2, i_1.tableoid, i_1.ctid
-> Seq Scan on public.inhcld i_2
Output: i_2.f1, i_2.f2, i_2.tableoid, i_2.ctid
- SubPlan 1
+ SubPlan multiexpr_1
-> Limit
Output: (i.f1), (((i.f2)::text || '-'::text))
-> Seq Scan on public.int4_tbl
@@ -2096,21 +2096,21 @@ alter table inhpar attach partition inhcld2 for values from (5) to (100);
insert into inhpar select x, x::text from generate_series(1,10) x;
explain (verbose, costs off)
update inhpar i set (f1, f2) = (select i.f1, i.f2 || '-' from int4_tbl limit 1);
- QUERY PLAN
-------------------------------------------------------------------------------------------------------
+ QUERY PLAN
+------------------------------------------------------------------------------------------------------------------------------------
Update on public.inhpar i
Update on public.inhcld1 i_1
Update on public.inhcld2 i_2
-> Append
-> Seq Scan on public.inhcld1 i_1
- Output: (SubPlan 1).col1, (SubPlan 1).col2, (rescan SubPlan 1), i_1.tableoid, i_1.ctid
- SubPlan 1
+ Output: (SubPlan multiexpr_1).col1, (SubPlan multiexpr_1).col2, (rescan SubPlan multiexpr_1),
i_1.tableoid,i_1.ctid
+ SubPlan multiexpr_1
-> Limit
Output: (i_1.f1), (((i_1.f2)::text || '-'::text))
-> Seq Scan on public.int4_tbl
Output: i_1.f1, ((i_1.f2)::text || '-'::text)
-> Seq Scan on public.inhcld2 i_2
- Output: (SubPlan 1).col1, (SubPlan 1).col2, (rescan SubPlan 1), i_2.tableoid, i_2.ctid
+ Output: (SubPlan multiexpr_1).col1, (SubPlan multiexpr_1).col2, (rescan SubPlan multiexpr_1),
i_2.tableoid,i_2.ctid
(13 rows)
update inhpar i set (f1, f2) = (select i.f1, i.f2 || '-' from int4_tbl limit 1);
@@ -3260,11 +3260,11 @@ explain (costs off) select min(a), max(a) from parted_minmax where b = '12345';
------------------------------------------------------------------------------------------------
Result
Replaces: MinMaxAggregate
- InitPlan 1
+ InitPlan minmax_1
-> Limit
-> Index Only Scan using parted_minmax1i on parted_minmax1 parted_minmax
Index Cond: ((a IS NOT NULL) AND (b = '12345'::text))
- InitPlan 2
+ InitPlan minmax_1
-> Limit
-> Index Only Scan Backward using parted_minmax1i on parted_minmax1 parted_minmax_1
Index Cond: ((a IS NOT NULL) AND (b = '12345'::text))
diff --git a/src/test/regress/expected/insert_conflict.out b/src/test/regress/expected/insert_conflict.out
index fdd0f6c8f25..db668474684 100644
--- a/src/test/regress/expected/insert_conflict.out
+++ b/src/test/regress/expected/insert_conflict.out
@@ -61,9 +61,9 @@ explain (costs off) insert into insertconflicttest values(0, 'Crowberry') on con
Insert on insertconflicttest
Conflict Resolution: UPDATE
Conflict Arbiter Indexes: op_index_key, collation_index_key, both_index_key
- Conflict Filter: EXISTS(SubPlan 1)
+ Conflict Filter: EXISTS(SubPlan exists_1)
-> Result
- SubPlan 1
+ SubPlan exists_1
-> Index Only Scan using both_index_expr_key on insertconflicttest ii
Index Cond: (key = excluded.key)
(8 rows)
diff --git a/src/test/regress/expected/join.out b/src/test/regress/expected/join.out
index cd37f549b5a..14a6d7513aa 100644
--- a/src/test/regress/expected/join.out
+++ b/src/test/regress/expected/join.out
@@ -2375,7 +2375,7 @@ order by t1.unique1;
Sort
Sort Key: t1.unique1
-> Hash Join
- Hash Cond: ((t1.two = t2.two) AND (t1.unique1 = (SubPlan 2)))
+ Hash Cond: ((t1.two = t2.two) AND (t1.unique1 = (SubPlan expr_1)))
-> Bitmap Heap Scan on tenk1 t1
Recheck Cond: (unique1 < 10)
-> Bitmap Index Scan on tenk1_unique1
@@ -2385,10 +2385,10 @@ order by t1.unique1;
Recheck Cond: (unique1 < 10)
-> Bitmap Index Scan on tenk1_unique1
Index Cond: (unique1 < 10)
- SubPlan 2
+ SubPlan expr_1
-> Result
Replaces: MinMaxAggregate
- InitPlan 1
+ InitPlan minmax_1
-> Limit
-> Index Only Scan using tenk1_unique1 on tenk1
Index Cond: ((unique1 IS NOT NULL) AND (unique1 = t2.unique1))
@@ -3181,11 +3181,11 @@ where unique1 in (select unique2 from tenk1 b);
explain (costs off)
select a.* from tenk1 a
where unique1 not in (select unique2 from tenk1 b);
- QUERY PLAN
------------------------------------------------------------
+ QUERY PLAN
+---------------------------------------------------------------
Seq Scan on tenk1 a
- Filter: (NOT (ANY (unique1 = (hashed SubPlan 1).col1)))
- SubPlan 1
+ Filter: (NOT (ANY (unique1 = (hashed SubPlan any_1).col1)))
+ SubPlan any_1
-> Index Only Scan using tenk1_unique2 on tenk1 b
(4 rows)
@@ -3706,11 +3706,11 @@ order by 1,2;
Sort Key: t1.q1, t1.q2
-> Hash Left Join
Hash Cond: (t1.q2 = t2.q1)
- Filter: (1 = (SubPlan 1))
+ Filter: (1 = (SubPlan expr_1))
-> Seq Scan on int8_tbl t1
-> Hash
-> Seq Scan on int8_tbl t2
- SubPlan 1
+ SubPlan expr_1
-> Limit
-> Result
One-Time Filter: ((42) IS NOT NULL)
@@ -4225,14 +4225,14 @@ from int8_tbl i8
right join (select false as z) ss3 on true,
lateral (select i8.q2 as q2l where x limit 1) ss4
where i8.q2 = 123;
- QUERY PLAN
-----------------------------------------------------------------
+ QUERY PLAN
+---------------------------------------------------------------------
Nested Loop
- Output: i8.q1, i8.q2, (InitPlan 1).col1, false, (i8.q2)
- InitPlan 1
+ Output: i8.q1, i8.q2, (InitPlan expr_1).col1, false, (i8.q2)
+ InitPlan expr_1
-> Result
Output: true
- InitPlan 2
+ InitPlan expr_2
-> Result
Output: true
-> Seq Scan on public.int4_tbl i4
@@ -4241,7 +4241,7 @@ where i8.q2 = 123;
-> Nested Loop
Output: i8.q1, i8.q2, (i8.q2)
-> Subquery Scan on ss1
- Output: ss1.y, (InitPlan 1).col1
+ Output: ss1.y, (InitPlan expr_1).col1
-> Limit
Output: NULL::integer
-> Result
@@ -4255,7 +4255,7 @@ where i8.q2 = 123;
Output: (i8.q2)
-> Result
Output: i8.q2
- One-Time Filter: ((InitPlan 1).col1)
+ One-Time Filter: ((InitPlan expr_1).col1)
(29 rows)
explain (verbose, costs off)
@@ -4268,14 +4268,14 @@ from int8_tbl i8
right join (select false as z) ss3 on true,
lateral (select i8.q2 as q2l where x limit 1) ss4
where i8.q2 = 123;
- QUERY PLAN
-----------------------------------------------------------------
+ QUERY PLAN
+---------------------------------------------------------------------
Nested Loop
- Output: i8.q1, i8.q2, (InitPlan 1).col1, false, (i8.q2)
- InitPlan 1
+ Output: i8.q1, i8.q2, (InitPlan expr_1).col1, false, (i8.q2)
+ InitPlan expr_1
-> Result
Output: true
- InitPlan 2
+ InitPlan expr_2
-> Result
Output: true
-> Limit
@@ -4285,7 +4285,7 @@ where i8.q2 = 123;
-> Nested Loop
Output: i8.q1, i8.q2, (i8.q2)
-> Seq Scan on public.int4_tbl i4
- Output: i4.f1, (InitPlan 1).col1
+ Output: i4.f1, (InitPlan expr_1).col1
Filter: (i4.f1 = 0)
-> Nested Loop
Output: i8.q1, i8.q2, (i8.q2)
@@ -4296,7 +4296,7 @@ where i8.q2 = 123;
Output: (i8.q2)
-> Result
Output: i8.q2
- One-Time Filter: ((InitPlan 1).col1)
+ One-Time Filter: ((InitPlan expr_1).col1)
(27 rows)
-- Test proper handling of appendrel PHVs during useless-RTE removal
@@ -5757,13 +5757,13 @@ explain (costs off)
select a.unique1, b.unique2
from onek a left join onek b on a.unique1 = b.unique2
where (b.unique2, random() > 0) = any (select q1, random() > 0 from int8_tbl c where c.q1 < b.unique1);
- QUERY PLAN
-------------------------------------------------------------------------------------------------------------------
+ QUERY PLAN
+--------------------------------------------------------------------------------------------------------------------------
Hash Join
Hash Cond: (b.unique2 = a.unique1)
-> Seq Scan on onek b
- Filter: (ANY ((unique2 = (SubPlan 1).col1) AND ((random() > '0'::double precision) = (SubPlan 1).col2)))
- SubPlan 1
+ Filter: (ANY ((unique2 = (SubPlan any_1).col1) AND ((random() > '0'::double precision) = (SubPlan
any_1).col2)))
+ SubPlan any_1
-> Seq Scan on int8_tbl c
Filter: (q1 < b.unique1)
-> Hash
@@ -6105,7 +6105,7 @@ select exists(
QUERY PLAN
---------------------------------------------------------------------
Seq Scan on int4_tbl x0
- SubPlan 1
+ SubPlan exists_1
-> Nested Loop Left Join
Join Filter: (t2.q2 = t4.q2)
-> Nested Loop Left Join
@@ -6956,7 +6956,7 @@ where t1.a = t2.a;
------------------------------------------
Seq Scan on sj t2
Filter: (a IS NOT NULL)
- SubPlan 1
+ SubPlan expr_1
-> Result
One-Time Filter: (t2.a = t2.a)
-> Seq Scan on sj
@@ -8983,8 +8983,8 @@ lateral (select * from int8_tbl t1,
where q2 = (select greatest(t1.q1,t2.q2))
and (select v.id=0)) offset 0) ss2) ss
where t1.q1 = ss.q2) ss0;
- QUERY PLAN
-----------------------------------------------------------------------------------------------------------------------------
+ QUERY PLAN
+------------------------------------------------------------------------------------------------------------------------------------
Nested Loop
Output: "*VALUES*".column1, t1.q1, t1.q2, ss2.q1, ss2.q2
-> Seq Scan on public.int8_tbl t1
@@ -8998,20 +8998,20 @@ lateral (select * from int8_tbl t1,
Filter: (t1.q1 = ss2.q2)
-> Seq Scan on public.int8_tbl t2
Output: t2.q1, t2.q2
- Filter: (ANY ((t2.q1 = (SubPlan 3).col1) AND ((random() > '0'::double precision) = (SubPlan
3).col2)))
- SubPlan 3
+ Filter: (ANY ((t2.q1 = (SubPlan any_1).col1) AND ((random() > '0'::double precision) = (SubPlan
any_1).col2)))
+ SubPlan any_1
-> Result
Output: t3.q2, (random() > '0'::double precision)
- One-Time Filter: (InitPlan 2).col1
- InitPlan 1
+ One-Time Filter: (InitPlan expr_2).col1
+ InitPlan expr_1
-> Result
Output: GREATEST(t1.q1, t2.q2)
- InitPlan 2
+ InitPlan expr_2
-> Result
Output: ("*VALUES*".column1 = 0)
-> Seq Scan on public.int8_tbl t3
Output: t3.q1, t3.q2
- Filter: (t3.q2 = (InitPlan 1).col1)
+ Filter: (t3.q2 = (InitPlan expr_1).col1)
(27 rows)
select * from (values (0), (1)) v(id),
@@ -9723,13 +9723,13 @@ SELECT * FROM rescan_bhs t1 LEFT JOIN rescan_bhs t2 ON t1.a IN
QUERY PLAN
-----------------------------------------------------------
Nested Loop Left Join
- Join Filter: (ANY (t1.a = (SubPlan 1).col1))
+ Join Filter: (ANY (t1.a = (SubPlan any_1).col1))
-> Bitmap Heap Scan on rescan_bhs t1
-> Bitmap Index Scan on rescan_bhs_a_idx
-> Materialize
-> Bitmap Heap Scan on rescan_bhs t2
-> Bitmap Index Scan on rescan_bhs_a_idx
- SubPlan 1
+ SubPlan any_1
-> Result
One-Time Filter: (t2.a > 1)
-> Bitmap Heap Scan on rescan_bhs t3
diff --git a/src/test/regress/expected/join_hash.out b/src/test/regress/expected/join_hash.out
index 4fc34a0e72a..a45e1450040 100644
--- a/src/test/regress/expected/join_hash.out
+++ b/src/test/regress/expected/join_hash.out
@@ -1031,30 +1031,30 @@ WHERE
------------------------------------------------------------------------------------------------
Hash Join
Output: hjtest_1.a, hjtest_2.a, (hjtest_1.tableoid)::regclass, (hjtest_2.tableoid)::regclass
- Hash Cond: ((hjtest_1.id = (SubPlan 1)) AND ((SubPlan 2) = (SubPlan 3)))
+ Hash Cond: ((hjtest_1.id = (SubPlan expr_1)) AND ((SubPlan expr_2) = (SubPlan expr_3)))
Join Filter: (hjtest_1.a <> hjtest_2.b)
-> Seq Scan on public.hjtest_1
Output: hjtest_1.a, hjtest_1.tableoid, hjtest_1.id, hjtest_1.b
- Filter: ((SubPlan 4) < 50)
- SubPlan 4
+ Filter: ((SubPlan expr_4) < 50)
+ SubPlan expr_4
-> Result
Output: (hjtest_1.b * 5)
-> Hash
Output: hjtest_2.a, hjtest_2.tableoid, hjtest_2.id, hjtest_2.c, hjtest_2.b
-> Seq Scan on public.hjtest_2
Output: hjtest_2.a, hjtest_2.tableoid, hjtest_2.id, hjtest_2.c, hjtest_2.b
- Filter: ((SubPlan 5) < 55)
- SubPlan 5
+ Filter: ((SubPlan expr_5) < 55)
+ SubPlan expr_5
-> Result
Output: (hjtest_2.c * 5)
- SubPlan 1
+ SubPlan expr_1
-> Result
Output: 1
One-Time Filter: (hjtest_2.id = 1)
- SubPlan 3
+ SubPlan expr_3
-> Result
Output: (hjtest_2.c * 5)
- SubPlan 2
+ SubPlan expr_2
-> Result
Output: (hjtest_1.b * 5)
(28 rows)
@@ -1085,30 +1085,30 @@ WHERE
------------------------------------------------------------------------------------------------
Hash Join
Output: hjtest_1.a, hjtest_2.a, (hjtest_1.tableoid)::regclass, (hjtest_2.tableoid)::regclass
- Hash Cond: (((SubPlan 1) = hjtest_1.id) AND ((SubPlan 3) = (SubPlan 2)))
+ Hash Cond: (((SubPlan expr_1) = hjtest_1.id) AND ((SubPlan expr_3) = (SubPlan expr_2)))
Join Filter: (hjtest_1.a <> hjtest_2.b)
-> Seq Scan on public.hjtest_2
Output: hjtest_2.a, hjtest_2.tableoid, hjtest_2.id, hjtest_2.c, hjtest_2.b
- Filter: ((SubPlan 5) < 55)
- SubPlan 5
+ Filter: ((SubPlan expr_5) < 55)
+ SubPlan expr_5
-> Result
Output: (hjtest_2.c * 5)
-> Hash
Output: hjtest_1.a, hjtest_1.tableoid, hjtest_1.id, hjtest_1.b
-> Seq Scan on public.hjtest_1
Output: hjtest_1.a, hjtest_1.tableoid, hjtest_1.id, hjtest_1.b
- Filter: ((SubPlan 4) < 50)
- SubPlan 4
+ Filter: ((SubPlan expr_4) < 50)
+ SubPlan expr_4
-> Result
Output: (hjtest_1.b * 5)
- SubPlan 2
+ SubPlan expr_2
-> Result
Output: (hjtest_1.b * 5)
- SubPlan 1
+ SubPlan expr_1
-> Result
Output: 1
One-Time Filter: (hjtest_2.id = 1)
- SubPlan 3
+ SubPlan expr_3
-> Result
Output: (hjtest_2.c * 5)
(28 rows)
diff --git a/src/test/regress/expected/memoize.out b/src/test/regress/expected/memoize.out
index fbcaf113266..00c30b91459 100644
--- a/src/test/regress/expected/memoize.out
+++ b/src/test/regress/expected/memoize.out
@@ -429,8 +429,8 @@ WHERE unique1 < 3
----------------------------------------------------------------
Index Scan using tenk1_unique1 on tenk1 t0
Index Cond: (unique1 < 3)
- Filter: EXISTS(SubPlan 1)
- SubPlan 1
+ Filter: EXISTS(SubPlan exists_1)
+ SubPlan exists_1
-> Nested Loop
-> Index Scan using tenk1_hundred on tenk1 t2
Filter: (t0.two <> four)
diff --git a/src/test/regress/expected/merge.out b/src/test/regress/expected/merge.out
index 44df626c40c..9cb1d87066a 100644
--- a/src/test/regress/expected/merge.out
+++ b/src/test/regress/expected/merge.out
@@ -1828,29 +1828,29 @@ WHEN MATCHED AND t.c > s.cnt THEN
-> Hash Join
Output: t.ctid, s.a, s.b, s.c, s.d, s.ctid
Hash Cond: (t.a = s.a)
- Join Filter: (t.b < (SubPlan 1))
+ Join Filter: (t.b < (SubPlan expr_1))
-> Seq Scan on public.tgt t
Output: t.ctid, t.a, t.b
-> Hash
Output: s.a, s.b, s.c, s.d, s.ctid
-> Seq Scan on public.src s
Output: s.a, s.b, s.c, s.d, s.ctid
- SubPlan 1
+ SubPlan expr_1
-> Aggregate
Output: count(*)
-> Seq Scan on public.ref r
Output: r.ab, r.cd
Filter: ((r.ab = (s.a + s.b)) AND (r.cd = (s.c - s.d)))
- SubPlan 4
+ SubPlan expr_3
-> Aggregate
Output: count(*)
-> Seq Scan on public.ref r_2
Output: r_2.ab, r_2.cd
Filter: ((r_2.ab = (s.a + s.b)) AND (r_2.cd = (s.c - s.d)))
- SubPlan 3
+ SubPlan multiexpr_1
-> Result
- Output: s.b, (InitPlan 2).col1
- InitPlan 2
+ Output: s.b, (InitPlan expr_2).col1
+ InitPlan expr_2
-> Aggregate
Output: count(*)
-> Seq Scan on public.ref r_1
diff --git a/src/test/regress/expected/partition_prune.out b/src/test/regress/expected/partition_prune.out
index 7499cdb2cdf..deacdd75807 100644
--- a/src/test/regress/expected/partition_prune.out
+++ b/src/test/regress/expected/partition_prune.out
@@ -1915,21 +1915,21 @@ select * from
from int4_tbl touter) ss,
asptab
where asptab.id > ss.b::int;
- QUERY PLAN
---------------------------------------------------------------------
+ QUERY PLAN
+----------------------------------------------------------------------
Nested Loop
-> Seq Scan on int4_tbl touter
-> Append
-> Index Only Scan using asptab0_pkey on asptab0 asptab_1
- Index Cond: (id > (EXISTS(SubPlan 3))::integer)
- SubPlan 4
+ Index Cond: (id > (EXISTS(SubPlan exists_3))::integer)
+ SubPlan exists_4
-> Seq Scan on int4_tbl tinner_2
-> Index Only Scan using asptab1_pkey on asptab1 asptab_2
- Index Cond: (id > (EXISTS(SubPlan 3))::integer)
- SubPlan 3
+ Index Cond: (id > (EXISTS(SubPlan exists_3))::integer)
+ SubPlan exists_3
-> Seq Scan on int4_tbl tinner_1
Filter: (f1 = touter.f1)
- SubPlan 2
+ SubPlan exists_2
-> Seq Scan on int4_tbl tinner
(14 rows)
@@ -2236,36 +2236,36 @@ explain (analyze, costs off, summary off, timing off, buffers off) execute ab_q1
prepare ab_q2 (int, int) as
select a from ab where a between $1 and $2 and b < (select 3);
explain (analyze, costs off, summary off, timing off, buffers off) execute ab_q2 (2, 2);
- QUERY PLAN
------------------------------------------------------------------------
+ QUERY PLAN
+----------------------------------------------------------------------------
Append (actual rows=0.00 loops=1)
Subplans Removed: 6
- InitPlan 1
+ InitPlan expr_1
-> Result (actual rows=1.00 loops=1)
-> Seq Scan on ab_a2_b1 ab_1 (actual rows=0.00 loops=1)
- Filter: ((a >= $1) AND (a <= $2) AND (b < (InitPlan 1).col1))
+ Filter: ((a >= $1) AND (a <= $2) AND (b < (InitPlan expr_1).col1))
-> Seq Scan on ab_a2_b2 ab_2 (actual rows=0.00 loops=1)
- Filter: ((a >= $1) AND (a <= $2) AND (b < (InitPlan 1).col1))
+ Filter: ((a >= $1) AND (a <= $2) AND (b < (InitPlan expr_1).col1))
-> Seq Scan on ab_a2_b3 ab_3 (never executed)
- Filter: ((a >= $1) AND (a <= $2) AND (b < (InitPlan 1).col1))
+ Filter: ((a >= $1) AND (a <= $2) AND (b < (InitPlan expr_1).col1))
(10 rows)
-- As above, but swap the PARAM_EXEC Param to the first partition level
prepare ab_q3 (int, int) as
select a from ab where b between $1 and $2 and a < (select 3);
explain (analyze, costs off, summary off, timing off, buffers off) execute ab_q3 (2, 2);
- QUERY PLAN
------------------------------------------------------------------------
+ QUERY PLAN
+----------------------------------------------------------------------------
Append (actual rows=0.00 loops=1)
Subplans Removed: 6
- InitPlan 1
+ InitPlan expr_1
-> Result (actual rows=1.00 loops=1)
-> Seq Scan on ab_a1_b2 ab_1 (actual rows=0.00 loops=1)
- Filter: ((b >= $1) AND (b <= $2) AND (a < (InitPlan 1).col1))
+ Filter: ((b >= $1) AND (b <= $2) AND (a < (InitPlan expr_1).col1))
-> Seq Scan on ab_a2_b2 ab_2 (actual rows=0.00 loops=1)
- Filter: ((b >= $1) AND (b <= $2) AND (a < (InitPlan 1).col1))
+ Filter: ((b >= $1) AND (b <= $2) AND (a < (InitPlan expr_1).col1))
-> Seq Scan on ab_a3_b2 ab_3 (never executed)
- Filter: ((b >= $1) AND (b <= $2) AND (a < (InitPlan 1).col1))
+ Filter: ((b >= $1) AND (b <= $2) AND (a < (InitPlan expr_1).col1))
(10 rows)
--
@@ -2475,23 +2475,23 @@ select explain_parallel_append('execute ab_q5 (33, 44, 55)');
-- Test Parallel Append with PARAM_EXEC Params
select explain_parallel_append('select count(*) from ab where (a = (select 1) or a = (select 3)) and b = 2');
- explain_parallel_append
-------------------------------------------------------------------------------------------------
+ explain_parallel_append
+----------------------------------------------------------------------------------------------------------
Aggregate (actual rows=N loops=N)
- InitPlan 1
+ InitPlan expr_1
-> Result (actual rows=N loops=N)
- InitPlan 2
+ InitPlan expr_2
-> Result (actual rows=N loops=N)
-> Gather (actual rows=N loops=N)
Workers Planned: 2
Workers Launched: N
-> Parallel Append (actual rows=N loops=N)
-> Parallel Seq Scan on ab_a1_b2 ab_1 (actual rows=N loops=N)
- Filter: ((b = 2) AND ((a = (InitPlan 1).col1) OR (a = (InitPlan 2).col1)))
+ Filter: ((b = 2) AND ((a = (InitPlan expr_1).col1) OR (a = (InitPlan expr_2).col1)))
-> Parallel Seq Scan on ab_a2_b2 ab_2 (never executed)
- Filter: ((b = 2) AND ((a = (InitPlan 1).col1) OR (a = (InitPlan 2).col1)))
+ Filter: ((b = 2) AND ((a = (InitPlan expr_1).col1) OR (a = (InitPlan expr_2).col1)))
-> Parallel Seq Scan on ab_a3_b2 ab_3 (actual rows=N loops=N)
- Filter: ((b = 2) AND ((a = (InitPlan 1).col1) OR (a = (InitPlan 2).col1)))
+ Filter: ((b = 2) AND ((a = (InitPlan expr_1).col1) OR (a = (InitPlan expr_2).col1)))
(15 rows)
-- Test pruning during parallel nested loop query
@@ -2692,65 +2692,65 @@ select * from ab where a = (select max(a) from lprt_a) and b = (select max(a)-1
QUERY PLAN
----------------------------------------------------------------------------
Append (actual rows=0.00 loops=1)
- InitPlan 1
+ InitPlan expr_1
-> Aggregate (actual rows=1.00 loops=1)
-> Seq Scan on lprt_a (actual rows=102.00 loops=1)
- InitPlan 2
+ InitPlan expr_2
-> Aggregate (actual rows=1.00 loops=1)
-> Seq Scan on lprt_a lprt_a_1 (actual rows=102.00 loops=1)
-> Bitmap Heap Scan on ab_a1_b1 ab_1 (never executed)
- Recheck Cond: (a = (InitPlan 1).col1)
- Filter: (b = (InitPlan 2).col1)
+ Recheck Cond: (a = (InitPlan expr_1).col1)
+ Filter: (b = (InitPlan expr_2).col1)
-> Bitmap Index Scan on ab_a1_b1_a_idx (never executed)
- Index Cond: (a = (InitPlan 1).col1)
+ Index Cond: (a = (InitPlan expr_1).col1)
Index Searches: 0
-> Bitmap Heap Scan on ab_a1_b2 ab_2 (never executed)
- Recheck Cond: (a = (InitPlan 1).col1)
- Filter: (b = (InitPlan 2).col1)
+ Recheck Cond: (a = (InitPlan expr_1).col1)
+ Filter: (b = (InitPlan expr_2).col1)
-> Bitmap Index Scan on ab_a1_b2_a_idx (never executed)
- Index Cond: (a = (InitPlan 1).col1)
+ Index Cond: (a = (InitPlan expr_1).col1)
Index Searches: 0
-> Bitmap Heap Scan on ab_a1_b3 ab_3 (never executed)
- Recheck Cond: (a = (InitPlan 1).col1)
- Filter: (b = (InitPlan 2).col1)
+ Recheck Cond: (a = (InitPlan expr_1).col1)
+ Filter: (b = (InitPlan expr_2).col1)
-> Bitmap Index Scan on ab_a1_b3_a_idx (never executed)
- Index Cond: (a = (InitPlan 1).col1)
+ Index Cond: (a = (InitPlan expr_1).col1)
Index Searches: 0
-> Bitmap Heap Scan on ab_a2_b1 ab_4 (never executed)
- Recheck Cond: (a = (InitPlan 1).col1)
- Filter: (b = (InitPlan 2).col1)
+ Recheck Cond: (a = (InitPlan expr_1).col1)
+ Filter: (b = (InitPlan expr_2).col1)
-> Bitmap Index Scan on ab_a2_b1_a_idx (never executed)
- Index Cond: (a = (InitPlan 1).col1)
+ Index Cond: (a = (InitPlan expr_1).col1)
Index Searches: 0
-> Bitmap Heap Scan on ab_a2_b2 ab_5 (never executed)
- Recheck Cond: (a = (InitPlan 1).col1)
- Filter: (b = (InitPlan 2).col1)
+ Recheck Cond: (a = (InitPlan expr_1).col1)
+ Filter: (b = (InitPlan expr_2).col1)
-> Bitmap Index Scan on ab_a2_b2_a_idx (never executed)
- Index Cond: (a = (InitPlan 1).col1)
+ Index Cond: (a = (InitPlan expr_1).col1)
Index Searches: 0
-> Bitmap Heap Scan on ab_a2_b3 ab_6 (never executed)
- Recheck Cond: (a = (InitPlan 1).col1)
- Filter: (b = (InitPlan 2).col1)
+ Recheck Cond: (a = (InitPlan expr_1).col1)
+ Filter: (b = (InitPlan expr_2).col1)
-> Bitmap Index Scan on ab_a2_b3_a_idx (never executed)
- Index Cond: (a = (InitPlan 1).col1)
+ Index Cond: (a = (InitPlan expr_1).col1)
Index Searches: 0
-> Bitmap Heap Scan on ab_a3_b1 ab_7 (never executed)
- Recheck Cond: (a = (InitPlan 1).col1)
- Filter: (b = (InitPlan 2).col1)
+ Recheck Cond: (a = (InitPlan expr_1).col1)
+ Filter: (b = (InitPlan expr_2).col1)
-> Bitmap Index Scan on ab_a3_b1_a_idx (never executed)
- Index Cond: (a = (InitPlan 1).col1)
+ Index Cond: (a = (InitPlan expr_1).col1)
Index Searches: 0
-> Bitmap Heap Scan on ab_a3_b2 ab_8 (actual rows=0.00 loops=1)
- Recheck Cond: (a = (InitPlan 1).col1)
- Filter: (b = (InitPlan 2).col1)
+ Recheck Cond: (a = (InitPlan expr_1).col1)
+ Filter: (b = (InitPlan expr_2).col1)
-> Bitmap Index Scan on ab_a3_b2_a_idx (actual rows=0.00 loops=1)
- Index Cond: (a = (InitPlan 1).col1)
+ Index Cond: (a = (InitPlan expr_1).col1)
Index Searches: 1
-> Bitmap Heap Scan on ab_a3_b3 ab_9 (never executed)
- Recheck Cond: (a = (InitPlan 1).col1)
- Filter: (b = (InitPlan 2).col1)
+ Recheck Cond: (a = (InitPlan expr_1).col1)
+ Filter: (b = (InitPlan expr_2).col1)
-> Bitmap Index Scan on ab_a3_b3_a_idx (never executed)
- Index Cond: (a = (InitPlan 1).col1)
+ Index Cond: (a = (InitPlan expr_1).col1)
Index Searches: 0
(61 rows)
@@ -2760,45 +2760,45 @@ select * from (select * from ab where a = 1 union all select * from ab) ab where
QUERY PLAN
----------------------------------------------------------------------------------
Append (actual rows=0.00 loops=1)
- InitPlan 1
+ InitPlan expr_1
-> Result (actual rows=1.00 loops=1)
-> Append (actual rows=0.00 loops=1)
-> Bitmap Heap Scan on ab_a1_b1 ab_11 (actual rows=0.00 loops=1)
Recheck Cond: (a = 1)
- Filter: (b = (InitPlan 1).col1)
+ Filter: (b = (InitPlan expr_1).col1)
-> Bitmap Index Scan on ab_a1_b1_a_idx (actual rows=0.00 loops=1)
Index Cond: (a = 1)
Index Searches: 1
-> Bitmap Heap Scan on ab_a1_b2 ab_12 (never executed)
Recheck Cond: (a = 1)
- Filter: (b = (InitPlan 1).col1)
+ Filter: (b = (InitPlan expr_1).col1)
-> Bitmap Index Scan on ab_a1_b2_a_idx (never executed)
Index Cond: (a = 1)
Index Searches: 0
-> Bitmap Heap Scan on ab_a1_b3 ab_13 (never executed)
Recheck Cond: (a = 1)
- Filter: (b = (InitPlan 1).col1)
+ Filter: (b = (InitPlan expr_1).col1)
-> Bitmap Index Scan on ab_a1_b3_a_idx (never executed)
Index Cond: (a = 1)
Index Searches: 0
-> Seq Scan on ab_a1_b1 ab_1 (actual rows=0.00 loops=1)
- Filter: (b = (InitPlan 1).col1)
+ Filter: (b = (InitPlan expr_1).col1)
-> Seq Scan on ab_a1_b2 ab_2 (never executed)
- Filter: (b = (InitPlan 1).col1)
+ Filter: (b = (InitPlan expr_1).col1)
-> Seq Scan on ab_a1_b3 ab_3 (never executed)
- Filter: (b = (InitPlan 1).col1)
+ Filter: (b = (InitPlan expr_1).col1)
-> Seq Scan on ab_a2_b1 ab_4 (actual rows=0.00 loops=1)
- Filter: (b = (InitPlan 1).col1)
+ Filter: (b = (InitPlan expr_1).col1)
-> Seq Scan on ab_a2_b2 ab_5 (never executed)
- Filter: (b = (InitPlan 1).col1)
+ Filter: (b = (InitPlan expr_1).col1)
-> Seq Scan on ab_a2_b3 ab_6 (never executed)
- Filter: (b = (InitPlan 1).col1)
+ Filter: (b = (InitPlan expr_1).col1)
-> Seq Scan on ab_a3_b1 ab_7 (actual rows=0.00 loops=1)
- Filter: (b = (InitPlan 1).col1)
+ Filter: (b = (InitPlan expr_1).col1)
-> Seq Scan on ab_a3_b2 ab_8 (never executed)
- Filter: (b = (InitPlan 1).col1)
+ Filter: (b = (InitPlan expr_1).col1)
-> Seq Scan on ab_a3_b3 ab_9 (never executed)
- Filter: (b = (InitPlan 1).col1)
+ Filter: (b = (InitPlan expr_1).col1)
(40 rows)
-- A case containing a UNION ALL with a non-partitioned child.
@@ -2807,47 +2807,47 @@ select * from (select * from ab where a = 1 union all (values(10,5)) union all s
QUERY PLAN
----------------------------------------------------------------------------------
Append (actual rows=0.00 loops=1)
- InitPlan 1
+ InitPlan expr_1
-> Result (actual rows=1.00 loops=1)
-> Append (actual rows=0.00 loops=1)
-> Bitmap Heap Scan on ab_a1_b1 ab_11 (actual rows=0.00 loops=1)
Recheck Cond: (a = 1)
- Filter: (b = (InitPlan 1).col1)
+ Filter: (b = (InitPlan expr_1).col1)
-> Bitmap Index Scan on ab_a1_b1_a_idx (actual rows=0.00 loops=1)
Index Cond: (a = 1)
Index Searches: 1
-> Bitmap Heap Scan on ab_a1_b2 ab_12 (never executed)
Recheck Cond: (a = 1)
- Filter: (b = (InitPlan 1).col1)
+ Filter: (b = (InitPlan expr_1).col1)
-> Bitmap Index Scan on ab_a1_b2_a_idx (never executed)
Index Cond: (a = 1)
Index Searches: 0
-> Bitmap Heap Scan on ab_a1_b3 ab_13 (never executed)
Recheck Cond: (a = 1)
- Filter: (b = (InitPlan 1).col1)
+ Filter: (b = (InitPlan expr_1).col1)
-> Bitmap Index Scan on ab_a1_b3_a_idx (never executed)
Index Cond: (a = 1)
Index Searches: 0
-> Result (actual rows=0.00 loops=1)
- One-Time Filter: (5 = (InitPlan 1).col1)
+ One-Time Filter: (5 = (InitPlan expr_1).col1)
-> Seq Scan on ab_a1_b1 ab_1 (actual rows=0.00 loops=1)
- Filter: (b = (InitPlan 1).col1)
+ Filter: (b = (InitPlan expr_1).col1)
-> Seq Scan on ab_a1_b2 ab_2 (never executed)
- Filter: (b = (InitPlan 1).col1)
+ Filter: (b = (InitPlan expr_1).col1)
-> Seq Scan on ab_a1_b3 ab_3 (never executed)
- Filter: (b = (InitPlan 1).col1)
+ Filter: (b = (InitPlan expr_1).col1)
-> Seq Scan on ab_a2_b1 ab_4 (actual rows=0.00 loops=1)
- Filter: (b = (InitPlan 1).col1)
+ Filter: (b = (InitPlan expr_1).col1)
-> Seq Scan on ab_a2_b2 ab_5 (never executed)
- Filter: (b = (InitPlan 1).col1)
+ Filter: (b = (InitPlan expr_1).col1)
-> Seq Scan on ab_a2_b3 ab_6 (never executed)
- Filter: (b = (InitPlan 1).col1)
+ Filter: (b = (InitPlan expr_1).col1)
-> Seq Scan on ab_a3_b1 ab_7 (actual rows=0.00 loops=1)
- Filter: (b = (InitPlan 1).col1)
+ Filter: (b = (InitPlan expr_1).col1)
-> Seq Scan on ab_a3_b2 ab_8 (never executed)
- Filter: (b = (InitPlan 1).col1)
+ Filter: (b = (InitPlan expr_1).col1)
-> Seq Scan on ab_a3_b3 ab_9 (never executed)
- Filter: (b = (InitPlan 1).col1)
+ Filter: (b = (InitPlan expr_1).col1)
(42 rows)
-- Another UNION ALL test, but containing a mix of exec init and exec run-time pruning.
@@ -2865,27 +2865,27 @@ union all
) ab where a = $1 and b = (select -10);
-- Ensure the xy_1 subplan is not pruned.
explain (analyze, costs off, summary off, timing off, buffers off) execute ab_q6(1);
- QUERY PLAN
---------------------------------------------------------
+ QUERY PLAN
+-------------------------------------------------------------
Append (actual rows=0.00 loops=1)
Subplans Removed: 12
- InitPlan 1
+ InitPlan expr_1
-> Result (actual rows=1.00 loops=1)
-> Seq Scan on ab_a1_b1 ab_1 (never executed)
- Filter: ((a = $1) AND (b = (InitPlan 1).col1))
+ Filter: ((a = $1) AND (b = (InitPlan expr_1).col1))
-> Seq Scan on ab_a1_b2 ab_2 (never executed)
- Filter: ((a = $1) AND (b = (InitPlan 1).col1))
+ Filter: ((a = $1) AND (b = (InitPlan expr_1).col1))
-> Seq Scan on ab_a1_b3 ab_3 (never executed)
- Filter: ((a = $1) AND (b = (InitPlan 1).col1))
+ Filter: ((a = $1) AND (b = (InitPlan expr_1).col1))
-> Seq Scan on xy_1 (actual rows=0.00 loops=1)
- Filter: ((x = $1) AND (y = (InitPlan 1).col1))
+ Filter: ((x = $1) AND (y = (InitPlan expr_1).col1))
Rows Removed by Filter: 1
-> Seq Scan on ab_a1_b1 ab_4 (never executed)
- Filter: ((a = $1) AND (b = (InitPlan 1).col1))
+ Filter: ((a = $1) AND (b = (InitPlan expr_1).col1))
-> Seq Scan on ab_a1_b2 ab_5 (never executed)
- Filter: ((a = $1) AND (b = (InitPlan 1).col1))
+ Filter: ((a = $1) AND (b = (InitPlan expr_1).col1))
-> Seq Scan on ab_a1_b3 ab_6 (never executed)
- Filter: ((a = $1) AND (b = (InitPlan 1).col1))
+ Filter: ((a = $1) AND (b = (InitPlan expr_1).col1))
(19 rows)
-- Ensure we see just the xy_1 row.
@@ -2971,7 +2971,7 @@ update ab_a1 set b = 3 from ab_a2 where ab_a2.b = (select 1);');
Update on ab_a1_b1 ab_a1_1
Update on ab_a1_b2 ab_a1_2
Update on ab_a1_b3 ab_a1_3
- InitPlan 1
+ InitPlan expr_1
-> Result (actual rows=1.00 loops=1)
-> Nested Loop (actual rows=3.00 loops=1)
-> Append (actual rows=3.00 loops=1)
@@ -2982,11 +2982,11 @@ update ab_a1 set b = 3 from ab_a2 where ab_a2.b = (select 1);');
Storage: Memory Maximum Storage: NkB
-> Append (actual rows=1.00 loops=1)
-> Seq Scan on ab_a2_b1 ab_a2_1 (actual rows=1.00 loops=1)
- Filter: (b = (InitPlan 1).col1)
+ Filter: (b = (InitPlan expr_1).col1)
-> Seq Scan on ab_a2_b2 ab_a2_2 (never executed)
- Filter: (b = (InitPlan 1).col1)
+ Filter: (b = (InitPlan expr_1).col1)
-> Seq Scan on ab_a2_b3 ab_a2_3 (never executed)
- Filter: (b = (InitPlan 1).col1)
+ Filter: (b = (InitPlan expr_1).col1)
(20 rows)
select tableoid::regclass, * from ab;
@@ -3356,12 +3356,12 @@ select * from listp where a = (select null::int);
QUERY PLAN
------------------------------------------------------
Append (actual rows=0.00 loops=1)
- InitPlan 1
+ InitPlan expr_1
-> Result (actual rows=1.00 loops=1)
-> Seq Scan on listp_1_1 listp_1 (never executed)
- Filter: (a = (InitPlan 1).col1)
+ Filter: (a = (InitPlan expr_1).col1)
-> Seq Scan on listp_2_1 listp_2 (never executed)
- Filter: (a = (InitPlan 1).col1)
+ Filter: (a = (InitPlan expr_1).col1)
(7 rows)
drop table listp;
@@ -3500,14 +3500,14 @@ prepare ps1 as
select * from mc3p where a = $1 and abs(b) < (select 3);
explain (analyze, costs off, summary off, timing off, buffers off)
execute ps1(1);
- QUERY PLAN
--------------------------------------------------------------
+ QUERY PLAN
+------------------------------------------------------------------
Append (actual rows=1.00 loops=1)
Subplans Removed: 2
- InitPlan 1
+ InitPlan expr_1
-> Result (actual rows=1.00 loops=1)
-> Seq Scan on mc3p1 mc3p_1 (actual rows=1.00 loops=1)
- Filter: ((a = $1) AND (abs(b) < (InitPlan 1).col1))
+ Filter: ((a = $1) AND (abs(b) < (InitPlan expr_1).col1))
(6 rows)
deallocate ps1;
@@ -3515,16 +3515,16 @@ prepare ps2 as
select * from mc3p where a <= $1 and abs(b) < (select 3);
explain (analyze, costs off, summary off, timing off, buffers off)
execute ps2(1);
- QUERY PLAN
---------------------------------------------------------------
+ QUERY PLAN
+-------------------------------------------------------------------
Append (actual rows=2.00 loops=1)
Subplans Removed: 1
- InitPlan 1
+ InitPlan expr_1
-> Result (actual rows=1.00 loops=1)
-> Seq Scan on mc3p0 mc3p_1 (actual rows=1.00 loops=1)
- Filter: ((a <= $1) AND (abs(b) < (InitPlan 1).col1))
+ Filter: ((a <= $1) AND (abs(b) < (InitPlan expr_1).col1))
-> Seq Scan on mc3p1 mc3p_2 (actual rows=1.00 loops=1)
- Filter: ((a <= $1) AND (abs(b) < (InitPlan 1).col1))
+ Filter: ((a <= $1) AND (abs(b) < (InitPlan expr_1).col1))
(8 rows)
deallocate ps2;
@@ -3540,14 +3540,14 @@ select * from boolp where a = (select value from boolvalues where value);
QUERY PLAN
--------------------------------------------------------------
Append (actual rows=0.00 loops=1)
- InitPlan 1
+ InitPlan expr_1
-> Seq Scan on boolvalues (actual rows=1.00 loops=1)
Filter: value
Rows Removed by Filter: 1
-> Seq Scan on boolp_f boolp_1 (never executed)
- Filter: (a = (InitPlan 1).col1)
+ Filter: (a = (InitPlan expr_1).col1)
-> Seq Scan on boolp_t boolp_2 (actual rows=0.00 loops=1)
- Filter: (a = (InitPlan 1).col1)
+ Filter: (a = (InitPlan expr_1).col1)
(9 rows)
explain (analyze, costs off, summary off, timing off, buffers off)
@@ -3555,14 +3555,14 @@ select * from boolp where a = (select value from boolvalues where not value);
QUERY PLAN
--------------------------------------------------------------
Append (actual rows=0.00 loops=1)
- InitPlan 1
+ InitPlan expr_1
-> Seq Scan on boolvalues (actual rows=1.00 loops=1)
Filter: (NOT value)
Rows Removed by Filter: 1
-> Seq Scan on boolp_f boolp_1 (actual rows=0.00 loops=1)
- Filter: (a = (InitPlan 1).col1)
+ Filter: (a = (InitPlan expr_1).col1)
-> Seq Scan on boolp_t boolp_2 (never executed)
- Filter: (a = (InitPlan 1).col1)
+ Filter: (a = (InitPlan expr_1).col1)
(9 rows)
drop table boolp;
@@ -3654,22 +3654,22 @@ explain (analyze, costs off, summary off, timing off, buffers off) select * from
--------------------------------------------------------------------------------------------------
Merge Append (actual rows=20.00 loops=1)
Sort Key: ma_test.b
- InitPlan 2
+ InitPlan expr_1
-> Result (actual rows=1.00 loops=1)
Replaces: MinMaxAggregate
- InitPlan 1
+ InitPlan minmax_1
-> Limit (actual rows=1.00 loops=1)
-> Index Scan using ma_test_p2_b_idx on ma_test_p2 (actual rows=1.00 loops=1)
Index Cond: (b IS NOT NULL)
Index Searches: 1
-> Index Scan using ma_test_p1_b_idx on ma_test_p1 ma_test_1 (never executed)
- Filter: (a >= (InitPlan 2).col1)
+ Filter: (a >= (InitPlan expr_1).col1)
Index Searches: 0
-> Index Scan using ma_test_p2_b_idx on ma_test_p2 ma_test_2 (actual rows=10.00 loops=1)
- Filter: (a >= (InitPlan 2).col1)
+ Filter: (a >= (InitPlan expr_1).col1)
Index Searches: 1
-> Index Scan using ma_test_p3_b_idx on ma_test_p3 ma_test_3 (actual rows=10.00 loops=1)
- Filter: (a >= (InitPlan 2).col1)
+ Filter: (a >= (InitPlan expr_1).col1)
Index Searches: 1
(19 rows)
@@ -4043,17 +4043,17 @@ from (
select 1, 1, 1
) s(a, b, c)
where s.a = 1 and s.b = 1 and s.c = (select 1);
- QUERY PLAN
--------------------------------------------------------------------
+ QUERY PLAN
+------------------------------------------------------------------------
Append
- InitPlan 1
+ InitPlan expr_1
-> Result
-> Seq Scan on p1 p
- Filter: ((a = 1) AND (b = 1) AND (c = (InitPlan 1).col1))
+ Filter: ((a = 1) AND (b = 1) AND (c = (InitPlan expr_1).col1))
-> Seq Scan on q111 q1
- Filter: ((a = 1) AND (b = 1) AND (c = (InitPlan 1).col1))
+ Filter: ((a = 1) AND (b = 1) AND (c = (InitPlan expr_1).col1))
-> Result
- One-Time Filter: (1 = (InitPlan 1).col1)
+ One-Time Filter: (1 = (InitPlan expr_1).col1)
(9 rows)
select *
@@ -4081,18 +4081,18 @@ from (
) s(a, b, c)
where s.a = $1 and s.b = $2 and s.c = (select 1);
explain (costs off) execute q (1, 1);
- QUERY PLAN
-------------------------------------------------------------------------------
+ QUERY PLAN
+-----------------------------------------------------------------------------------
Append
Subplans Removed: 1
- InitPlan 1
+ InitPlan expr_1
-> Result
-> Seq Scan on p1 p
- Filter: ((a = $1) AND (b = $2) AND (c = (InitPlan 1).col1))
+ Filter: ((a = $1) AND (b = $2) AND (c = (InitPlan expr_1).col1))
-> Seq Scan on q111 q1
- Filter: ((a = $1) AND (b = $2) AND (c = (InitPlan 1).col1))
+ Filter: ((a = $1) AND (b = $2) AND (c = (InitPlan expr_1).col1))
-> Result
- One-Time Filter: ((1 = $1) AND (1 = $2) AND (1 = (InitPlan 1).col1))
+ One-Time Filter: ((1 = $1) AND (1 = $2) AND (1 = (InitPlan expr_1).col1))
(10 rows)
execute q (1, 1);
@@ -4110,11 +4110,11 @@ create table listp2 partition of listp for values in(2) partition by list(b);
create table listp2_10 partition of listp2 for values in (10);
explain (analyze, costs off, summary off, timing off, buffers off)
select * from listp where a = (select 2) and b <> 10;
- QUERY PLAN
------------------------------------------------------
+ QUERY PLAN
+--------------------------------------------------------
Seq Scan on listp1 listp (actual rows=0.00 loops=1)
- Filter: ((b <> 10) AND (a = (InitPlan 1).col1))
- InitPlan 1
+ Filter: ((b <> 10) AND (a = (InitPlan expr_1).col1))
+ InitPlan expr_1
-> Result (never executed)
(4 rows)
@@ -4182,13 +4182,13 @@ select explain_parallel_append('select * from listp where a = (select 1);');
Gather (actual rows=N loops=N)
Workers Planned: 2
Workers Launched: N
- InitPlan 1
+ InitPlan expr_1
-> Result (actual rows=N loops=N)
-> Parallel Append (actual rows=N loops=N)
-> Seq Scan on listp_12_1 listp_1 (actual rows=N loops=N)
- Filter: (a = (InitPlan 1).col1)
+ Filter: (a = (InitPlan expr_1).col1)
-> Parallel Seq Scan on listp_12_2 listp_2 (never executed)
- Filter: (a = (InitPlan 1).col1)
+ Filter: (a = (InitPlan expr_1).col1)
(10 rows)
-- Like the above but throw some more complexity at the planner by adding
@@ -4205,19 +4205,19 @@ select * from listp where a = (select 2);');
Workers Launched: N
-> Parallel Append (actual rows=N loops=N)
-> Parallel Append (actual rows=N loops=N)
- InitPlan 2
+ InitPlan expr_2
-> Result (actual rows=N loops=N)
-> Seq Scan on listp_12_1 listp_1 (never executed)
- Filter: (a = (InitPlan 2).col1)
+ Filter: (a = (InitPlan expr_2).col1)
-> Parallel Seq Scan on listp_12_2 listp_2 (actual rows=N loops=N)
- Filter: (a = (InitPlan 2).col1)
+ Filter: (a = (InitPlan expr_2).col1)
-> Parallel Append (actual rows=N loops=N)
- InitPlan 1
+ InitPlan expr_1
-> Result (actual rows=N loops=N)
-> Seq Scan on listp_12_1 listp_4 (actual rows=N loops=N)
- Filter: (a = (InitPlan 1).col1)
+ Filter: (a = (InitPlan expr_1).col1)
-> Parallel Seq Scan on listp_12_2 listp_5 (never executed)
- Filter: (a = (InitPlan 1).col1)
+ Filter: (a = (InitPlan expr_1).col1)
(18 rows)
drop table listp;
@@ -4240,23 +4240,23 @@ select * from rangep where b IN((select 1),(select 2)) order by a;
QUERY PLAN
---------------------------------------------------------------------------------------------------------------
Append (actual rows=0.00 loops=1)
- InitPlan 1
+ InitPlan expr_1
-> Result (actual rows=1.00 loops=1)
- InitPlan 2
+ InitPlan expr_2
-> Result (actual rows=1.00 loops=1)
-> Merge Append (actual rows=0.00 loops=1)
Sort Key: rangep_2.a
-> Index Scan using rangep_0_to_100_1_a_idx on rangep_0_to_100_1 rangep_2 (actual rows=0.00 loops=1)
- Filter: (b = ANY (ARRAY[(InitPlan 1).col1, (InitPlan 2).col1]))
+ Filter: (b = ANY (ARRAY[(InitPlan expr_1).col1, (InitPlan expr_2).col1]))
Index Searches: 1
-> Index Scan using rangep_0_to_100_2_a_idx on rangep_0_to_100_2 rangep_3 (actual rows=0.00 loops=1)
- Filter: (b = ANY (ARRAY[(InitPlan 1).col1, (InitPlan 2).col1]))
+ Filter: (b = ANY (ARRAY[(InitPlan expr_1).col1, (InitPlan expr_2).col1]))
Index Searches: 1
-> Index Scan using rangep_0_to_100_3_a_idx on rangep_0_to_100_3 rangep_4 (never executed)
- Filter: (b = ANY (ARRAY[(InitPlan 1).col1, (InitPlan 2).col1]))
+ Filter: (b = ANY (ARRAY[(InitPlan expr_1).col1, (InitPlan expr_2).col1]))
Index Searches: 0
-> Index Scan using rangep_100_to_200_a_idx on rangep_100_to_200 rangep_5 (actual rows=0.00 loops=1)
- Filter: (b = ANY (ARRAY[(InitPlan 1).col1, (InitPlan 2).col1]))
+ Filter: (b = ANY (ARRAY[(InitPlan expr_1).col1, (InitPlan expr_2).col1]))
Index Searches: 1
(19 rows)
diff --git a/src/test/regress/expected/portals.out b/src/test/regress/expected/portals.out
index 06726ed4ab7..31f77abc446 100644
--- a/src/test/regress/expected/portals.out
+++ b/src/test/regress/expected/portals.out
@@ -1472,18 +1472,18 @@ rollback;
-- Check handling of non-backwards-scan-capable plans with scroll cursors
begin;
explain (costs off) declare c1 cursor for select (select 42) as x;
- QUERY PLAN
-----------------
+ QUERY PLAN
+-------------------
Result
- InitPlan 1
+ InitPlan expr_1
-> Result
(3 rows)
explain (costs off) declare c1 scroll cursor for select (select 42) as x;
- QUERY PLAN
-----------------
+ QUERY PLAN
+-------------------
Materialize
- InitPlan 1
+ InitPlan expr_1
-> Result
-> Result
(4 rows)
diff --git a/src/test/regress/expected/predicate.out b/src/test/regress/expected/predicate.out
index 304b6868b90..66fb0854b88 100644
--- a/src/test/regress/expected/predicate.out
+++ b/src/test/regress/expected/predicate.out
@@ -247,11 +247,11 @@ SELECT * FROM pred_tab t1
QUERY PLAN
---------------------------------------------------------
Nested Loop Left Join
- Join Filter: EXISTS(SubPlan 1)
+ Join Filter: EXISTS(SubPlan exists_1)
-> Seq Scan on pred_tab t1
-> Materialize
-> Seq Scan on pred_tab t2
- SubPlan 1
+ SubPlan exists_1
-> Nested Loop
-> Nested Loop
-> Nested Loop
@@ -274,8 +274,8 @@ SELECT * FROM pred_tab t1
QUERY PLAN
--------------------------------------------
Nested Loop Left Join
- Join Filter: (InitPlan 1).col1
- InitPlan 1
+ Join Filter: (InitPlan exists_1).col1
+ InitPlan exists_1
-> Result
Replaces: Join on t3, t4, t5, t6
One-Time Filter: false
diff --git a/src/test/regress/expected/returning.out b/src/test/regress/expected/returning.out
index 341b689f766..d02c2ceab53 100644
--- a/src/test/regress/expected/returning.out
+++ b/src/test/regress/expected/returning.out
@@ -548,16 +548,16 @@ INSERT INTO foo VALUES (5, 'subquery test')
QUERY PLAN
---------------------------------------------------------------
Insert on pg_temp.foo
- Output: (SubPlan 1), (SubPlan 2)
+ Output: (SubPlan expr_1), (SubPlan expr_2)
-> Result
Output: 5, 'subquery test'::text, 42, '99'::bigint
- SubPlan 1
+ SubPlan expr_1
-> Aggregate
Output: max((old.f4 + x.x))
-> Function Scan on pg_catalog.generate_series x
Output: x.x
Function Call: generate_series(1, 10)
- SubPlan 2
+ SubPlan expr_2
-> Aggregate
Output: max((new.f4 + x_1.x))
-> Function Scan on pg_catalog.generate_series x_1
@@ -578,26 +578,26 @@ UPDATE foo SET f4 = 100 WHERE f1 = 5
RETURNING (SELECT old.f4 = new.f4),
(SELECT max(old.f4 + x) FROM generate_series(1, 10) x) old_max,
(SELECT max(new.f4 + x) FROM generate_series(1, 10) x) new_max;
- QUERY PLAN
----------------------------------------------------------------
+ QUERY PLAN
+----------------------------------------------------------------
Update on pg_temp.foo
- Output: (SubPlan 1), (SubPlan 2), (SubPlan 3)
+ Output: (SubPlan expr_1), (SubPlan expr_2), (SubPlan expr_3)
Update on pg_temp.foo foo_1
-> Result
Output: '100'::bigint, foo_1.tableoid, foo_1.ctid
-> Seq Scan on pg_temp.foo foo_1
Output: foo_1.tableoid, foo_1.ctid
Filter: (foo_1.f1 = 5)
- SubPlan 1
+ SubPlan expr_1
-> Result
Output: (old.f4 = new.f4)
- SubPlan 2
+ SubPlan expr_2
-> Aggregate
Output: max((old.f4 + x.x))
-> Function Scan on pg_catalog.generate_series x
Output: x.x
Function Call: generate_series(1, 10)
- SubPlan 3
+ SubPlan expr_3
-> Aggregate
Output: max((new.f4 + x_1.x))
-> Function Scan on pg_catalog.generate_series x_1
@@ -621,18 +621,18 @@ DELETE FROM foo WHERE f1 = 5
QUERY PLAN
---------------------------------------------------------------
Delete on pg_temp.foo
- Output: (SubPlan 1), (SubPlan 2)
+ Output: (SubPlan expr_1), (SubPlan expr_2)
Delete on pg_temp.foo foo_1
-> Seq Scan on pg_temp.foo foo_1
Output: foo_1.tableoid, foo_1.ctid
Filter: (foo_1.f1 = 5)
- SubPlan 1
+ SubPlan expr_1
-> Aggregate
Output: max((old.f4 + x.x))
-> Function Scan on pg_catalog.generate_series x
Output: x.x
Function Call: generate_series(1, 10)
- SubPlan 2
+ SubPlan expr_2
-> Aggregate
Output: max((new.f4 + x_1.x))
-> Function Scan on pg_catalog.generate_series x_1
diff --git a/src/test/regress/expected/rowsecurity.out b/src/test/regress/expected/rowsecurity.out
index 7153ebba521..5a172c5d91c 100644
--- a/src/test/regress/expected/rowsecurity.out
+++ b/src/test/regress/expected/rowsecurity.out
@@ -265,27 +265,27 @@ NOTICE: f_leak => awesome science fiction
(5 rows)
EXPLAIN (COSTS OFF) SELECT * FROM document WHERE f_leak(dtitle);
- QUERY PLAN
---------------------------------------------------------------
+ QUERY PLAN
+-------------------------------------------------------------------
Seq Scan on document
- Filter: ((dlevel <= (InitPlan 1).col1) AND f_leak(dtitle))
- InitPlan 1
+ Filter: ((dlevel <= (InitPlan expr_1).col1) AND f_leak(dtitle))
+ InitPlan expr_1
-> Index Scan using uaccount_pkey on uaccount
Index Cond: (pguser = CURRENT_USER)
(5 rows)
EXPLAIN (COSTS OFF) SELECT * FROM document NATURAL JOIN category WHERE f_leak(dtitle);
- QUERY PLAN
---------------------------------------------------------------------------
+ QUERY PLAN
+-------------------------------------------------------------------------------
Hash Join
Hash Cond: (category.cid = document.cid)
- InitPlan 1
+ InitPlan expr_1
-> Index Scan using uaccount_pkey on uaccount
Index Cond: (pguser = CURRENT_USER)
-> Seq Scan on category
-> Hash
-> Seq Scan on document
- Filter: ((dlevel <= (InitPlan 1).col1) AND f_leak(dtitle))
+ Filter: ((dlevel <= (InitPlan expr_1).col1) AND f_leak(dtitle))
(9 rows)
-- viewpoint from regress_rls_dave
@@ -329,27 +329,27 @@ NOTICE: f_leak => awesome technology book
(7 rows)
EXPLAIN (COSTS OFF) SELECT * FROM document WHERE f_leak(dtitle);
- QUERY PLAN
--------------------------------------------------------------------------------------------------------------
+ QUERY PLAN
+------------------------------------------------------------------------------------------------------------------
Seq Scan on document
- Filter: ((cid <> 44) AND (cid <> 44) AND (cid < 50) AND (dlevel <= (InitPlan 1).col1) AND f_leak(dtitle))
- InitPlan 1
+ Filter: ((cid <> 44) AND (cid <> 44) AND (cid < 50) AND (dlevel <= (InitPlan expr_1).col1) AND f_leak(dtitle))
+ InitPlan expr_1
-> Index Scan using uaccount_pkey on uaccount
Index Cond: (pguser = CURRENT_USER)
(5 rows)
EXPLAIN (COSTS OFF) SELECT * FROM document NATURAL JOIN category WHERE f_leak(dtitle);
- QUERY PLAN
--------------------------------------------------------------------------------------------------------------------------
+ QUERY PLAN
+------------------------------------------------------------------------------------------------------------------------------
Hash Join
Hash Cond: (category.cid = document.cid)
- InitPlan 1
+ InitPlan expr_1
-> Index Scan using uaccount_pkey on uaccount
Index Cond: (pguser = CURRENT_USER)
-> Seq Scan on category
-> Hash
-> Seq Scan on document
- Filter: ((cid <> 44) AND (cid <> 44) AND (cid < 50) AND (dlevel <= (InitPlan 1).col1) AND
f_leak(dtitle))
+ Filter: ((cid <> 44) AND (cid <> 44) AND (cid < 50) AND (dlevel <= (InitPlan expr_1).col1) AND
f_leak(dtitle))
(9 rows)
-- 44 would technically fail for both p2r and p1r, but we should get an error
@@ -987,18 +987,18 @@ NOTICE: f_leak => my first satire
(4 rows)
EXPLAIN (COSTS OFF) SELECT * FROM part_document WHERE f_leak(dtitle);
- QUERY PLAN
---------------------------------------------------------------------
+ QUERY PLAN
+-------------------------------------------------------------------------
Append
- InitPlan 1
+ InitPlan expr_1
-> Index Scan using uaccount_pkey on uaccount
Index Cond: (pguser = CURRENT_USER)
-> Seq Scan on part_document_fiction part_document_1
- Filter: ((dlevel <= (InitPlan 1).col1) AND f_leak(dtitle))
+ Filter: ((dlevel <= (InitPlan expr_1).col1) AND f_leak(dtitle))
-> Seq Scan on part_document_satire part_document_2
- Filter: ((dlevel <= (InitPlan 1).col1) AND f_leak(dtitle))
+ Filter: ((dlevel <= (InitPlan expr_1).col1) AND f_leak(dtitle))
-> Seq Scan on part_document_nonfiction part_document_3
- Filter: ((dlevel <= (InitPlan 1).col1) AND f_leak(dtitle))
+ Filter: ((dlevel <= (InitPlan expr_1).col1) AND f_leak(dtitle))
(10 rows)
-- viewpoint from regress_rls_carol
@@ -1029,18 +1029,18 @@ NOTICE: f_leak => awesome technology book
(10 rows)
EXPLAIN (COSTS OFF) SELECT * FROM part_document WHERE f_leak(dtitle);
- QUERY PLAN
---------------------------------------------------------------------
+ QUERY PLAN
+-------------------------------------------------------------------------
Append
- InitPlan 1
+ InitPlan expr_1
-> Index Scan using uaccount_pkey on uaccount
Index Cond: (pguser = CURRENT_USER)
-> Seq Scan on part_document_fiction part_document_1
- Filter: ((dlevel <= (InitPlan 1).col1) AND f_leak(dtitle))
+ Filter: ((dlevel <= (InitPlan expr_1).col1) AND f_leak(dtitle))
-> Seq Scan on part_document_satire part_document_2
- Filter: ((dlevel <= (InitPlan 1).col1) AND f_leak(dtitle))
+ Filter: ((dlevel <= (InitPlan expr_1).col1) AND f_leak(dtitle))
-> Seq Scan on part_document_nonfiction part_document_3
- Filter: ((dlevel <= (InitPlan 1).col1) AND f_leak(dtitle))
+ Filter: ((dlevel <= (InitPlan expr_1).col1) AND f_leak(dtitle))
(10 rows)
-- viewpoint from regress_rls_dave
@@ -1059,11 +1059,11 @@ NOTICE: f_leak => awesome science fiction
(4 rows)
EXPLAIN (COSTS OFF) SELECT * FROM part_document WHERE f_leak(dtitle);
- QUERY PLAN
------------------------------------------------------------------------------
+ QUERY PLAN
+----------------------------------------------------------------------------------
Seq Scan on part_document_fiction part_document
- Filter: ((cid < 55) AND (dlevel <= (InitPlan 1).col1) AND f_leak(dtitle))
- InitPlan 1
+ Filter: ((cid < 55) AND (dlevel <= (InitPlan expr_1).col1) AND f_leak(dtitle))
+ InitPlan expr_1
-> Index Scan using uaccount_pkey on uaccount
Index Cond: (pguser = CURRENT_USER)
(5 rows)
@@ -1137,11 +1137,11 @@ NOTICE: f_leak => awesome science fiction
(4 rows)
EXPLAIN (COSTS OFF) SELECT * FROM part_document WHERE f_leak(dtitle);
- QUERY PLAN
------------------------------------------------------------------------------
+ QUERY PLAN
+----------------------------------------------------------------------------------
Seq Scan on part_document_fiction part_document
- Filter: ((cid < 55) AND (dlevel <= (InitPlan 1).col1) AND f_leak(dtitle))
- InitPlan 1
+ Filter: ((cid < 55) AND (dlevel <= (InitPlan expr_1).col1) AND f_leak(dtitle))
+ InitPlan expr_1
-> Index Scan using uaccount_pkey on uaccount
Index Cond: (pguser = CURRENT_USER)
(5 rows)
@@ -1176,18 +1176,18 @@ NOTICE: f_leak => awesome technology book
(11 rows)
EXPLAIN (COSTS OFF) SELECT * FROM part_document WHERE f_leak(dtitle);
- QUERY PLAN
---------------------------------------------------------------------
+ QUERY PLAN
+-------------------------------------------------------------------------
Append
- InitPlan 1
+ InitPlan expr_1
-> Index Scan using uaccount_pkey on uaccount
Index Cond: (pguser = CURRENT_USER)
-> Seq Scan on part_document_fiction part_document_1
- Filter: ((dlevel <= (InitPlan 1).col1) AND f_leak(dtitle))
+ Filter: ((dlevel <= (InitPlan expr_1).col1) AND f_leak(dtitle))
-> Seq Scan on part_document_satire part_document_2
- Filter: ((dlevel <= (InitPlan 1).col1) AND f_leak(dtitle))
+ Filter: ((dlevel <= (InitPlan expr_1).col1) AND f_leak(dtitle))
-> Seq Scan on part_document_nonfiction part_document_3
- Filter: ((dlevel <= (InitPlan 1).col1) AND f_leak(dtitle))
+ Filter: ((dlevel <= (InitPlan expr_1).col1) AND f_leak(dtitle))
(10 rows)
-- only owner can change policies
@@ -1437,11 +1437,11 @@ NOTICE: f_leak => 03b26944890929ff751653acb2f2af79
(1 row)
EXPLAIN (COSTS OFF) SELECT * FROM only s1 WHERE f_leak(b);
- QUERY PLAN
----------------------------------------------------------------
+ QUERY PLAN
+-------------------------------------------------------------------
Seq Scan on s1
- Filter: ((ANY (a = (hashed SubPlan 1).col1)) AND f_leak(b))
- SubPlan 1
+ Filter: ((ANY (a = (hashed SubPlan any_1).col1)) AND f_leak(b))
+ SubPlan any_1
-> Seq Scan on s2
Filter: (((x % 2) = 0) AND (y ~~ '%2f%'::text))
(5 rows)
@@ -1457,11 +1457,11 @@ NOTICE: f_leak => 03b26944890929ff751653acb2f2af79
(1 row)
EXPLAIN (COSTS OFF) SELECT * FROM s1 WHERE f_leak(b);
- QUERY PLAN
----------------------------------------------------------------
+ QUERY PLAN
+-------------------------------------------------------------------
Seq Scan on s1
- Filter: ((ANY (a = (hashed SubPlan 1).col1)) AND f_leak(b))
- SubPlan 1
+ Filter: ((ANY (a = (hashed SubPlan any_1).col1)) AND f_leak(b))
+ SubPlan any_1
-> Seq Scan on s2
Filter: (((x % 2) = 0) AND (y ~~ '%af%'::text))
(5 rows)
@@ -1477,11 +1477,11 @@ EXPLAIN (COSTS OFF) SELECT (SELECT x FROM s1 LIMIT 1) xx, * FROM s2 WHERE y like
-------------------------------------------------------------------------
Seq Scan on s2
Filter: (((x % 2) = 0) AND (y ~~ '%28%'::text))
- SubPlan 2
+ SubPlan expr_1
-> Limit
-> Seq Scan on s1
- Filter: (ANY (a = (hashed SubPlan 1).col1))
- SubPlan 1
+ Filter: (ANY (a = (hashed SubPlan any_1).col1))
+ SubPlan any_1
-> Seq Scan on s2 s2_1
Filter: (((x % 2) = 0) AND (y ~~ '%af%'::text))
(9 rows)
@@ -2717,11 +2717,11 @@ NOTICE: f_leak => bbb
(1 row)
EXPLAIN (COSTS OFF) SELECT * FROM rls_view;
- QUERY PLAN
----------------------------------------------------------------------------------------
+ QUERY PLAN
+-------------------------------------------------------------------------------------------
Seq Scan on z1
- Filter: ((NOT (ANY (a = (hashed SubPlan 1).col1))) AND ((a % 2) = 0) AND f_leak(b))
- SubPlan 1
+ Filter: ((NOT (ANY (a = (hashed SubPlan any_1).col1))) AND ((a % 2) = 0) AND f_leak(b))
+ SubPlan any_1
-> Seq Scan on z1_blacklist
(4 rows)
@@ -2735,11 +2735,11 @@ NOTICE: f_leak => bbb
(1 row)
EXPLAIN (COSTS OFF) SELECT * FROM rls_view;
- QUERY PLAN
----------------------------------------------------------------------------------------
+ QUERY PLAN
+-------------------------------------------------------------------------------------------
Seq Scan on z1
- Filter: ((NOT (ANY (a = (hashed SubPlan 1).col1))) AND ((a % 2) = 0) AND f_leak(b))
- SubPlan 1
+ Filter: ((NOT (ANY (a = (hashed SubPlan any_1).col1))) AND ((a % 2) = 0) AND f_leak(b))
+ SubPlan any_1
-> Seq Scan on z1_blacklist
(4 rows)
@@ -2907,11 +2907,11 @@ NOTICE: f_leak => bbb
(1 row)
EXPLAIN (COSTS OFF) SELECT * FROM rls_view;
- QUERY PLAN
----------------------------------------------------------------------------------------
+ QUERY PLAN
+-------------------------------------------------------------------------------------------
Seq Scan on z1
- Filter: ((NOT (ANY (a = (hashed SubPlan 1).col1))) AND ((a % 2) = 0) AND f_leak(b))
- SubPlan 1
+ Filter: ((NOT (ANY (a = (hashed SubPlan any_1).col1))) AND ((a % 2) = 0) AND f_leak(b))
+ SubPlan any_1
-> Seq Scan on z1_blacklist
(4 rows)
@@ -2933,11 +2933,11 @@ NOTICE: f_leak => aba
(1 row)
EXPLAIN (COSTS OFF) SELECT * FROM rls_view;
- QUERY PLAN
----------------------------------------------------------------------------------------
+ QUERY PLAN
+-------------------------------------------------------------------------------------------
Seq Scan on z1
- Filter: ((NOT (ANY (a = (hashed SubPlan 1).col1))) AND ((a % 2) = 1) AND f_leak(b))
- SubPlan 1
+ Filter: ((NOT (ANY (a = (hashed SubPlan any_1).col1))) AND ((a % 2) = 1) AND f_leak(b))
+ SubPlan any_1
-> Seq Scan on z1_blacklist
(4 rows)
diff --git a/src/test/regress/expected/rowtypes.out b/src/test/regress/expected/rowtypes.out
index dd52d96d50f..677ad2ab9ad 100644
--- a/src/test/regress/expected/rowtypes.out
+++ b/src/test/regress/expected/rowtypes.out
@@ -1251,19 +1251,19 @@ with cte(c) as materialized (select row(1, 2)),
select * from cte2 as t
where (select * from (select c as c1) s
where (select (c1).f1 > 0)) is not null;
- QUERY PLAN
-----------------------------------------------
+ QUERY PLAN
+---------------------------------------------------
CTE Scan on cte
Output: cte.c
- Filter: ((SubPlan 3) IS NOT NULL)
+ Filter: ((SubPlan expr_1) IS NOT NULL)
CTE cte
-> Result
Output: '(1,2)'::record
- SubPlan 3
+ SubPlan expr_1
-> Result
Output: cte.c
- One-Time Filter: (InitPlan 2).col1
- InitPlan 2
+ One-Time Filter: (InitPlan expr_2).col1
+ InitPlan expr_2
-> Result
Output: ((cte.c).f1 > 0)
(13 rows)
diff --git a/src/test/regress/expected/select_parallel.out b/src/test/regress/expected/select_parallel.out
index 0185ef661b1..933921d1860 100644
--- a/src/test/regress/expected/select_parallel.out
+++ b/src/test/regress/expected/select_parallel.out
@@ -156,9 +156,9 @@ explain (costs off)
-> Parallel Append
-> Parallel Seq Scan on part_pa_test_p1 pa2_1
-> Parallel Seq Scan on part_pa_test_p2 pa2_2
- SubPlan 2
+ SubPlan expr_1
-> Result
- SubPlan 1
+ SubPlan expr_2
-> Append
-> Seq Scan on part_pa_test_p1 pa1_1
Filter: (a = pa2.a)
@@ -302,15 +302,15 @@ alter table tenk2 set (parallel_workers = 0);
explain (costs off)
select count(*) from tenk1 where (two, four) not in
(select hundred, thousand from tenk2 where thousand > 100);
- QUERY PLAN
-----------------------------------------------------------------------------------------------------------------
+ QUERY PLAN
+------------------------------------------------------------------------------------------------------------------------
Finalize Aggregate
-> Gather
Workers Planned: 4
-> Partial Aggregate
-> Parallel Seq Scan on tenk1
- Filter: (NOT (ANY ((two = (hashed SubPlan 1).col1) AND (four = (hashed SubPlan 1).col2))))
- SubPlan 1
+ Filter: (NOT (ANY ((two = (hashed SubPlan any_1).col1) AND (four = (hashed SubPlan
any_1).col2))))
+ SubPlan any_1
-> Seq Scan on tenk2
Filter: (thousand > 100)
(9 rows)
@@ -326,11 +326,11 @@ select count(*) from tenk1 where (two, four) not in
explain (costs off)
select * from tenk1 where (unique1 + random())::integer not in
(select ten from tenk2);
- QUERY PLAN
--------------------------------------------------------------------------------------------------------
+ QUERY PLAN
+-----------------------------------------------------------------------------------------------------------
Seq Scan on tenk1
- Filter: (NOT (ANY ((((unique1)::double precision + random()))::integer = (hashed SubPlan 1).col1)))
- SubPlan 1
+ Filter: (NOT (ANY ((((unique1)::double precision + random()))::integer = (hashed SubPlan any_1).col1)))
+ SubPlan any_1
-> Seq Scan on tenk2
(4 rows)
@@ -343,10 +343,10 @@ alter table tenk2 set (parallel_workers = 2);
explain (costs off)
select count(*) from tenk1
where tenk1.unique1 = (Select max(tenk2.unique1) from tenk2);
- QUERY PLAN
-------------------------------------------------------
+ QUERY PLAN
+----------------------------------------------------------
Aggregate
- InitPlan 1
+ InitPlan expr_1
-> Finalize Aggregate
-> Gather
Workers Planned: 2
@@ -355,7 +355,7 @@ explain (costs off)
-> Gather
Workers Planned: 4
-> Parallel Seq Scan on tenk1
- Filter: (unique1 = (InitPlan 1).col1)
+ Filter: (unique1 = (InitPlan expr_1).col1)
(11 rows)
select count(*) from tenk1
@@ -395,17 +395,17 @@ select count((unique1)) from tenk1 where hundred > 1;
explain (costs off)
select count((unique1)) from tenk1
where hundred = any ((select array_agg(i) from generate_series(1, 100, 15) i)::int[]);
- QUERY PLAN
----------------------------------------------------------------------
+ QUERY PLAN
+--------------------------------------------------------------------------
Finalize Aggregate
- InitPlan 1
+ InitPlan expr_1
-> Aggregate
-> Function Scan on generate_series i
-> Gather
Workers Planned: 4
-> Partial Aggregate
-> Parallel Index Scan using tenk1_hundred on tenk1
- Index Cond: (hundred = ANY ((InitPlan 1).col1))
+ Index Cond: (hundred = ANY ((InitPlan expr_1).col1))
(9 rows)
select count((unique1)) from tenk1
@@ -1224,24 +1224,24 @@ ORDER BY 1;
-> Append
-> Gather
Workers Planned: 4
- InitPlan 1
+ InitPlan expr_1
-> Limit
-> Gather
Workers Planned: 4
-> Parallel Seq Scan on tenk1 tenk1_2
Filter: (fivethous = 1)
-> Parallel Seq Scan on tenk1
- Filter: (fivethous = (InitPlan 1).col1)
+ Filter: (fivethous = (InitPlan expr_1).col1)
-> Gather
Workers Planned: 4
- InitPlan 2
+ InitPlan expr_2
-> Limit
-> Gather
Workers Planned: 4
-> Parallel Seq Scan on tenk1 tenk1_3
Filter: (fivethous = 1)
-> Parallel Seq Scan on tenk1 tenk1_1
- Filter: (fivethous = (InitPlan 2).col1)
+ Filter: (fivethous = (InitPlan expr_2).col1)
(23 rows)
-- test interaction with SRFs
@@ -1254,10 +1254,10 @@ ORDER BY 1, 2, 3;
EXPLAIN (VERBOSE, COSTS OFF)
SELECT generate_series(1, two), array(select generate_series(1, two))
FROM tenk1 ORDER BY tenthous;
- QUERY PLAN
----------------------------------------------------------------------------
+ QUERY PLAN
+---------------------------------------------------------------------------------
ProjectSet
- Output: generate_series(1, tenk1.two), ARRAY(SubPlan 1), tenk1.tenthous
+ Output: generate_series(1, tenk1.two), ARRAY(SubPlan array_1), tenk1.tenthous
-> Gather Merge
Output: tenk1.two, tenk1.tenthous
Workers Planned: 4
@@ -1268,7 +1268,7 @@ SELECT generate_series(1, two), array(select generate_series(1, two))
Sort Key: tenk1.tenthous
-> Parallel Seq Scan on public.tenk1
Output: tenk1.tenthous, tenk1.two
- SubPlan 1
+ SubPlan array_1
-> ProjectSet
Output: generate_series(1, tenk1.two)
-> Result
@@ -1333,11 +1333,11 @@ SELECT 1 FROM tenk1_vw_sec
QUERY PLAN
-------------------------------------------------------------------
Subquery Scan on tenk1_vw_sec
- Filter: ((SubPlan 1) < 100)
+ Filter: ((SubPlan expr_1) < 100)
-> Gather
Workers Planned: 4
-> Parallel Index Only Scan using tenk1_unique1 on tenk1
- SubPlan 1
+ SubPlan expr_1
-> Aggregate
-> Seq Scan on int4_tbl
Filter: (f1 < tenk1_vw_sec.unique1)
diff --git a/src/test/regress/expected/sqljson.out b/src/test/regress/expected/sqljson.out
index 625acf3019a..c7b9e575445 100644
--- a/src/test/regress/expected/sqljson.out
+++ b/src/test/regress/expected/sqljson.out
@@ -1093,8 +1093,8 @@ SELECT JSON_ARRAY(SELECT i FROM (VALUES (1), (2), (NULL), (4)) foo(i) RETURNING
QUERY PLAN
---------------------------------------------------------------------
Result
- Output: (InitPlan 1).col1
- InitPlan 1
+ Output: (InitPlan expr_1).col1
+ InitPlan expr_1
-> Aggregate
Output: JSON_ARRAYAGG("*VALUES*".column1 RETURNING jsonb)
-> Values Scan on "*VALUES*"
diff --git a/src/test/regress/expected/subselect.out b/src/test/regress/expected/subselect.out
index 47b2af7b2e1..cf6b32d1173 100644
--- a/src/test/regress/expected/subselect.out
+++ b/src/test/regress/expected/subselect.out
@@ -205,11 +205,11 @@ SELECT f1 AS "Correlated Field"
-- Check ROWCOMPARE cases, both correlated and not
EXPLAIN (VERBOSE, COSTS OFF)
SELECT ROW(1, 2) = (SELECT f1, f2) AS eq FROM SUBSELECT_TBL;
- QUERY PLAN
------------------------------------------------------------------
+ QUERY PLAN
+---------------------------------------------------------------------------------------
Seq Scan on public.subselect_tbl
- Output: (((1 = (SubPlan 1).col1) AND (2 = (SubPlan 1).col2)))
- SubPlan 1
+ Output: (((1 = (SubPlan rowcompare_1).col1) AND (2 = (SubPlan rowcompare_1).col2)))
+ SubPlan rowcompare_1
-> Result
Output: subselect_tbl.f1, subselect_tbl.f2
(5 rows)
@@ -229,11 +229,11 @@ SELECT ROW(1, 2) = (SELECT f1, f2) AS eq FROM SUBSELECT_TBL;
EXPLAIN (VERBOSE, COSTS OFF)
SELECT ROW(1, 2) = (SELECT 3, 4) AS eq FROM SUBSELECT_TBL;
- QUERY PLAN
------------------------------------------------------------------
+ QUERY PLAN
+---------------------------------------------------------------------------------------
Seq Scan on public.subselect_tbl
- Output: ((1 = (InitPlan 1).col1) AND (2 = (InitPlan 1).col2))
- InitPlan 1
+ Output: ((1 = (InitPlan rowcompare_1).col1) AND (2 = (InitPlan rowcompare_1).col2))
+ InitPlan rowcompare_1
-> Result
Output: 3, 4
(5 rows)
@@ -375,18 +375,18 @@ explain (verbose, costs off) select '42' union all select 43;
-- check materialization of an initplan reference (bug #14524)
explain (verbose, costs off)
select 1 = all (select (select 1));
- QUERY PLAN
--------------------------------------------
+ QUERY PLAN
+------------------------------------------------
Result
- Output: (ALL (1 = (SubPlan 2).col1))
- SubPlan 2
+ Output: (ALL (1 = (SubPlan all_1).col1))
+ SubPlan all_1
-> Materialize
- Output: ((InitPlan 1).col1)
- InitPlan 1
+ Output: ((InitPlan expr_1).col1)
+ InitPlan expr_1
-> Result
Output: 1
-> Result
- Output: (InitPlan 1).col1
+ Output: (InitPlan expr_1).col1
(10 rows)
select 1 = all (select (select 1));
@@ -428,8 +428,8 @@ select * from int4_tbl o where exists
QUERY PLAN
--------------------------------------
Seq Scan on int4_tbl o
- Filter: EXISTS(SubPlan 1)
- SubPlan 1
+ Filter: EXISTS(SubPlan exists_1)
+ SubPlan exists_1
-> Limit
-> Seq Scan on int4_tbl i
Filter: (f1 = o.f1)
@@ -988,7 +988,7 @@ select (1 = any(array_agg(f1))) = any (select false) from int4_tbl;
----------------------------
Aggregate
-> Seq Scan on int4_tbl
- SubPlan 1
+ SubPlan any_1
-> Result
(4 rows)
@@ -1116,11 +1116,11 @@ select * from outer_text where (f1, f2) not in (select * from inner_text);
--
explain (verbose, costs off)
select 'foo'::text in (select 'bar'::name union all select 'bar'::name);
- QUERY PLAN
----------------------------------------------------------
+ QUERY PLAN
+-------------------------------------------------------------
Result
- Output: (ANY ('foo'::text = (hashed SubPlan 1).col1))
- SubPlan 1
+ Output: (ANY ('foo'::text = (hashed SubPlan any_1).col1))
+ SubPlan any_1
-> Append
-> Result
Output: 'bar'::name
@@ -1140,11 +1140,11 @@ select 'foo'::text in (select 'bar'::name union all select 'bar'::name);
--
explain (verbose, costs off)
select row(row(row(1))) = any (select row(row(1)));
- QUERY PLAN
---------------------------------------------------------
+ QUERY PLAN
+------------------------------------------------------------
Result
- Output: (ANY ('("(1)")'::record = (SubPlan 1).col1))
- SubPlan 1
+ Output: (ANY ('("(1)")'::record = (SubPlan any_1).col1))
+ SubPlan any_1
-> Materialize
Output: '("(1)")'::record
-> Result
@@ -1184,11 +1184,11 @@ language sql as 'select $1::text = $2';
create operator = (procedure=bogus_int8_text_eq, leftarg=int8, rightarg=text);
explain (costs off)
select * from int8_tbl where q1 in (select c1 from inner_text);
- QUERY PLAN
---------------------------------------------------------
+ QUERY PLAN
+------------------------------------------------------------
Seq Scan on int8_tbl
- Filter: (ANY ((q1)::text = (hashed SubPlan 1).col1))
- SubPlan 1
+ Filter: (ANY ((q1)::text = (hashed SubPlan any_1).col1))
+ SubPlan any_1
-> Seq Scan on inner_text
(4 rows)
@@ -1205,11 +1205,11 @@ create or replace function bogus_int8_text_eq(int8, text) returns boolean
language sql as 'select $1::text = $2 and $1::text = $2';
explain (costs off)
select * from int8_tbl where q1 in (select c1 from inner_text);
- QUERY PLAN
------------------------------------------------------------------------------------------------------
+ QUERY PLAN
+-------------------------------------------------------------------------------------------------------------
Seq Scan on int8_tbl
- Filter: (ANY (((q1)::text = (hashed SubPlan 1).col1) AND ((q1)::text = (hashed SubPlan 1).col1)))
- SubPlan 1
+ Filter: (ANY (((q1)::text = (hashed SubPlan any_1).col1) AND ((q1)::text = (hashed SubPlan any_1).col1)))
+ SubPlan any_1
-> Seq Scan on inner_text
(4 rows)
@@ -1226,11 +1226,11 @@ create or replace function bogus_int8_text_eq(int8, text) returns boolean
language sql as 'select $2 = $1::text';
explain (costs off)
select * from int8_tbl where q1 in (select c1 from inner_text);
- QUERY PLAN
--------------------------------------------------
+ QUERY PLAN
+-----------------------------------------------------
Seq Scan on int8_tbl
- Filter: (ANY ((SubPlan 1).col1 = (q1)::text))
- SubPlan 1
+ Filter: (ANY ((SubPlan any_1).col1 = (q1)::text))
+ SubPlan any_1
-> Materialize
-> Seq Scan on inner_text
(5 rows)
@@ -1249,12 +1249,12 @@ rollback; -- to get rid of the bogus operator
explain (costs off)
select count(*) from tenk1 t
where (exists(select 1 from tenk1 k where k.unique1 = t.unique2) or ten < 0);
- QUERY PLAN
---------------------------------------------------------------------------
+ QUERY PLAN
+---------------------------------------------------------------------------------
Aggregate
-> Seq Scan on tenk1 t
- Filter: ((ANY (unique2 = (hashed SubPlan 2).col1)) OR (ten < 0))
- SubPlan 2
+ Filter: ((ANY (unique2 = (hashed SubPlan exists_2).col1)) OR (ten < 0))
+ SubPlan exists_2
-> Index Only Scan using tenk1_unique1 on tenk1 k
(5 rows)
@@ -1274,10 +1274,10 @@ where (exists(select 1 from tenk1 k where k.unique1 = t.unique2) or ten < 0)
Aggregate
-> Bitmap Heap Scan on tenk1 t
Recheck Cond: (thousand = 1)
- Filter: (EXISTS(SubPlan 1) OR (ten < 0))
+ Filter: (EXISTS(SubPlan exists_1) OR (ten < 0))
-> Bitmap Index Scan on tenk1_thous_tenthous
Index Cond: (thousand = 1)
- SubPlan 1
+ SubPlan exists_1
-> Index Only Scan using tenk1_unique1 on tenk1 k
Index Cond: (unique1 = t.unique2)
(9 rows)
@@ -1299,20 +1299,20 @@ analyze exists_tbl;
explain (costs off)
select * from exists_tbl t1
where (exists(select 1 from exists_tbl t2 where t1.c1 = t2.c2) or c3 < 0);
- QUERY PLAN
---------------------------------------------------------------------
+ QUERY PLAN
+---------------------------------------------------------------------------
Append
-> Seq Scan on exists_tbl_null t1_1
- Filter: (EXISTS(SubPlan 1) OR (c3 < 0))
- SubPlan 1
+ Filter: (EXISTS(SubPlan exists_1) OR (c3 < 0))
+ SubPlan exists_1
-> Append
-> Seq Scan on exists_tbl_null t2_1
Filter: (t1_1.c1 = c2)
-> Seq Scan on exists_tbl_def t2_2
Filter: (t1_1.c1 = c2)
-> Seq Scan on exists_tbl_def t1_2
- Filter: ((ANY (c1 = (hashed SubPlan 2).col1)) OR (c3 < 0))
- SubPlan 2
+ Filter: ((ANY (c1 = (hashed SubPlan exists_2).col1)) OR (c3 < 0))
+ SubPlan exists_2
-> Append
-> Seq Scan on exists_tbl_null t2_4
-> Seq Scan on exists_tbl_def t2_5
@@ -1348,14 +1348,14 @@ where a.thousand = b.thousand
explain (verbose, costs off)
select x, x from
(select (select now()) as x from (values(1),(2)) v(y)) ss;
- QUERY PLAN
-------------------------------------------------
+ QUERY PLAN
+----------------------------------------------------------
Values Scan on "*VALUES*"
- Output: (InitPlan 1).col1, (InitPlan 2).col1
- InitPlan 1
+ Output: (InitPlan expr_1).col1, (InitPlan expr_2).col1
+ InitPlan expr_1
-> Result
Output: now()
- InitPlan 2
+ InitPlan expr_2
-> Result
Output: now()
(8 rows)
@@ -1363,13 +1363,13 @@ explain (verbose, costs off)
explain (verbose, costs off)
select x, x from
(select (select random()) as x from (values(1),(2)) v(y)) ss;
- QUERY PLAN
------------------------------------
+ QUERY PLAN
+----------------------------------------
Subquery Scan on ss
Output: ss.x, ss.x
-> Values Scan on "*VALUES*"
- Output: (InitPlan 1).col1
- InitPlan 1
+ Output: (InitPlan expr_1).col1
+ InitPlan expr_1
-> Result
Output: random()
(7 rows)
@@ -1380,12 +1380,12 @@ explain (verbose, costs off)
QUERY PLAN
----------------------------------------------------------------------
Values Scan on "*VALUES*"
- Output: (SubPlan 1), (SubPlan 2)
- SubPlan 1
+ Output: (SubPlan expr_1), (SubPlan expr_2)
+ SubPlan expr_1
-> Result
Output: now()
One-Time Filter: ("*VALUES*".column1 = "*VALUES*".column1)
- SubPlan 2
+ SubPlan expr_2
-> Result
Output: now()
One-Time Filter: ("*VALUES*".column1 = "*VALUES*".column1)
@@ -1399,8 +1399,8 @@ explain (verbose, costs off)
Subquery Scan on ss
Output: ss.x, ss.x
-> Values Scan on "*VALUES*"
- Output: (SubPlan 1)
- SubPlan 1
+ Output: (SubPlan expr_1)
+ SubPlan expr_1
-> Result
Output: random()
One-Time Filter: ("*VALUES*".column1 = "*VALUES*".column1)
@@ -1420,16 +1420,16 @@ where o.ten = 0;
QUERY PLAN
---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
Aggregate
- Output: sum((((ANY (i.ten = (hashed SubPlan 1).col1))))::integer)
+ Output: sum((((ANY (i.ten = (hashed SubPlan any_1).col1))))::integer)
-> Nested Loop
- Output: ((ANY (i.ten = (hashed SubPlan 1).col1)))
+ Output: ((ANY (i.ten = (hashed SubPlan any_1).col1)))
-> Seq Scan on public.onek o
Output: o.unique1, o.unique2, o.two, o.four, o.ten, o.twenty, o.hundred, o.thousand, o.twothousand,
o.fivethous,o.tenthous, o.odd, o.even, o.stringu1, o.stringu2, o.string4
Filter: (o.ten = 0)
-> Index Scan using onek_unique1 on public.onek i
- Output: (ANY (i.ten = (hashed SubPlan 1).col1)), random()
+ Output: (ANY (i.ten = (hashed SubPlan any_1).col1)), random()
Index Cond: (i.unique1 = o.unique1)
- SubPlan 1
+ SubPlan any_1
-> Seq Scan on public.int4_tbl
Output: int4_tbl.f1
Filter: (int4_tbl.f1 <= o.hundred)
@@ -1638,7 +1638,7 @@ select * from
----------------------------------------
Values Scan on "*VALUES*"
Output: "*VALUES*".column1
- SubPlan 1
+ SubPlan any_1
-> Values Scan on "*VALUES*_1"
Output: "*VALUES*_1".column1
(5 rows)
@@ -1665,12 +1665,12 @@ select * from int4_tbl where
---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
Nested Loop Semi Join
Output: int4_tbl.f1
- Join Filter: (CASE WHEN (ANY (int4_tbl.f1 = (hashed SubPlan 1).col1)) THEN int4_tbl.f1 ELSE NULL::integer END =
b.ten)
+ Join Filter: (CASE WHEN (ANY (int4_tbl.f1 = (hashed SubPlan any_1).col1)) THEN int4_tbl.f1 ELSE NULL::integer END =
b.ten)
-> Seq Scan on public.int4_tbl
Output: int4_tbl.f1
-> Seq Scan on public.tenk1 b
Output: b.unique1, b.unique2, b.two, b.four, b.ten, b.twenty, b.hundred, b.thousand, b.twothousand,
b.fivethous,b.tenthous, b.odd, b.even, b.stringu1, b.stringu2, b.string4
- SubPlan 1
+ SubPlan any_1
-> Index Only Scan using tenk1_unique1 on public.tenk1 a
Output: a.unique1
(10 rows)
@@ -2798,14 +2798,14 @@ select * from tenk1 A where exists
(select 1 from tenk2 B
where A.hundred in (select C.hundred FROM tenk2 C
WHERE c.odd = b.odd));
- QUERY PLAN
------------------------------------------------------
+ QUERY PLAN
+---------------------------------------------------------
Nested Loop Semi Join
- Join Filter: (ANY (a.hundred = (SubPlan 1).col1))
+ Join Filter: (ANY (a.hundred = (SubPlan any_1).col1))
-> Seq Scan on tenk1 a
-> Materialize
-> Seq Scan on tenk2 b
- SubPlan 1
+ SubPlan any_1
-> Seq Scan on tenk2 c
Filter: (odd = b.odd)
(8 rows)
@@ -2815,14 +2815,14 @@ WHERE c.odd = b.odd));
explain (costs off)
SELECT * FROM tenk1 A LEFT JOIN tenk2 B
ON A.hundred in (SELECT c.hundred FROM tenk2 C WHERE c.odd = b.odd);
- QUERY PLAN
------------------------------------------------------
+ QUERY PLAN
+---------------------------------------------------------
Nested Loop Left Join
- Join Filter: (ANY (a.hundred = (SubPlan 1).col1))
+ Join Filter: (ANY (a.hundred = (SubPlan any_1).col1))
-> Seq Scan on tenk1 a
-> Materialize
-> Seq Scan on tenk2 b
- SubPlan 1
+ SubPlan any_1
-> Seq Scan on tenk2 c
Filter: (odd = b.odd)
(8 rows)
@@ -2832,14 +2832,14 @@ ON A.hundred in (SELECT c.hundred FROM tenk2 C WHERE c.odd = b.odd);
explain (costs off)
SELECT * FROM tenk1 A LEFT JOIN tenk2 B
ON B.hundred in (SELECT c.hundred FROM tenk2 C WHERE c.odd = a.odd);
- QUERY PLAN
------------------------------------------------------
+ QUERY PLAN
+---------------------------------------------------------
Nested Loop Left Join
- Join Filter: (ANY (b.hundred = (SubPlan 1).col1))
+ Join Filter: (ANY (b.hundred = (SubPlan any_1).col1))
-> Seq Scan on tenk1 a
-> Materialize
-> Seq Scan on tenk2 b
- SubPlan 1
+ SubPlan any_1
-> Seq Scan on tenk2 c
Filter: (odd = a.odd)
(8 rows)
@@ -2901,7 +2901,7 @@ ON B.hundred in (SELECT min(c.hundred) FROM tenk2 C WHERE c.odd = b.odd);
Filter: (b.hundred = unnamed_subquery.min)
-> Result
Replaces: MinMaxAggregate
- InitPlan 1
+ InitPlan minmax_1
-> Limit
-> Index Scan using tenk2_hundred on tenk2 c
Index Cond: (hundred IS NOT NULL)
@@ -3142,7 +3142,7 @@ WHERE unique1 IN (VALUES (0), ((2 IN (SELECT unique2 FROM onek c
-> Seq Scan on onek t
-> Values Scan on "*VALUES*"
Filter: (t.unique1 = column1)
- SubPlan 1
+ SubPlan any_1
-> Index Only Scan using onek_unique2 on onek c
Index Cond: (unique2 = t.unique1)
(7 rows)
@@ -3158,7 +3158,7 @@ WHERE unique1 IN (VALUES (0), ((2 IN (SELECT unique2 FROM onek c
-> Sort
Sort Key: "*VALUES*".column1
-> Values Scan on "*VALUES*"
- SubPlan 1
+ SubPlan any_1
-> Index Only Scan using onek_unique2 on onek c
Filter: ((unique2)::double precision = ANY ('{0.479425538604203,2}'::double precision[]))
-> Index Scan using onek_unique1 on onek t
@@ -3177,7 +3177,7 @@ SELECT ten FROM onek t WHERE unique1 IN (VALUES (0), ((2 IN
-> Sort
Sort Key: "*VALUES*".column1
-> Values Scan on "*VALUES*"
- SubPlan 1
+ SubPlan any_1
-> Result
-> Index Scan using onek_unique1 on onek t
Index Cond: (unique1 = "*VALUES*".column1)
diff --git a/src/test/regress/expected/updatable_views.out b/src/test/regress/expected/updatable_views.out
index 095df0a670c..03df7e75b7b 100644
--- a/src/test/regress/expected/updatable_views.out
+++ b/src/test/regress/expected/updatable_views.out
@@ -2750,7 +2750,7 @@ EXPLAIN (costs off) INSERT INTO rw_view1 VALUES (5);
---------------------------------------------------------
Insert on base_tbl b
-> Result
- SubPlan 1
+ SubPlan exists_1
-> Index Only Scan using ref_tbl_pkey on ref_tbl r
Index Cond: (a = b.a)
(5 rows)
@@ -2764,7 +2764,7 @@ EXPLAIN (costs off) UPDATE rw_view1 SET a = a + 5;
-> Seq Scan on base_tbl b
-> Hash
-> Seq Scan on ref_tbl r
- SubPlan 1
+ SubPlan exists_1
-> Index Only Scan using ref_tbl_pkey on ref_tbl r_1
Index Cond: (a = b.a)
(9 rows)
@@ -3167,21 +3167,21 @@ EXPLAIN (costs off) DELETE FROM rw_view1 WHERE id = 1 AND snoop(data);
DELETE FROM rw_view1 WHERE id = 1 AND snoop(data);
NOTICE: snooped value: Row 1
EXPLAIN (costs off) INSERT INTO rw_view1 VALUES (2, 'New row 2');
- QUERY PLAN
------------------------------------------------------------
+ QUERY PLAN
+-----------------------------------------------------------------
Insert on base_tbl
- InitPlan 1
+ InitPlan exists_1
-> Index Only Scan using base_tbl_pkey on base_tbl t
Index Cond: (id = 2)
-> Result
- One-Time Filter: ((InitPlan 1).col1 IS NOT TRUE)
+ One-Time Filter: ((InitPlan exists_1).col1 IS NOT TRUE)
Update on base_tbl
- InitPlan 1
+ InitPlan exists_1
-> Index Only Scan using base_tbl_pkey on base_tbl t
Index Cond: (id = 2)
-> Result
- One-Time Filter: (InitPlan 1).col1
+ One-Time Filter: (InitPlan exists_1).col1
-> Index Scan using base_tbl_pkey on base_tbl
Index Cond: (id = 2)
(15 rows)
@@ -3240,8 +3240,8 @@ SELECT * FROM v1 WHERE a=8;
EXPLAIN (VERBOSE, COSTS OFF)
UPDATE v1 SET a=100 WHERE snoop(a) AND leakproof(a) AND a < 7 AND a != 6;
- QUERY PLAN
------------------------------------------------------------------------------------------------------------
+ QUERY PLAN
+------------------------------------------------------------------------------------------------------------------
Update on public.t1
Update on public.t1 t1_1
Update on public.t11 t1_2
@@ -3253,8 +3253,8 @@ UPDATE v1 SET a=100 WHERE snoop(a) AND leakproof(a) AND a < 7 AND a != 6;
-> Index Scan using t1_a_idx on public.t1 t1_1
Output: t1_1.tableoid, t1_1.ctid
Index Cond: ((t1_1.a > 5) AND (t1_1.a < 7))
- Filter: ((t1_1.a <> 6) AND EXISTS(SubPlan 1) AND snoop(t1_1.a) AND leakproof(t1_1.a))
- SubPlan 1
+ Filter: ((t1_1.a <> 6) AND EXISTS(SubPlan exists_1) AND snoop(t1_1.a) AND leakproof(t1_1.a))
+ SubPlan exists_1
-> Append
-> Seq Scan on public.t12 t12_1
Filter: (t12_1.a = t1_1.a)
@@ -3263,15 +3263,15 @@ UPDATE v1 SET a=100 WHERE snoop(a) AND leakproof(a) AND a < 7 AND a != 6;
-> Index Scan using t11_a_idx on public.t11 t1_2
Output: t1_2.tableoid, t1_2.ctid
Index Cond: ((t1_2.a > 5) AND (t1_2.a < 7))
- Filter: ((t1_2.a <> 6) AND EXISTS(SubPlan 1) AND snoop(t1_2.a) AND leakproof(t1_2.a))
+ Filter: ((t1_2.a <> 6) AND EXISTS(SubPlan exists_1) AND snoop(t1_2.a) AND leakproof(t1_2.a))
-> Index Scan using t12_a_idx on public.t12 t1_3
Output: t1_3.tableoid, t1_3.ctid
Index Cond: ((t1_3.a > 5) AND (t1_3.a < 7))
- Filter: ((t1_3.a <> 6) AND EXISTS(SubPlan 1) AND snoop(t1_3.a) AND leakproof(t1_3.a))
+ Filter: ((t1_3.a <> 6) AND EXISTS(SubPlan exists_1) AND snoop(t1_3.a) AND leakproof(t1_3.a))
-> Index Scan using t111_a_idx on public.t111 t1_4
Output: t1_4.tableoid, t1_4.ctid
Index Cond: ((t1_4.a > 5) AND (t1_4.a < 7))
- Filter: ((t1_4.a <> 6) AND EXISTS(SubPlan 1) AND snoop(t1_4.a) AND leakproof(t1_4.a))
+ Filter: ((t1_4.a <> 6) AND EXISTS(SubPlan exists_1) AND snoop(t1_4.a) AND leakproof(t1_4.a))
(30 rows)
UPDATE v1 SET a=100 WHERE snoop(a) AND leakproof(a) AND a < 7 AND a != 6;
@@ -3287,8 +3287,8 @@ SELECT * FROM t1 WHERE a=100; -- Nothing should have been changed to 100
EXPLAIN (VERBOSE, COSTS OFF)
UPDATE v1 SET a=a+1 WHERE snoop(a) AND leakproof(a) AND a = 8;
- QUERY PLAN
------------------------------------------------------------------------------------------
+ QUERY PLAN
+------------------------------------------------------------------------------------------------
Update on public.t1
Update on public.t1 t1_1
Update on public.t11 t1_2
@@ -3300,8 +3300,8 @@ UPDATE v1 SET a=a+1 WHERE snoop(a) AND leakproof(a) AND a = 8;
-> Index Scan using t1_a_idx on public.t1 t1_1
Output: t1_1.a, t1_1.tableoid, t1_1.ctid
Index Cond: ((t1_1.a > 5) AND (t1_1.a = 8))
- Filter: (EXISTS(SubPlan 1) AND snoop(t1_1.a) AND leakproof(t1_1.a))
- SubPlan 1
+ Filter: (EXISTS(SubPlan exists_1) AND snoop(t1_1.a) AND leakproof(t1_1.a))
+ SubPlan exists_1
-> Append
-> Seq Scan on public.t12 t12_1
Filter: (t12_1.a = t1_1.a)
@@ -3310,15 +3310,15 @@ UPDATE v1 SET a=a+1 WHERE snoop(a) AND leakproof(a) AND a = 8;
-> Index Scan using t11_a_idx on public.t11 t1_2
Output: t1_2.a, t1_2.tableoid, t1_2.ctid
Index Cond: ((t1_2.a > 5) AND (t1_2.a = 8))
- Filter: (EXISTS(SubPlan 1) AND snoop(t1_2.a) AND leakproof(t1_2.a))
+ Filter: (EXISTS(SubPlan exists_1) AND snoop(t1_2.a) AND leakproof(t1_2.a))
-> Index Scan using t12_a_idx on public.t12 t1_3
Output: t1_3.a, t1_3.tableoid, t1_3.ctid
Index Cond: ((t1_3.a > 5) AND (t1_3.a = 8))
- Filter: (EXISTS(SubPlan 1) AND snoop(t1_3.a) AND leakproof(t1_3.a))
+ Filter: (EXISTS(SubPlan exists_1) AND snoop(t1_3.a) AND leakproof(t1_3.a))
-> Index Scan using t111_a_idx on public.t111 t1_4
Output: t1_4.a, t1_4.tableoid, t1_4.ctid
Index Cond: ((t1_4.a > 5) AND (t1_4.a = 8))
- Filter: (EXISTS(SubPlan 1) AND snoop(t1_4.a) AND leakproof(t1_4.a))
+ Filter: (EXISTS(SubPlan exists_1) AND snoop(t1_4.a) AND leakproof(t1_4.a))
(30 rows)
UPDATE v1 SET a=a+1 WHERE snoop(a) AND leakproof(a) AND a = 8;
@@ -3502,10 +3502,10 @@ CREATE RULE v1_upd_rule AS ON UPDATE TO v1 DO INSTEAD
CREATE VIEW v2 WITH (security_barrier = true) AS
SELECT * FROM v1 WHERE EXISTS (SELECT 1);
EXPLAIN (COSTS OFF) UPDATE v2 SET a = 1;
- QUERY PLAN
---------------------------------------------------------------
+ QUERY PLAN
+---------------------------------------------------------------------
Update on t1
- InitPlan 1
+ InitPlan exists_1
-> Result
-> Merge Join
Merge Cond: (t1.a = v1.a)
@@ -3516,7 +3516,7 @@ EXPLAIN (COSTS OFF) UPDATE v2 SET a = 1;
Sort Key: v1.a
-> Subquery Scan on v1
-> Result
- One-Time Filter: (InitPlan 1).col1
+ One-Time Filter: (InitPlan exists_1).col1
-> Seq Scan on t1 t1_1
(14 rows)
diff --git a/src/test/regress/expected/update.out b/src/test/regress/expected/update.out
index 1b27d132d7b..eef2bac1cbf 100644
--- a/src/test/regress/expected/update.out
+++ b/src/test/regress/expected/update.out
@@ -178,15 +178,15 @@ EXPLAIN (VERBOSE, COSTS OFF)
UPDATE update_test t
SET (a, b) = (SELECT b, a FROM update_test s WHERE s.a = t.a)
WHERE CURRENT_USER = SESSION_USER;
- QUERY PLAN
---------------------------------------------------------------------------------
+ QUERY PLAN
+--------------------------------------------------------------------------------------------------------------
Update on public.update_test t
-> Result
- Output: (SubPlan 1).col1, (SubPlan 1).col2, (rescan SubPlan 1), t.ctid
+ Output: (SubPlan multiexpr_1).col1, (SubPlan multiexpr_1).col2, (rescan SubPlan multiexpr_1), t.ctid
One-Time Filter: (CURRENT_USER = SESSION_USER)
-> Seq Scan on public.update_test t
Output: t.a, t.ctid
- SubPlan 1
+ SubPlan multiexpr_1
-> Seq Scan on public.update_test s
Output: s.b, s.a
Filter: (s.a = t.a)
diff --git a/src/test/regress/expected/window.out b/src/test/regress/expected/window.out
index b86b668f433..4ccc349eec7 100644
--- a/src/test/regress/expected/window.out
+++ b/src/test/regress/expected/window.out
@@ -4250,14 +4250,14 @@ SELECT 1 FROM
(SELECT ntile(s1.x) OVER () AS c
FROM (SELECT (SELECT 1) AS x) AS s1) s
WHERE s.c = 1;
- QUERY PLAN
-----------------------------------------------------------------
+ QUERY PLAN
+---------------------------------------------------------------------
Subquery Scan on s
Filter: (s.c = 1)
-> WindowAgg
Window: w1 AS (ROWS UNBOUNDED PRECEDING)
- Run Condition: (ntile((InitPlan 1).col1) OVER w1 <= 1)
- InitPlan 1
+ Run Condition: (ntile((InitPlan expr_1).col1) OVER w1 <= 1)
+ InitPlan expr_1
-> Result
-> Result
(8 rows)
@@ -4338,7 +4338,7 @@ WHERE c = 1;
Filter: (emp.c = 1)
-> WindowAgg
Window: w1 AS (ORDER BY empsalary.empno)
- InitPlan 1
+ InitPlan expr_1
-> Result
-> Sort
Sort Key: empsalary.empno DESC
diff --git a/src/test/regress/expected/with.out b/src/test/regress/expected/with.out
index c3932c7b94c..86fdb85c6c5 100644
--- a/src/test/regress/expected/with.out
+++ b/src/test/regress/expected/with.out
@@ -2306,14 +2306,14 @@ explain (verbose, costs off)
select f1, (with cte1(x,y) as (select 1,2)
select count((select i4.f1 from cte1))) as ss
from int4_tbl i4;
- QUERY PLAN
---------------------------------------------
+ QUERY PLAN
+-------------------------------------------------
Seq Scan on public.int4_tbl i4
- Output: i4.f1, (SubPlan 2)
- SubPlan 2
+ Output: i4.f1, (SubPlan expr_1)
+ SubPlan expr_1
-> Aggregate
- Output: count((InitPlan 1).col1)
- InitPlan 1
+ Output: count((InitPlan expr_2).col1)
+ InitPlan expr_2
-> Result
Output: i4.f1
-> Result
@@ -3203,7 +3203,7 @@ WHEN NOT MATCHED THEN INSERT VALUES(o.k, o.v);
Output: o.k, o.v, o.*
-> Result
Output: 0, 'merge source SubPlan'::text
- SubPlan 2
+ SubPlan expr_1
-> Limit
Output: ((cte_basic.b || ' merge update'::text))
-> CTE Scan on cte_basic
@@ -3235,7 +3235,7 @@ WHEN NOT MATCHED THEN INSERT VALUES(o.k, o.v);
CTE cte_init
-> Result
Output: 1, 'cte_init val'::text
- InitPlan 2
+ InitPlan expr_1
-> Limit
Output: ((cte_init.b || ' merge update'::text))
-> CTE Scan on cte_init
@@ -3278,11 +3278,11 @@ WHEN NOT MATCHED THEN INSERT VALUES(o.a, o.b || (SELECT merge_source_cte.*::text
CTE merge_source_cte
-> Result
Output: 15, 'merge_source_cte val'::text
- InitPlan 2
+ InitPlan expr_1
-> CTE Scan on merge_source_cte merge_source_cte_1
Output: ((merge_source_cte_1.b || (merge_source_cte_1.*)::text) || ' merge update'::text)
Filter: (merge_source_cte_1.a = 15)
- InitPlan 3
+ InitPlan expr_2
-> CTE Scan on merge_source_cte merge_source_cte_2
Output: ((merge_source_cte_2.*)::text || ' merge insert'::text)
-> Hash Right Join
--
2.43.7
From b6736b127a93b0203ad8a5ab9dd1514135606517 Mon Sep 17 00:00:00 2001
From: Tom Lane <tgl@sss.pgh.pa.us>
Date: Wed, 24 Sep 2025 17:30:22 -0400
Subject: [PATCH v10 2/2] Use a list of subplan names instead of a list of
"allroots".
I don't like constructing a list of all PlannerInfo roots: it's
partially redundant with the subroots list, and it's far from clear
how to handle transient roots such as the one manufactured by
pull_up_simple_subquery. This patch proposes that we should
instead just store a list of assigned subplan names. One advantage
is that choose_plan_name can immediately enter the new name into
the list, instead of relying on the caller to get it right later.
Apropos to that point, I found that build_minmax_path was putting
the wrong root into the list, so that it was perfectly capable
of assigning "minmax_1" over and over, as indeed is visible in
a couple of incorrect regression test changes in v9-0001.
I remain unsure whether it's OK for pull_up_simple_subquery to just do
+ subroot->plan_name = root->plan_name;
but at least now we won't have two roots with the same plan_name
in the allroots list. There's no way that that's helpful.
Also fix the missed use of choose_plan_name in SS_process_ctes:
without that, we can't really promise that we'll attach unique
names to CTE subplans.
---
src/backend/optimizer/plan/planagg.c | 3 --
src/backend/optimizer/plan/planner.c | 35 ++++++++++++++---------
src/backend/optimizer/plan/subselect.c | 5 ++--
src/backend/optimizer/prep/prepjointree.c | 3 --
src/include/nodes/pathnodes.h | 6 ++--
src/test/regress/expected/aggregates.out | 6 ++--
src/test/regress/expected/inherit.out | 2 +-
7 files changed, 31 insertions(+), 29 deletions(-)
diff --git a/src/backend/optimizer/plan/planagg.c b/src/backend/optimizer/plan/planagg.c
index 0ce35cabaf5..a2ac58d246e 100644
--- a/src/backend/optimizer/plan/planagg.c
+++ b/src/backend/optimizer/plan/planagg.c
@@ -362,9 +362,6 @@ build_minmax_path(PlannerInfo *root, MinMaxAggInfo *mminfo,
/* and we haven't created PlaceHolderInfos, either */
Assert(subroot->placeholder_list == NIL);
- /* Add this to list of all PlannerInfo objects. */
- root->glob->allroots = lappend(root->glob->allroots, root);
-
/*----------
* Generate modified query of the form
* (SELECT col FROM tab
diff --git a/src/backend/optimizer/plan/planner.c b/src/backend/optimizer/plan/planner.c
index acd1356a721..3b130e724f7 100644
--- a/src/backend/optimizer/plan/planner.c
+++ b/src/backend/optimizer/plan/planner.c
@@ -631,6 +631,7 @@ standard_planner(Query *parse, const char *query_string, int cursorOptions,
*
* glob is the global state for the current planner run.
* parse is the querytree produced by the parser & rewriter.
+ * plan_name is the name to assign to this subplan (NULL at the top level).
* parent_root is the immediate parent Query's info (NULL at the top level).
* hasRecursion is true if this is a recursive WITH query.
* tuple_fraction is the fraction of tuples we expect will be retrieved.
@@ -712,9 +713,6 @@ subquery_planner(PlannerGlobal *glob, Query *parse, char *plan_name,
root->non_recursive_path = NULL;
root->partColsUpdated = false;
- /* Add this to list of all PlannerInfo objects. */
- root->glob->allroots = lappend(root->glob->allroots, root);
-
/*
* Create the top-level join domain. This won't have valid contents until
* deconstruct_jointree fills it in, but the node needs to exist before
@@ -8840,7 +8838,9 @@ create_partial_unique_paths(PlannerInfo *root, RelOptInfo *input_rel,
}
/*
- * Choose a unique plan name for subroot.
+ * Choose a unique name for some subroot.
+ *
+ * Modifies glob->subplanNames to track names already used.
*/
char *
choose_plan_name(PlannerGlobal *glob, const char *name, bool always_number)
@@ -8848,18 +8848,17 @@ choose_plan_name(PlannerGlobal *glob, const char *name, bool always_number)
unsigned n;
/*
- * If a numeric suffix is not required, then search the list of roots for
- * a plan with the requested name. If none is found, then we can use the
- * provided name without modification.
+ * If a numeric suffix is not required, then search the list of
+ * previously-assigned names for a match. If none is found, then we can
+ * use the provided name without modification.
*/
if (!always_number)
{
bool found = false;
- foreach_node(PlannerInfo, root, glob->allroots)
+ foreach_ptr(char, subplan_name, glob->subplanNames)
{
- if (root->plan_name != NULL &&
- strcmp(name, root->plan_name) == 0)
+ if (strcmp(subplan_name, name) == 0)
{
found = true;
break;
@@ -8867,7 +8866,13 @@ choose_plan_name(PlannerGlobal *glob, const char *name, bool always_number)
}
if (!found)
- return pstrdup(name);
+ {
+ /* pstrdup here is just to avoid cast-away-const */
+ char *chosen_name = pstrdup(name);
+
+ glob->subplanNames = lappend(glob->subplanNames, chosen_name);
+ return chosen_name;
+ }
}
/*
@@ -8880,10 +8885,9 @@ choose_plan_name(PlannerGlobal *glob, const char *name, bool always_number)
char *proposed_name = psprintf("%s_%u", name, n);
bool found = false;
- foreach_node(PlannerInfo, root, glob->allroots)
+ foreach_ptr(char, subplan_name, glob->subplanNames)
{
- if (root->plan_name != NULL &&
- strcmp(proposed_name, root->plan_name) == 0)
+ if (strcmp(subplan_name, proposed_name) == 0)
{
found = true;
break;
@@ -8891,7 +8895,10 @@ choose_plan_name(PlannerGlobal *glob, const char *name, bool always_number)
}
if (!found)
+ {
+ glob->subplanNames = lappend(glob->subplanNames, proposed_name);
return proposed_name;
+ }
pfree(proposed_name);
}
diff --git a/src/backend/optimizer/plan/subselect.c b/src/backend/optimizer/plan/subselect.c
index 5f8306bc421..14192a13236 100644
--- a/src/backend/optimizer/plan/subselect.c
+++ b/src/backend/optimizer/plan/subselect.c
@@ -967,8 +967,9 @@ SS_process_ctes(PlannerInfo *root)
* Generate Paths for the CTE query. Always plan for full retrieval
* --- we don't have enough info to predict otherwise.
*/
- subroot = subquery_planner(root->glob, subquery, cte->ctename, root,
- cte->cterecursive, 0.0, NULL);
+ subroot = subquery_planner(root->glob, subquery,
+ choose_plan_name(root->glob, cte->ctename, false),
+ root, cte->cterecursive, 0.0, NULL);
/*
* Since the current query level doesn't yet contain any RTEs, it
diff --git a/src/backend/optimizer/prep/prepjointree.c b/src/backend/optimizer/prep/prepjointree.c
index 2ec13637d16..563be151a4d 100644
--- a/src/backend/optimizer/prep/prepjointree.c
+++ b/src/backend/optimizer/prep/prepjointree.c
@@ -1388,9 +1388,6 @@ pull_up_simple_subquery(PlannerInfo *root, Node *jtnode, RangeTblEntry *rte,
subroot->non_recursive_path = NULL;
/* We don't currently need a top JoinDomain for the subroot */
- /* Add new subroot to master list of PlannerInfo objects. */
- root->glob->allroots = lappend(root->glob->allroots, subroot);
-
/* No CTEs to worry about */
Assert(subquery->cteList == NIL);
diff --git a/src/include/nodes/pathnodes.h b/src/include/nodes/pathnodes.h
index a341b01a1e1..7ee9a7a68d8 100644
--- a/src/include/nodes/pathnodes.h
+++ b/src/include/nodes/pathnodes.h
@@ -110,8 +110,8 @@ typedef struct PlannerGlobal
/* PlannerInfos for SubPlan nodes */
List *subroots pg_node_attr(read_write_ignore);
- /* every PlannerInfo regardless of whether it's an InitPlan/SubPlan */
- List *allroots pg_node_attr(read_write_ignore);
+ /* names already used for subplans (list of C strings) */
+ List *subplanNames pg_node_attr(read_write_ignore);
/* indices of subplans that require REWIND */
Bitmapset *rewindPlanIDs;
@@ -231,7 +231,7 @@ struct PlannerInfo
/* NULL at outermost Query */
PlannerInfo *parent_root pg_node_attr(read_write_ignore);
- /* Name for EXPLAIN and debugging purposes */
+ /* Subplan name for EXPLAIN and debugging purposes (NULL at top level) */
char *plan_name;
/*
diff --git a/src/test/regress/expected/aggregates.out b/src/test/regress/expected/aggregates.out
index a9503e810c5..1f84db2f361 100644
--- a/src/test/regress/expected/aggregates.out
+++ b/src/test/regress/expected/aggregates.out
@@ -1269,7 +1269,7 @@ explain (costs off)
-> Index Only Scan Backward using minmaxtest2i on minmaxtest2 minmaxtest_3
Index Cond: (f1 IS NOT NULL)
-> Index Only Scan using minmaxtest3i on minmaxtest3 minmaxtest_4
- InitPlan minmax_1
+ InitPlan minmax_2
-> Limit
-> Merge Append
Sort Key: minmaxtest_5.f1 DESC
@@ -1305,7 +1305,7 @@ explain (costs off)
-> Index Only Scan Backward using minmaxtest2i on minmaxtest2 minmaxtest_3
Index Cond: (f1 IS NOT NULL)
-> Index Only Scan using minmaxtest3i on minmaxtest3 minmaxtest_4
- InitPlan minmax_1
+ InitPlan minmax_2
-> Limit
-> Merge Append
Sort Key: minmaxtest_5.f1 DESC
@@ -1317,7 +1317,7 @@ explain (costs off)
Index Cond: (f1 IS NOT NULL)
-> Index Only Scan Backward using minmaxtest3i on minmaxtest3 minmaxtest_9
-> Sort
- Sort Key: ((InitPlan minmax_1).col1), ((InitPlan minmax_1).col1)
+ Sort Key: ((InitPlan minmax_1).col1), ((InitPlan minmax_2).col1)
-> Result
Replaces: MinMaxAggregate
(27 rows)
diff --git a/src/test/regress/expected/inherit.out b/src/test/regress/expected/inherit.out
index 6dbbd26f56b..0490a746555 100644
--- a/src/test/regress/expected/inherit.out
+++ b/src/test/regress/expected/inherit.out
@@ -3264,7 +3264,7 @@ explain (costs off) select min(a), max(a) from parted_minmax where b = '12345';
-> Limit
-> Index Only Scan using parted_minmax1i on parted_minmax1 parted_minmax
Index Cond: ((a IS NOT NULL) AND (b = '12345'::text))
- InitPlan minmax_1
+ InitPlan minmax_2
-> Limit
-> Index Only Scan Backward using parted_minmax1i on parted_minmax1 parted_minmax_1
Index Cond: ((a IS NOT NULL) AND (b = '12345'::text))
--
2.43.7
pgsql-hackers by date: