Fix "failed to find plan for subquery/CTE" errors in EXPLAIN.

To deparse a reference to a field of a RECORD-type output of a
subquery, EXPLAIN normally digs down into the subquery's plan to try
to discover exactly which anonymous RECORD type is meant.  However,
this can fail if the subquery has been optimized out of the plan
altogether on the grounds that no rows could pass the WHERE quals,
which has been possible at least since 3fc6e2d7f.  There isn't
anything remaining in the plan tree that would help us, so fall back
to printing the field name as "fN" for the N'th column of the record.
(This will actually be the right thing some of the time, since it
matches the column names we assign to RowExprs.)

In passing, fix a comment typo in create_projection_plan, which
I noticed while experimenting with an alternative fix for this.

Per bug #18576 from Vasya B.  Back-patch to all supported branches.

Richard Guo and Tom Lane

Discussion: https://postgr.es/m/18576-9feac34e132fea9e@postgresql.org

diff --git a/src/backend/optimizer/plan/createplan.c b/src/backend/optimizer/plan/createplan.c
index 974c50b29f9b5c47e7489083e4b64b9ec0c69b0b..1d9423abdc81b383b6c80689f8f58aba492883f4 100644 (file)
--- a/src/backend/optimizer/plan/createplan.c
+++ b/src/backend/optimizer/plan/createplan.c
@@ -2006,7 +2006,7 @@ create_projection_plan(PlannerInfo *root, ProjectionPath *best_path, int flags)
     * Convert our subpath to a Plan and determine whether we need a Result
     * node.
     *
