From bbf92981fae6bc83e622d87ff18bbc4021a2f6f2 Mon Sep 17 00:00:00 2001 From: Richard Guo Date: Thu, 11 May 2023 17:54:26 +0800 Subject: [PATCH v2] Avoid unnecessary PlaceHolderVars for simple Vars When we pull up a lateral subquery, if a simple Var in subquery's targetlist is lateral reference to something outside the subquery being pulled up, usually we need to wrap it in a PlaceHolderVar. But if the referenced rel is under the same lowest nulling outer join, we can omit the PlaceHolderVar. This patch checks that and avoids unnecessary PHVs. This could be beneficial because such PHVs imply lateral dependencies which makes us have to use nestloop. --- src/backend/optimizer/prep/prepjointree.c | 53 +++++++++++++++++---- src/test/regress/expected/join.out | 58 +++++++++++++++++++++++ src/test/regress/sql/join.sql | 14 ++++++ 3 files changed, 115 insertions(+), 10 deletions(-) diff --git a/src/backend/optimizer/prep/prepjointree.c b/src/backend/optimizer/prep/prepjointree.c index 73ff40721c..b0fda8bd98 100644 --- a/src/backend/optimizer/prep/prepjointree.c +++ b/src/backend/optimizer/prep/prepjointree.c @@ -49,6 +49,9 @@ typedef struct pullup_replace_vars_context RangeTblEntry *target_rte; /* RTE of subquery */ Relids relids; /* relids within subquery, as numbered after * pullup (set only if target_rte->lateral) */ + Relids lowest_nullable_relids; /* relids of the nullable side of the + * lowest outer join subquery is within + * (set only if target_rte->lateral) */ bool *outer_hasSubLinks; /* -> outer query's hasSubLinks */ int varno; /* varno of subquery */ bool wrap_non_vars; /* do we need all non-Var outputs to be PHVs? */ @@ -81,10 +84,12 @@ static Node *pull_up_sublinks_qual_recurse(PlannerInfo *root, Node *node, Node **jtlink2, Relids available_rels2); static Node *pull_up_subqueries_recurse(PlannerInfo *root, Node *jtnode, JoinExpr *lowest_outer_join, + Node *lowest_nullable_side, AppendRelInfo *containing_appendrel); static Node *pull_up_simple_subquery(PlannerInfo *root, Node *jtnode, RangeTblEntry *rte, JoinExpr *lowest_outer_join, + Node *lowest_nullable_side, AppendRelInfo *containing_appendrel); static Node *pull_up_simple_union_all(PlannerInfo *root, Node *jtnode, RangeTblEntry *rte); @@ -772,7 +777,7 @@ pull_up_subqueries(PlannerInfo *root) /* Recursion starts with no containing join nor appendrel */ root->parse->jointree = (FromExpr *) pull_up_subqueries_recurse(root, (Node *) root->parse->jointree, - NULL, NULL); + NULL, NULL, NULL); /* We should still have a FromExpr */ Assert(IsA(root->parse->jointree, FromExpr)); } @@ -787,6 +792,13 @@ pull_up_subqueries(PlannerInfo *root) * lowest_outer_join references the lowest such JoinExpr node; otherwise * it is NULL. We use this to constrain the effects of LATERAL subqueries. * + * If this jointree node is within the nullable side of an outer join, then + * lowest_nullable_side references the nullable side of the lowest such + * JoinExpr node; otherwise it is NULL. We use this to avoid use of the + * PlaceHolderVar mechanism for simple Vars that are lateral references to + * something outside the subquery being pulled up but the referenced rel is + * under the same lowest nulling outer join. + * * If we are looking at a member subquery of an append relation, * containing_appendrel describes that relation; else it is NULL. * This forces use of the PlaceHolderVar mechanism for all non-Var targetlist @@ -803,14 +815,15 @@ pull_up_subqueries(PlannerInfo *root) * Notice also that we can't turn pullup_replace_vars loose on the whole * jointree, because it'd return a mutated copy of the tree; we have to * invoke it just on the quals, instead. This behavior is what makes it - * reasonable to pass lowest_outer_join as a pointer rather than some - * more-indirect way of identifying the lowest OJ. Likewise, we don't - * replace append_rel_list members but only their substructure, so the - * containing_appendrel reference is safe to use. + * reasonable to pass lowest_outer_join and lowest_nullable_side as a + * pointer rather than some more-indirect way of identifying the lowest OJ. + * Likewise, we don't replace append_rel_list members but only their + * substructure, so the containing_appendrel reference is safe to use. */ static Node * pull_up_subqueries_recurse(PlannerInfo *root, Node *jtnode, JoinExpr *lowest_outer_join, + Node *lowest_nullable_side, AppendRelInfo *containing_appendrel) { /* Since this function recurses, it could be driven to stack overflow. */ @@ -837,6 +850,7 @@ pull_up_subqueries_recurse(PlannerInfo *root, Node *jtnode, is_safe_append_member(rte->subquery))) return pull_up_simple_subquery(root, jtnode, rte, lowest_outer_join, + lowest_nullable_side, containing_appendrel); /* @@ -884,6 +898,7 @@ pull_up_subqueries_recurse(PlannerInfo *root, Node *jtnode, { lfirst(l) = pull_up_subqueries_recurse(root, lfirst(l), lowest_outer_join, + lowest_nullable_side, NULL); } } @@ -898,9 +913,11 @@ pull_up_subqueries_recurse(PlannerInfo *root, Node *jtnode, case JOIN_INNER: j->larg = pull_up_subqueries_recurse(root, j->larg, lowest_outer_join, + lowest_nullable_side, NULL); j->rarg = pull_up_subqueries_recurse(root, j->rarg, lowest_outer_join, + lowest_nullable_side, NULL); break; case JOIN_LEFT: @@ -908,25 +925,31 @@ pull_up_subqueries_recurse(PlannerInfo *root, Node *jtnode, case JOIN_ANTI: j->larg = pull_up_subqueries_recurse(root, j->larg, j, + lowest_nullable_side, NULL); j->rarg = pull_up_subqueries_recurse(root, j->rarg, j, + j->rarg, NULL); break; case JOIN_FULL: j->larg = pull_up_subqueries_recurse(root, j->larg, j, + j->larg, NULL); j->rarg = pull_up_subqueries_recurse(root, j->rarg, j, + j->rarg, NULL); break; case JOIN_RIGHT: j->larg = pull_up_subqueries_recurse(root, j->larg, j, + j->larg, NULL); j->rarg = pull_up_subqueries_recurse(root, j->rarg, j, + lowest_nullable_side, NULL); break; default: @@ -956,6 +979,7 @@ pull_up_subqueries_recurse(PlannerInfo *root, Node *jtnode, static Node * pull_up_simple_subquery(PlannerInfo *root, Node *jtnode, RangeTblEntry *rte, JoinExpr *lowest_outer_join, + Node *lowest_nullable_side, AppendRelInfo *containing_appendrel) { Query *parse = root->parse; @@ -1115,10 +1139,20 @@ pull_up_simple_subquery(PlannerInfo *root, Node *jtnode, RangeTblEntry *rte, rvcontext.targetlist = subquery->targetList; rvcontext.target_rte = rte; if (rte->lateral) + { rvcontext.relids = get_relids_in_jointree((Node *) subquery->jointree, true, true); + rvcontext.lowest_nullable_relids = + lowest_nullable_side ? + get_relids_in_jointree(lowest_nullable_side, + true, + true) : NULL; + } else /* won't need relids */ + { rvcontext.relids = NULL; + rvcontext.lowest_nullable_relids = NULL; + } rvcontext.outer_hasSubLinks = &parse->hasSubLinks; rvcontext.varno = varno; /* this flag will be set below, if needed */ @@ -1418,7 +1452,7 @@ pull_up_union_leaf_queries(Node *setOp, PlannerInfo *root, int parentRTindex, rtr = makeNode(RangeTblRef); rtr->rtindex = childRTindex; (void) pull_up_subqueries_recurse(root, (Node *) rtr, - NULL, appinfo); + NULL, NULL, appinfo); } else if (IsA(setOp, SetOperationStmt)) { @@ -2422,12 +2456,11 @@ pullup_replace_vars_callback(Var *var, /* * Simple Vars always escape being wrapped, unless they are * lateral references to something outside the subquery being - * pulled up. (Even then, we could omit the PlaceHolderVar if - * the referenced rel is under the same lowest outer join, but - * it doesn't seem worth the trouble to check that.) + * pulled up and is not under the same lowest outer join. */ if (rcon->target_rte->lateral && - !bms_is_member(((Var *) newnode)->varno, rcon->relids)) + !bms_is_member(((Var *) newnode)->varno, rcon->relids) && + !bms_is_member(((Var *) newnode)->varno, rcon->lowest_nullable_relids)) wrap = true; else wrap = false; diff --git a/src/test/regress/expected/join.out b/src/test/regress/expected/join.out index 9b8638f286..1db755baa6 100644 --- a/src/test/regress/expected/join.out +++ b/src/test/regress/expected/join.out @@ -6766,6 +6766,64 @@ select * from 4567890123456789 | -4567890123456789 | | | (10 rows) +-- lateral reference to simple Var can escape PlaceHolderVar if the +-- referenced rel is under the same lowest nulling outer join +explain (verbose, costs off) +select * from + int8_tbl a left join + (int8_tbl b inner join + lateral (select *, b.q2 as x from int8_tbl c) ss on b.q2 = ss.q1) + on a.q1 = b.q1; + QUERY PLAN +---------------------------------------------------- + Hash Right Join + Output: a.q1, a.q2, b.q1, b.q2, c.q1, c.q2, b.q2 + Hash Cond: (b.q1 = a.q1) + -> Hash Join + Output: b.q1, b.q2, c.q1, c.q2 + Hash Cond: (b.q2 = c.q1) + -> Seq Scan on public.int8_tbl b + Output: b.q1, b.q2 + -> Hash + Output: c.q1, c.q2 + -> Seq Scan on public.int8_tbl c + Output: c.q1, c.q2 + -> Hash + Output: a.q1, a.q2 + -> Seq Scan on public.int8_tbl a + Output: a.q1, a.q2 +(16 rows) + +select * from + int8_tbl a left join + (int8_tbl b inner join + lateral (select *, b.q2 as x from int8_tbl c) ss on b.q2 = ss.q1) + on a.q1 = b.q1; + q1 | q2 | q1 | q2 | q1 | q2 | x +------------------+-------------------+------------------+------------------+------------------+-------------------+------------------ + 123 | 4567890123456789 | 123 | 4567890123456789 | 4567890123456789 | -4567890123456789 | 4567890123456789 + 123 | 456 | 123 | 4567890123456789 | 4567890123456789 | -4567890123456789 | 4567890123456789 + 123 | 4567890123456789 | 123 | 4567890123456789 | 4567890123456789 | 4567890123456789 | 4567890123456789 + 123 | 456 | 123 | 4567890123456789 | 4567890123456789 | 4567890123456789 | 4567890123456789 + 123 | 4567890123456789 | 123 | 4567890123456789 | 4567890123456789 | 123 | 4567890123456789 + 123 | 456 | 123 | 4567890123456789 | 4567890123456789 | 123 | 4567890123456789 + 4567890123456789 | -4567890123456789 | 4567890123456789 | 123 | 123 | 4567890123456789 | 123 + 4567890123456789 | 4567890123456789 | 4567890123456789 | 123 | 123 | 4567890123456789 | 123 + 4567890123456789 | 123 | 4567890123456789 | 123 | 123 | 4567890123456789 | 123 + 4567890123456789 | -4567890123456789 | 4567890123456789 | 123 | 123 | 456 | 123 + 4567890123456789 | 4567890123456789 | 4567890123456789 | 123 | 123 | 456 | 123 + 4567890123456789 | 123 | 4567890123456789 | 123 | 123 | 456 | 123 + 4567890123456789 | -4567890123456789 | 4567890123456789 | 4567890123456789 | 4567890123456789 | -4567890123456789 | 4567890123456789 + 4567890123456789 | 4567890123456789 | 4567890123456789 | 4567890123456789 | 4567890123456789 | -4567890123456789 | 4567890123456789 + 4567890123456789 | 123 | 4567890123456789 | 4567890123456789 | 4567890123456789 | -4567890123456789 | 4567890123456789 + 4567890123456789 | -4567890123456789 | 4567890123456789 | 4567890123456789 | 4567890123456789 | 4567890123456789 | 4567890123456789 + 4567890123456789 | 4567890123456789 | 4567890123456789 | 4567890123456789 | 4567890123456789 | 4567890123456789 | 4567890123456789 + 4567890123456789 | 123 | 4567890123456789 | 4567890123456789 | 4567890123456789 | 4567890123456789 | 4567890123456789 + 4567890123456789 | -4567890123456789 | 4567890123456789 | 4567890123456789 | 4567890123456789 | 123 | 4567890123456789 + 4567890123456789 | 4567890123456789 | 4567890123456789 | 4567890123456789 | 4567890123456789 | 123 | 4567890123456789 + 4567890123456789 | 123 | 4567890123456789 | 4567890123456789 | 4567890123456789 | 123 | 4567890123456789 +(21 rows) + -- lateral can result in join conditions appearing below their -- real semantic level explain (verbose, costs off) diff --git a/src/test/regress/sql/join.sql b/src/test/regress/sql/join.sql index 3e5032b04d..48dd805586 100644 --- a/src/test/regress/sql/join.sql +++ b/src/test/regress/sql/join.sql @@ -2464,6 +2464,20 @@ select * from int8_tbl a left join lateral (select *, coalesce(a.q2, 42) as x from int8_tbl b) ss on a.q2 = ss.q1; +-- lateral reference to simple Var can escape PlaceHolderVar if the +-- referenced rel is under the same lowest nulling outer join +explain (verbose, costs off) +select * from + int8_tbl a left join + (int8_tbl b inner join + lateral (select *, b.q2 as x from int8_tbl c) ss on b.q2 = ss.q1) + on a.q1 = b.q1; +select * from + int8_tbl a left join + (int8_tbl b inner join + lateral (select *, b.q2 as x from int8_tbl c) ss on b.q2 = ss.q1) + on a.q1 = b.q1; + -- lateral can result in join conditions appearing below their -- real semantic level explain (verbose, costs off) -- 2.31.0