Fix LATERAL references to join alias variables.

I had thought this case worked already, but perhaps I didn't re-test it
after adding extract_lateral_references() ...

diff --git a/src/backend/optimizer/plan/planner.c b/src/backend/optimizer/plan/planner.c
index 0540afaced00ce5807e6d8fe56ed5a15397e2272..4284eed47b929f7c9cca8c75bcde3487fc13c65f 100644 (file)
--- a/src/backend/optimizer/plan/planner.c
+++ b/src/backend/optimizer/plan/planner.c
@@ -49,13 +49,15 @@ planner_hook_type planner_hook = NULL;
 
 
 /* Expression kind codes for preprocess_expression */
-#define EXPRKIND_QUAL          0
-#define EXPRKIND_TARGET                1
-#define EXPRKIND_RTFUNC                2
-#define EXPRKIND_VALUES                3
-#define EXPRKIND_LIMIT         4
-#define EXPRKIND_APPINFO       5
-#define EXPRKIND_PHV           6
+#define EXPRKIND_QUAL                  0
+#define EXPRKIND_TARGET                        1
+#define EXPRKIND_RTFUNC                        2
+#define EXPRKIND_RTFUNC_LATERAL        3
+#define EXPRKIND_VALUES                        4
+#define EXPRKIND_VALUES_LATERAL        5
+#define EXPRKIND_LIMIT                 6
+#define EXPRKIND_APPINFO               7
+#define EXPRKIND_PHV                   8
 
 
 static Node *preprocess_expression(PlannerInfo *root, Node *expr, int kind);
