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 f91562cbea342bc0dc16604f1fb279c1589fd702..f23326a1c519adda8e2901ab1e7837b62e6fc29f 100644 (file)
--- a/src/backend/optimizer/plan/createplan.c
+++ b/src/backend/optimizer/plan/createplan.c
@@ -2015,7 +2015,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 a4277719aadc1732d026ccc5ee46813194a41dc5..f5e6ad694220dfb05c5c049be2c3376eb8c0a27f 100644 (file)
--- a/src/backend/utils/adt/ruleutils.c
+++ b/src/backend/utils/adt/ruleutils.c
@@ -7878,17 +7878,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",
@@ -7997,20 +8011,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 52de8b2de8498dbf10102c1f36e49401e7b2b8f4..9660371e8ba3a957d51f64ac8f2a69e881e22207 100644 (file)
--- a/src/test/regress/expected/rowtypes.out
+++ b/src/test/regress/expected/rowtypes.out
@@ -1269,6 +1269,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 da2e74d8a598d28bb1ae8f68c44f00a90dc91daf..76e4ca58d47935f95f369b37d681a7ddcdf978e0 100644 (file)
--- a/src/test/regress/sql/rowtypes.sql
+++ b/src/test/regress/sql/rowtypes.sql
@@ -513,6 +513,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
 --