Expand virtual generated columns before sublink pull-up

Currently, we expand virtual generated columns after we have pulled up
any SubLinks within the query's quals.  This ensures that the virtual
generated column references within SubLinks that should be transformed
into joins are correctly expanded.  This approach works well and has
posed no issues.

In an upcoming patch, we plan to centralize the collection of catalog
information needed early in the planner.  This will help avoid
repeated table_open/table_close calls for relations in the rangetable.
Since this information is required during sublink pull-up, we are
moving the expansion of virtual generated columns to occur beforehand.

To achieve this, if any EXISTS SubLinks can be pulled up, their
rangetables are processed just before pulling them up.

Author: Richard Guo <guofenglinux@gmail.com>
Reviewed-by: Robert Haas <robertmhaas@gmail.com>
Reviewed-by: Tom Lane <tgl@sss.pgh.pa.us>
Discussion: http://postgr.es/m/CAMbWs4-bFJ1At4btk5wqbezdu8PLtQ3zv-aiaY3ry9Ymm=jgFQ@mail.gmail.com

diff --git a/src/backend/optimizer/plan/planner.c b/src/backend/optimizer/plan/planner.c
index 549aedcfa991adf5d3f242e6389c2234c4b8d07f..fbbc42f160081446bdff81f081c49bfd410193c1 100644 (file)
--- a/src/backend/optimizer/plan/planner.c
+++ b/src/backend/optimizer/plan/planner.c
@@ -720,6 +720,15 @@ subquery_planner(PlannerGlobal *glob, Query *parse, PlannerInfo *parent_root,
     */
    transform_MERGE_to_join(parse);
 
+   /*
+    * Scan the rangetable for relations with virtual generated columns, and
+    * replace all Var nodes in the query that reference these columns with
+    * the generation expressions.  Note that this step does not descend into
+    * sublinks and subqueries; if we pull up any sublinks or subqueries
+    * below, their rangetables are processed just before pulling them up.
+    */
+   parse = root->parse = expand_virtual_generated_columns(root);
+
    /*
     * If the FROM clause is empty, replace it with a dummy RTE_RESULT RTE, so
     * that we don't need so many special cases to deal with that situation.
@@ -743,14 +752,6 @@ subquery_planner(PlannerGlobal *glob, Query *parse, PlannerInfo *parent_root,
     */
    preprocess_function_rtes(root);
 
-   /*
-    * Scan the rangetable for relations with virtual generated columns, and
-    * replace all Var nodes in the query that reference these columns with
-    * the generation expressions.  Recursion issues here are handled in the
-    * same way as for SubLinks.
-    */
-   parse = root->parse = expand_virtual_generated_columns(root);
-
    /*
     * Check to see if any subqueries in the jointree can be merged into this
     * query.

diff --git a/src/backend/optimizer/plan/subselect.c b/src/backend/optimizer/plan/subselect.c
index e7cb3fede665801250fc177443e8af297af175dd..575303b294a996f0ead7fe38da7783157b096008 100644 (file)
--- a/src/backend/optimizer/plan/subselect.c
+++ b/src/backend/optimizer/plan/subselect.c
@@ -1454,6 +1454,7 @@ convert_EXISTS_sublink_to_join(PlannerInfo *root, SubLink *sublink,
    Query      *parse = root->parse;
    Query      *subselect = (Query *) sublink->subselect;
    Node       *whereClause;
+   PlannerInfo subroot;
    int         rtoffset;
    int         varno;
    Relids      clause_varnos;
@@ -1515,6 +1516,32 @@ convert_EXISTS_sublink_to_join(PlannerInfo *root, SubLink *sublink,
    if (contain_volatile_functions(whereClause))
        return NULL;
 
+   /*
+    * Scan the rangetable for relations with virtual generated columns, and
+    * replace all Var nodes in the subquery that reference these columns with
+    * the generation expressions.
+    *
+    * Note: we construct up an entirely dummy PlannerInfo for use here.  This
+    * is fine because only the "glob" and "parse" links will be used in this
+    * case.
+    *
+    * Note: we temporarily assign back the WHERE clause so that any virtual
+    * generated column references within it can be expanded.  It should be
+    * separated out again afterward.
+    */
+   MemSet(&subroot, 0, sizeof(subroot));
+   subroot.type = T_PlannerInfo;
+   subroot.glob = root->glob;
+   subroot.parse = subselect;
+   subselect->jointree->quals = whereClause;
+   subselect = expand_virtual_generated_columns(&subroot);
+
+   /*
+    * Now separate out the WHERE clause again.
+    */
+   whereClause = subselect->jointree->quals;
+   subselect->jointree->quals = NULL;
+
    /*
     * The subquery must have a nonempty jointree, but we can make it so.
     */

diff --git a/src/backend/optimizer/prep/prepjointree.c b/src/backend/optimizer/prep/prepjointree.c
index 87dc6f56b576f9bceb1eead511917168bc6f9457..8140d22de703cde81ef574a94a058931772ee8a5 100644 (file)
--- a/src/backend/optimizer/prep/prepjointree.c
+++ b/src/backend/optimizer/prep/prepjointree.c
@@ -4,10 +4,10 @@
  *   Planner preprocessing for subqueries and join tree manipulation.
  *
  * NOTE: the intended sequence for invoking these operations is
+ *     expand_virtual_generated_columns
  *     replace_empty_jointree
  *     pull_up_sublinks
  *     preprocess_function_rtes
- *     expand_virtual_generated_columns
  *     pull_up_subqueries
  *     flatten_simple_union_all
  *     do expression preprocessing (including flattening JOIN alias vars)
@@ -958,10 +958,6 @@ preprocess_function_rtes(PlannerInfo *root)
  * generation expressions.  Note that we do not descend into subqueries; that
  * is taken care of when the subqueries are planned.
  *
- * This has to be done after we have pulled up any SubLinks within the query's
- * quals; otherwise any virtual generated column references within the SubLinks
- * that should be transformed into joins wouldn't get expanded.
- *
  * Returns a modified copy of the query tree, if any relations with virtual
  * generated columns are present.
  */
@@ -1333,6 +1329,13 @@ pull_up_simple_subquery(PlannerInfo *root, Node *jtnode, RangeTblEntry *rte,
    /* No CTEs to worry about */
    Assert(subquery->cteList == NIL);
 
+   /*
+    * Scan the rangetable for relations with virtual generated columns, and
+    * replace all Var nodes in the subquery that reference these columns with
+    * the generation expressions.
+    */
+   subquery = subroot->parse = expand_virtual_generated_columns(subroot);
+
    /*
     * If the FROM clause is empty, replace it with a dummy RTE_RESULT RTE, so
     * that we don't need so many special cases to deal with that situation.
@@ -1352,13 +1355,6 @@ pull_up_simple_subquery(PlannerInfo *root, Node *jtnode, RangeTblEntry *rte,
     */
    preprocess_function_rtes(subroot);
 
-   /*
-    * Scan the rangetable for relations with virtual generated columns, and
-    * replace all Var nodes in the query that reference these columns with
-    * the generation expressions.
-    */
-   subquery = subroot->parse = expand_virtual_generated_columns(subroot);
-
    /*
     * Recursively pull up the subquery's subqueries, so that
     * pull_up_subqueries' processing is complete for its jointree and

diff --git a/src/include/optimizer/prep.h b/src/include/optimizer/prep.h
index df56202777c7f510e63021d19752c53670a83408..ceb731bcf5ef63f4f7bfa20ad17e228da43bfcfa 100644 (file)
--- a/src/include/optimizer/prep.h
+++ b/src/include/optimizer/prep.h
@@ -22,10 +22,10 @@
  * prototypes for prepjointree.c
  */
 extern void transform_MERGE_to_join(Query *parse);
+extern Query *expand_virtual_generated_columns(PlannerInfo *root);
 extern void replace_empty_jointree(Query *parse);
 extern void pull_up_sublinks(PlannerInfo *root);
 extern void preprocess_function_rtes(PlannerInfo *root);
-extern Query *expand_virtual_generated_columns(PlannerInfo *root);
 extern void pull_up_subqueries(PlannerInfo *root);
 extern void flatten_simple_union_all(PlannerInfo *root);
 extern void reduce_outer_joins(PlannerInfo *root);

diff --git a/src/test/regress/expected/generated_virtual.out b/src/test/regress/expected/generated_virtual.out
index 3b40e15a95ad03b5b50cdb29509a29cfb5750201..a635cb1e7760ba7668101a3218732ac4e0840a85 100644 (file)
--- a/src/test/regress/expected/generated_virtual.out
+++ b/src/test/regress/expected/generated_virtual.out
@@ -1613,4 +1613,26 @@ select * from gtest32 t group by grouping sets (a, b, c, d, e) having c = 20;
 
 -- Ensure that the virtual generated columns in ALTER COLUMN TYPE USING expression are expanded
 alter table gtest32 alter column e type bigint using b;
+-- Ensure that virtual generated column references within SubLinks that should
+-- be transformed into joins can get expanded
+explain (costs off)
+select 1 from gtest32 t1 where exists
+  (select 1 from gtest32 t2 where t1.a > t2.a and t2.b = 2);
+             QUERY PLAN              
+-------------------------------------
+ Nested Loop Semi Join
+   Join Filter: (t1.a > t2.a)
+   ->  Seq Scan on gtest32 t1
+   ->  Materialize
+         ->  Seq Scan on gtest32 t2
+               Filter: ((a * 2) = 2)
+(6 rows)
+
+select 1 from gtest32 t1 where exists
+  (select 1 from gtest32 t2 where t1.a > t2.a and t2.b = 2);
+ ?column? 
+----------
+        1
+(1 row)
+
 drop table gtest32;

diff --git a/src/test/regress/sql/generated_virtual.sql b/src/test/regress/sql/generated_virtual.sql
index e2b31853e0132a5650391dfaaf1b160e701f9fea..ba19bc4c701e06320aae01ee8c86496ef994343c 100644 (file)
--- a/src/test/regress/sql/generated_virtual.sql
+++ b/src/test/regress/sql/generated_virtual.sql
@@ -858,4 +858,13 @@ select * from gtest32 t group by grouping sets (a, b, c, d, e) having c = 20;
 -- Ensure that the virtual generated columns in ALTER COLUMN TYPE USING expression are expanded
 alter table gtest32 alter column e type bigint using b;
 
+-- Ensure that virtual generated column references within SubLinks that should
+-- be transformed into joins can get expanded
+explain (costs off)
+select 1 from gtest32 t1 where exists
+  (select 1 from gtest32 t2 where t1.a > t2.a and t2.b = 2);
+
+select 1 from gtest32 t1 where exists
+  (select 1 from gtest32 t2 where t1.a > t2.a and t2.b = 2);
+
 drop table gtest32;