@@ -438,18 +440,38 @@ subquery_planner(PlannerGlobal *glob, Query *parse,
                preprocess_expression(root, (Node *) root->append_rel_list,
                                                          EXPRKIND_APPINFO);
 
-       /* Also need to preprocess expressions for function and values RTEs */
+       /* Also need to preprocess expressions within RTEs */
        foreach(l, parse->rtable)
        {
                RangeTblEntry *rte = (RangeTblEntry *) lfirst(l);
+               int                     kind;
 
-               if (rte->rtekind == RTE_FUNCTION)
-                       rte->funcexpr = preprocess_expression(root, rte->funcexpr,
-                                                                                                 EXPRKIND_RTFUNC);
+               if (rte->rtekind == RTE_SUBQUERY)
+               {
+                       /*
+                        * We don't want to do all preprocessing yet on the subquery's
+                        * expressions, since that will happen when we plan it.  But if it
+                        * contains any join aliases of our level, those have to get
+                        * expanded now, because planning of the subquery won't do it.
+                        * That's only possible if the subquery is LATERAL.
+                        */
+                       if (rte->lateral && root->hasJoinRTEs)
+                               rte->subquery = (Query *)
+                                       flatten_join_alias_vars(root, (Node *) rte->subquery);
+               }
+               else if (rte->rtekind == RTE_FUNCTION)
+               {
+                       /* Preprocess the function expression fully */
+                       kind = rte->lateral ? EXPRKIND_RTFUNC_LATERAL : EXPRKIND_RTFUNC;
+                       rte->funcexpr = preprocess_expression(root, rte->funcexpr, kind);
+               }
                else if (rte->rtekind == RTE_VALUES)
+               {
+                       /* Preprocess the values lists fully */
+                       kind = rte->lateral ? EXPRKIND_VALUES_LATERAL : EXPRKIND_VALUES;
                        rte->values_lists = (List *)
-                               preprocess_expression(root, (Node *) rte->values_lists,
-                                                                         EXPRKIND_VALUES);
+                               preprocess_expression(root, (Node *) rte->values_lists, kind);
+               }
        }
 
        /*
@@ -593,12 +615,13 @@ preprocess_expression(PlannerInfo *root, Node *expr, int kind)
 
        /*
         * If the query has any join RTEs, replace join alias variables with
-        * base-relation variables. We must do this before sublink processing,
-        * else sublinks expanded out from join aliases wouldn't get processed. We
-        * can skip it in VALUES lists, however, since they can't contain any Vars
-        * at all.
+        * base-relation variables.  We must do this before sublink processing,
+        * else sublinks expanded out from join aliases would not get processed.
+        * We can skip it in non-lateral RTE functions and VALUES lists, however,
+        * since they can't contain any Vars of the current query level.
         */
-       if (root->hasJoinRTEs && kind != EXPRKIND_VALUES)
+       if (root->hasJoinRTEs &&
+               !(kind == EXPRKIND_RTFUNC || kind == EXPRKIND_VALUES))
                expr = flatten_join_alias_vars(root, expr);
 
        /*

diff --git a/src/backend/optimizer/util/var.c b/src/backend/optimizer/util/var.c
index a0668c9615be7dccdc39c3acb53ccad1d3204127..db9a1164ad31ab6a9aa9f6b8c63025f9aeced646 100644 (file)
--- a/src/backend/optimizer/util/var.c
+++ b/src/backend/optimizer/util/var.c
@@ -600,7 +600,9 @@ pull_var_clause_walker(Node *node, pull_var_clause_context *context)
  * hasSubLinks = TRUE, so this is only relevant to un-flattened subqueries.
  *
  * NOTE: this is used on not-yet-planned expressions.  We do not expect it
- * to be applied directly to a Query node.
+ * to be applied directly to the whole Query, so if we see a Query to start
+ * with, we do want to increment sublevels_up (this occurs for LATERAL
+ * subqueries).
  */
 Node *
 flatten_join_alias_vars(PlannerInfo *root, Node *node)

diff --git a/src/test/regress/expected/join.out b/src/test/regress/expected/join.out
index c2e83d7f8bbb1663714b459539349d9f22855662..7c1ab4486151fe5ed96656c0c23fd3f0fae8f14d 100644 (file)
--- a/src/test/regress/expected/join.out
+++ b/src/test/regress/expected/join.out
@@ -3242,6 +3242,32 @@ select * from int8_tbl a,
  4567890123456789 | -4567890123456789 | 4567890123456789 | -4567890123456789 |                 
 (57 rows)
 
+-- lateral reference to a join alias variable
+select * from (select f1/2 as x from int4_tbl) ss1 join int4_tbl i4 on x = f1,
+  lateral (select x) ss2(y);
+ x | f1 | y 
+---+----+---
+ 0 |  0 | 0
+(1 row)
+
+select * from (select f1 as x from int4_tbl) ss1 join int4_tbl i4 on x = f1,
+  lateral (values(x)) ss2(y);
+      x      |     f1      |      y      
+-------------+-------------+-------------
+           0 |           0 |           0
+      123456 |      123456 |      123456
+     -123456 |     -123456 |     -123456
+  2147483647 |  2147483647 |  2147483647
+ -2147483647 | -2147483647 | -2147483647
+(5 rows)
+
+select * from ((select f1/2 as x from int4_tbl) ss1 join int4_tbl i4 on x = f1) j,
+  lateral (select x) ss2(y);
+ x | f1 | y 
+---+----+---
+ 0 |  0 | 0
+(1 row)
+
 -- lateral references requiring pullup
 select * from (values(1)) x(lb),
   lateral generate_series(lb,4) x4;

diff --git a/src/test/regress/sql/join.sql b/src/test/regress/sql/join.sql
index 24553045da1d5c1812c2ca408ebfbe28e427505a..2213a446a3ddd7136d802fe016e4156eca02b17c 100644 (file)
--- a/src/test/regress/sql/join.sql
+++ b/src/test/regress/sql/join.sql
@@ -901,6 +901,14 @@ select * from int8_tbl a,
   int8_tbl x left join lateral (select a.q1 from int4_tbl y) ss(z)
     on x.q2 = ss.z;
 
+-- lateral reference to a join alias variable
+select * from (select f1/2 as x from int4_tbl) ss1 join int4_tbl i4 on x = f1,
+  lateral (select x) ss2(y);
+select * from (select f1 as x from int4_tbl) ss1 join int4_tbl i4 on x = f1,
+  lateral (values(x)) ss2(y);
+select * from ((select f1/2 as x from int4_tbl) ss1 join int4_tbl i4 on x = f1) j,
+  lateral (select x) ss2(y);
+
 -- lateral references requiring pullup
 select * from (values(1)) x(lb),
   lateral generate_series(lb,4) x4;