else if (IsA(node, PlaceHolderVar))
{
PlaceHolderVar *phv = (PlaceHolderVar *) node;
- PlaceHolderInfo *phinfo = find_placeholder_info(root, phv);
+ PlaceHolderInfo *phinfo = find_placeholder_info(root, phv, false);
tuple_width += phinfo->ph_width;
}
List *vars = pull_var_clause((Node *) cur_em->em_expr,
PVC_INCLUDE_PLACEHOLDERS);
- add_vars_to_targetlist(root, vars, ec->ec_relids);
+ add_vars_to_targetlist(root, vars, ec->ec_relids, false);
list_free(vars);
}
}
if (tlist_vars != NIL)
{
- add_vars_to_targetlist(root, tlist_vars, bms_make_singleton(0));
+ add_vars_to_targetlist(root, tlist_vars, bms_make_singleton(0), true);
list_free(tlist_vars);
}
}
*
* The list may also contain PlaceHolderVars. These don't necessarily
* have a single owning relation; we keep their attr_needed info in
- * root->placeholder_list instead.
+ * root->placeholder_list instead. If create_new_ph is true, it's OK
+ * to create new PlaceHolderInfos, and we also have to update ph_may_need;
+ * otherwise, the PlaceHolderInfos must already exist, and we should only
+ * update their ph_needed. (It should be true before deconstruct_jointree
+ * begins, and false after that.)
*/
void
-add_vars_to_targetlist(PlannerInfo *root, List *vars, Relids where_needed)
+add_vars_to_targetlist(PlannerInfo *root, List *vars,
+ Relids where_needed, bool create_new_ph)
{
ListCell *temp;
else if (IsA(node, PlaceHolderVar))
{
PlaceHolderVar *phv = (PlaceHolderVar *) node;
- PlaceHolderInfo *phinfo = find_placeholder_info(root, phv);
+ PlaceHolderInfo *phinfo = find_placeholder_info(root, phv,
+ create_new_ph);
+ /* Always adjust ph_needed */
phinfo->ph_needed = bms_add_members(phinfo->ph_needed,
where_needed);
/*
- * Update ph_may_need too. This is currently only necessary
- * when being called from build_base_rel_tlists, but we may as
- * well do it always.
+ * If we are creating PlaceHolderInfos, mark them with the
+ * correct maybe-needed locations. Otherwise, it's too late to
+ * change that.
*/
- phinfo->ph_may_need = bms_add_members(phinfo->ph_may_need,
- where_needed);
+ if (create_new_ph)
+ mark_placeholder_maybe_needed(root, phinfo, where_needed);
}
else
elog(ERROR, "unrecognized node type: %d", (int) nodeTag(node));
{
List *vars = pull_var_clause(clause, PVC_INCLUDE_PLACEHOLDERS);
- add_vars_to_targetlist(root, vars, relids);
+ add_vars_to_targetlist(root, vars, relids, false);
list_free(vars);
}
/* Local functions */
static Relids find_placeholders_recurse(PlannerInfo *root, Node *jtnode);
-static void find_placeholders_in_qual(PlannerInfo *root, Node *qual,
- Relids relids);
+static void mark_placeholders_in_expr(PlannerInfo *root, Node *expr,
+ Relids relids);
/*
/*
* find_placeholder_info
- * Fetch the PlaceHolderInfo for the given PHV; create it if not found
+ * Fetch the PlaceHolderInfo for the given PHV
+ *
+ * If the PlaceHolderInfo doesn't exist yet, create it if create_new_ph is
+ * true, else throw an error.
*
* This is separate from make_placeholder_expr because subquery pullup has
* to make PlaceHolderVars for expressions that might not be used at all in
* We build PlaceHolderInfos only for PHVs that are still present in the
* simplified query passed to query_planner().
*
- * Note: this should only be called after query_planner() has started.
+ * Note: this should only be called after query_planner() has started. Also,
+ * create_new_ph must not be TRUE after deconstruct_jointree begins, because
+ * make_outerjoininfo assumes that we already know about all placeholders.
*/
PlaceHolderInfo *
-find_placeholder_info(PlannerInfo *root, PlaceHolderVar *phv)
+find_placeholder_info(PlannerInfo *root, PlaceHolderVar *phv,
+ bool create_new_ph)
{
PlaceHolderInfo *phinfo;
ListCell *lc;
}
/* Not found, so create it */
+ if (!create_new_ph)
+ elog(ERROR, "too late to create a new PlaceHolderInfo");
+
phinfo = makeNode(PlaceHolderInfo);
phinfo->phid = phv->phid;
/*
* Now process the top-level quals.
*/
- find_placeholders_in_qual(root, f->quals, jtrelids);
+ mark_placeholders_in_expr(root, f->quals, jtrelids);
}
else if (IsA(jtnode, JoinExpr))
{
jtrelids = bms_join(leftids, rightids);
/* Process the qual clauses */
- find_placeholders_in_qual(root, j->quals, jtrelids);
+ mark_placeholders_in_expr(root, j->quals, jtrelids);
}
else
{
}
/*
- * find_placeholders_in_qual
- * Process a qual clause for find_placeholders_in_jointree.
+ * mark_placeholders_in_expr
+ * Find all PlaceHolderVars in the given expression, and mark them
+ * as possibly needed at the specified join level.
*
* relids is the syntactic join level to mark as the "maybe needed" level
- * for each PlaceHolderVar found in the qual clause.
+ * for each PlaceHolderVar found in the expression.
*/
static void
-find_placeholders_in_qual(PlannerInfo *root, Node *qual, Relids relids)
+mark_placeholders_in_expr(PlannerInfo *root, Node *expr, Relids relids)
{
List *vars;
ListCell *vl;
* pull_var_clause does more than we need here, but it'll do and it's
* convenient to use.
*/
- vars = pull_var_clause(qual, PVC_INCLUDE_PLACEHOLDERS);
+ vars = pull_var_clause(expr, PVC_INCLUDE_PLACEHOLDERS);
foreach(vl, vars)
{
PlaceHolderVar *phv = (PlaceHolderVar *) lfirst(vl);
continue;
/* Create a PlaceHolderInfo entry if there's not one already */
- phinfo = find_placeholder_info(root, phv);
-
- /* Mark the PHV as possibly needed at the qual's syntactic level */
- phinfo->ph_may_need = bms_add_members(phinfo->ph_may_need, relids);
+ phinfo = find_placeholder_info(root, phv, true);
- /*
- * This is a bit tricky: the PHV's contained expression may contain
- * other, lower-level PHVs. We need to get those into the
- * PlaceHolderInfo list, but they aren't going to be needed where the
- * outer PHV is referenced. Rather, they'll be needed where the outer
- * PHV is evaluated. We can estimate that (conservatively) as the
- * syntactic location of the PHV's expression. Recurse to take care
- * of any such PHVs.
- */
- find_placeholders_in_qual(root, (Node *) phv->phexpr, phv->phrels);
+ /* Mark it, and recursively process any contained placeholders */
+ mark_placeholder_maybe_needed(root, phinfo, relids);
}
list_free(vars);
}
+/*
+ * mark_placeholder_maybe_needed
+ * Mark a placeholder as possibly needed at the specified join level.
+ *
+ * relids is the syntactic join level to mark as the "maybe needed" level
+ * for the placeholder.
+ *
+ * This is called during an initial scan of the query's targetlist and quals
+ * before we begin deconstruct_jointree. Once we begin deconstruct_jointree,
+ * all active placeholders must be present in root->placeholder_list with
+ * their correct ph_may_need values, because make_outerjoininfo and
+ * update_placeholder_eval_levels require this info to be available while
+ * we crawl up the join tree.
+ */
+void
+mark_placeholder_maybe_needed(PlannerInfo *root, PlaceHolderInfo *phinfo,
+ Relids relids)
+{
+ /* Mark the PHV as possibly needed at the given syntactic level */
+ phinfo->ph_may_need = bms_add_members(phinfo->ph_may_need, relids);
+
+ /*
+ * This is a bit tricky: the PHV's contained expression may contain other,
+ * lower-level PHVs. We need to get those into the PlaceHolderInfo list,
+ * but they aren't going to be needed where the outer PHV is referenced.
+ * Rather, they'll be needed where the outer PHV is evaluated. We can
+ * estimate that (conservatively) as the syntactic location of the PHV's
+ * expression. Recurse to take care of any such PHVs.
+ */
+ mark_placeholders_in_expr(root, (Node *) phinfo->ph_var->phexpr,
+ phinfo->ph_var->phrels);
+}
+
/*
* update_placeholder_eval_levels
* Adjust the target evaluation levels for placeholders
List *vars = pull_var_clause((Node *) phinfo->ph_var->phexpr,
PVC_INCLUDE_PLACEHOLDERS);
- add_vars_to_targetlist(root, vars, eval_at);
+ add_vars_to_targetlist(root, vars, eval_at, false);
list_free(vars);
}
}
extern PlaceHolderVar *make_placeholder_expr(PlannerInfo *root, Expr *expr,
Relids phrels);
extern PlaceHolderInfo *find_placeholder_info(PlannerInfo *root,
- PlaceHolderVar *phv);
+ PlaceHolderVar *phv, bool create_new_ph);
extern void find_placeholders_in_jointree(PlannerInfo *root);
+extern void mark_placeholder_maybe_needed(PlannerInfo *root,
+ PlaceHolderInfo *phinfo, Relids relids);
extern void update_placeholder_eval_levels(PlannerInfo *root,
SpecialJoinInfo *new_sjinfo);
extern void fix_placeholder_input_needed_levels(PlannerInfo *root);
extern void add_base_rels_to_query(PlannerInfo *root, Node *jtnode);
extern void build_base_rel_tlists(PlannerInfo *root, List *final_tlist);
extern void add_vars_to_targetlist(PlannerInfo *root, List *vars,
- Relids where_needed);
+ Relids where_needed, bool create_new_ph);
extern List *deconstruct_jointree(PlannerInfo *root);
extern void distribute_restrictinfo_to_rels(PlannerInfo *root,
RestrictInfo *restrictinfo);
(3 rows)
rollback;
+--
+-- test incorrect handling of placeholders that only appear in targetlists,
+-- per bug #6154
+--
+SELECT * FROM
+( SELECT 1 as key1 ) sub1
+LEFT JOIN
+( SELECT sub3.key3, sub4.value2, COALESCE(sub4.value2, 66) as value3 FROM
+ ( SELECT 1 as key3 ) sub3
+ LEFT JOIN
+ ( SELECT sub5.key5, COALESCE(sub6.value1, 1) as value2 FROM
+ ( SELECT 1 as key5 ) sub5
+ LEFT JOIN
+ ( SELECT 2 as key6, 42 as value1 ) sub6
+ ON sub5.key5 = sub6.key6
+ ) sub4
+ ON sub4.key5 = sub3.key3
+) sub2
+ON sub1.key1 = sub2.key3;
+ key1 | key3 | value2 | value3
+------+------+--------+--------
+ 1 | 1 | 1 | 1
+(1 row)
+
+-- test the path using join aliases, too
+SELECT * FROM
+( SELECT 1 as key1 ) sub1
+LEFT JOIN
+( SELECT sub3.key3, value2, COALESCE(value2, 66) as value3 FROM
+ ( SELECT 1 as key3 ) sub3
+ LEFT JOIN
+ ( SELECT sub5.key5, COALESCE(sub6.value1, 1) as value2 FROM
+ ( SELECT 1 as key5 ) sub5
+ LEFT JOIN
+ ( SELECT 2 as key6, 42 as value1 ) sub6
+ ON sub5.key5 = sub6.key6
+ ) sub4
+ ON sub4.key5 = sub3.key3
+) sub2
+ON sub1.key1 = sub2.key3;
+ key1 | key3 | value2 | value3
+------+------+--------+--------
+ 1 | 1 | 1 | 1
+(1 row)
+
--
-- test the corner cases FULL JOIN ON TRUE and FULL JOIN ON FALSE
--
rollback;
+--
+-- test incorrect handling of placeholders that only appear in targetlists,
+-- per bug #6154
+--
+SELECT * FROM
+( SELECT 1 as key1 ) sub1
+LEFT JOIN
+( SELECT sub3.key3, sub4.value2, COALESCE(sub4.value2, 66) as value3 FROM
+ ( SELECT 1 as key3 ) sub3
+ LEFT JOIN
+ ( SELECT sub5.key5, COALESCE(sub6.value1, 1) as value2 FROM
+ ( SELECT 1 as key5 ) sub5
+ LEFT JOIN
+ ( SELECT 2 as key6, 42 as value1 ) sub6
+ ON sub5.key5 = sub6.key6
+ ) sub4
+ ON sub4.key5 = sub3.key3
+) sub2
+ON sub1.key1 = sub2.key3;
+
+-- test the path using join aliases, too
+SELECT * FROM
+( SELECT 1 as key1 ) sub1
+LEFT JOIN
+( SELECT sub3.key3, value2, COALESCE(value2, 66) as value3 FROM
+ ( SELECT 1 as key3 ) sub3
+ LEFT JOIN
+ ( SELECT sub5.key5, COALESCE(sub6.value1, 1) as value2 FROM
+ ( SELECT 1 as key5 ) sub5
+ LEFT JOIN
+ ( SELECT 2 as key6, 42 as value1 ) sub6
+ ON sub5.key5 = sub6.key6
+ ) sub4
+ ON sub4.key5 = sub3.key3
+) sub2
+ON sub1.key1 = sub2.key3;
+
--
-- test the corner cases FULL JOIN ON TRUE and FULL JOIN ON FALSE
--
projects / postgresql / commitdiff