-    * In most cases where we don't need to project, creation_projection_path
+    * In most cases where we don't need to project, create_projection_path
     * will have set dummypp, but not always.  First, some createplan.c
     * routines change the tlists of their nodes.  (An example is that
     * create_merge_append_plan might add resjunk sort columns to a

diff --git a/src/backend/utils/adt/ruleutils.c b/src/backend/utils/adt/ruleutils.c
index f01cc2521c8001ca842bca01a95fc3974dd28866..1168b5ba6c3e76ecd5718a067a6209b8c7f29a59 100644 (file)
--- a/src/backend/utils/adt/ruleutils.c
+++ b/src/backend/utils/adt/ruleutils.c
@@ -7839,17 +7839,31 @@ get_name_for_var_field(Var *var, int fieldno,
                    /*
                     * We're deparsing a Plan tree so we don't have complete
                     * RTE entries (in particular, rte->subquery is NULL). But
-                    * the only place we'd see a Var directly referencing a
-                    * SUBQUERY RTE is in a SubqueryScan plan node, and we can
-                    * look into the child plan's tlist instead.
+                    * the only place we'd normally see a Var directly
+                    * referencing a SUBQUERY RTE is in a SubqueryScan plan
+                    * node, and we can look into the child plan's tlist
+                    * instead.  An exception occurs if the subquery was
+                    * proven empty and optimized away: then we'd find such a
+                    * Var in a childless Result node, and there's nothing in
+                    * the plan tree that would let us figure out what it had
+                    * originally referenced.  In that case, fall back on
+                    * printing "fN", analogously to the default column names
+                    * for RowExprs.
                     */
                    TargetEntry *tle;
                    deparse_namespace save_dpns;
                    const char *result;
 
                    if (!dpns->inner_plan)
-                       elog(ERROR, "failed to find plan for subquery %s",
-                            rte->eref->aliasname);
+                   {
+                       char       *dummy_name = palloc(32);
+
+                       Assert(IsA(dpns->plan, Result));
+                       snprintf(dummy_name, 32, "f%d", fieldno);
+                       return dummy_name;
+                   }
+                   Assert(IsA(dpns->plan, SubqueryScan));
+
                    tle = get_tle_by_resno(dpns->inner_tlist, attnum);
                    if (!tle)
                        elog(ERROR, "bogus varattno for subquery var: %d",
@@ -7958,20 +7972,30 @@ get_name_for_var_field(Var *var, int fieldno,
                {
                    /*
                     * We're deparsing a Plan tree so we don't have a CTE
-                    * list.  But the only places we'd see a Var directly
-                    * referencing a CTE RTE are in CteScan or WorkTableScan
-                    * plan nodes.  For those cases, set_deparse_plan arranged
-                    * for dpns->inner_plan to be the plan node that emits the
-                    * CTE or RecursiveUnion result, and we can look at its
-                    * tlist instead.
+                    * list.  But the only places we'd normally see a Var
+                    * directly referencing a CTE RTE are in CteScan or
+                    * WorkTableScan plan nodes.  For those cases,
+                    * set_deparse_plan arranged for dpns->inner_plan to be
+                    * the plan node that emits the CTE or RecursiveUnion
+                    * result, and we can look at its tlist instead.  As
+                    * above, this can fail if the CTE has been proven empty,
+                    * in which case fall back to "fN".
                     */
                    TargetEntry *tle;
                    deparse_namespace save_dpns;
                    const char *result;
 
                    if (!dpns->inner_plan)
-                       elog(ERROR, "failed to find plan for CTE %s",
-                            rte->eref->aliasname);
+                   {
+                       char       *dummy_name = palloc(32);
+
+                       Assert(IsA(dpns->plan, Result));
+                       snprintf(dummy_name, 32, "f%d", fieldno);
+                       return dummy_name;
+                   }
+                   Assert(IsA(dpns->plan, CteScan) ||
+                          IsA(dpns->plan, WorkTableScan));
+
                    tle = get_tle_by_resno(dpns->inner_tlist, attnum);
                    if (!tle)
                        elog(ERROR, "bogus varattno for subquery var: %d",

diff --git a/src/test/regress/expected/rowtypes.out b/src/test/regress/expected/rowtypes.out
index 8f3c153bac24533dec0381a23df33ec1e868bb62..f019d11cd7e73f9e55186b2789891676eca13bb1 100644 (file)
--- a/src/test/regress/expected/rowtypes.out
+++ b/src/test/regress/expected/rowtypes.out
@@ -1300,6 +1300,60 @@ select pg_get_viewdef('composite_v', true);
 (1 row)
 
 drop view composite_v;
+--
+-- Check cases where the composite comes from a proven-dummy rel (bug #18576)
+--
+explain (verbose, costs off)
+select (ss.a).x, (ss.a).n from
+  (select information_schema._pg_expandarray(array[1,2]) AS a) ss;
+                               QUERY PLAN                               
+------------------------------------------------------------------------
+ Subquery Scan on ss
+   Output: (ss.a).x, (ss.a).n
+   ->  ProjectSet
+         Output: information_schema._pg_expandarray('{1,2}'::integer[])
+         ->  Result
+(5 rows)
+
+explain (verbose, costs off)
+select (ss.a).x, (ss.a).n from
+  (select information_schema._pg_expandarray(array[1,2]) AS a) ss
+where false;
+        QUERY PLAN        
+--------------------------
+ Result
+   Output: (a).f1, (a).f2
+   One-Time Filter: false
+(3 rows)
+
+explain (verbose, costs off)
+with cte(c) as materialized (select row(1, 2)),
+     cte2(c) as (select * from cte)
+select (c).f1 from cte2 as t;
+            QUERY PLAN             
+-----------------------------------
+ CTE Scan on cte
+   Output: (cte.c).f1
+   CTE cte
+     ->  Result
+           Output: '(1,2)'::record
+(5 rows)
+
+explain (verbose, costs off)
+with cte(c) as materialized (select row(1, 2)),
+     cte2(c) as (select * from cte)
+select (c).f1 from cte2 as t
+where false;
+            QUERY PLAN             
+-----------------------------------
+ Result
+   Output: (cte.c).f1
+   One-Time Filter: false
+   CTE cte
+     ->  Result
+           Output: '(1,2)'::record
+(6 rows)
+
 --
 -- Tests for component access / FieldSelect
 --

diff --git a/src/test/regress/sql/rowtypes.sql b/src/test/regress/sql/rowtypes.sql
index fd47dc9e0f674ec5d6c0dbf5352df73f01cf7ba1..174b062144a2d31395181037eec697a5beeb1de6 100644 (file)
--- a/src/test/regress/sql/rowtypes.sql
+++ b/src/test/regress/sql/rowtypes.sql
@@ -520,6 +520,27 @@ where (select * from (select c as c1) s
 select pg_get_viewdef('composite_v', true);
 drop view composite_v;
 
+--
+-- Check cases where the composite comes from a proven-dummy rel (bug #18576)
+--
+explain (verbose, costs off)
+select (ss.a).x, (ss.a).n from
+  (select information_schema._pg_expandarray(array[1,2]) AS a) ss;
+explain (verbose, costs off)
+select (ss.a).x, (ss.a).n from
+  (select information_schema._pg_expandarray(array[1,2]) AS a) ss
+where false;
+
+explain (verbose, costs off)
+with cte(c) as materialized (select row(1, 2)),
+     cte2(c) as (select * from cte)
+select (c).f1 from cte2 as t;
+explain (verbose, costs off)
+with cte(c) as materialized (select row(1, 2)),
+     cte2(c) as (select * from cte)
+select (c).f1 from cte2 as t
+where false;
+
 --
 -- Tests for component access / FieldSelect
 --