PostgreSQL Source Code git master
Loading...
Searching...
No Matches
prepjointree.c
Go to the documentation of this file.
1/*-------------------------------------------------------------------------
2 *
3 * prepjointree.c
4 * Planner preprocessing for subqueries and join tree manipulation.
5 *
6 * NOTE: the intended sequence for invoking these operations is
7 * preprocess_relation_rtes
8 * replace_empty_jointree
9 * pull_up_sublinks
10 * preprocess_function_rtes
11 * pull_up_subqueries
12 * flatten_simple_union_all
13 * do expression preprocessing (including flattening JOIN alias vars)
14 * reduce_outer_joins
15 * remove_useless_result_rtes
16 *
17 *
18 * Portions Copyright (c) 1996-2026, PostgreSQL Global Development Group
19 * Portions Copyright (c) 1994, Regents of the University of California
20 *
21 *
22 * IDENTIFICATION
23 * src/backend/optimizer/prep/prepjointree.c
24 *
25 *-------------------------------------------------------------------------
26 */
27#include "postgres.h"
28
29#include "access/table.h"
30#include "catalog/pg_type.h"
31#include "funcapi.h"
32#include "miscadmin.h"
33#include "nodes/makefuncs.h"
34#include "nodes/multibitmapset.h"
35#include "nodes/nodeFuncs.h"
36#include "optimizer/clauses.h"
37#include "optimizer/optimizer.h"
38#include "optimizer/placeholder.h"
39#include "optimizer/plancat.h"
40#include "optimizer/prep.h"
41#include "optimizer/subselect.h"
42#include "optimizer/tlist.h"
43#include "parser/parse_relation.h"
44#include "parser/parsetree.h"
45#include "rewrite/rewriteHandler.h"
46#include "rewrite/rewriteManip.h"
47#include "utils/rel.h"
48
49
50typedef struct nullingrel_info
51{
52 /*
53 * For each leaf RTE, nullingrels[rti] is the set of relids of outer joins
54 * that potentially null that RTE.
55 */
56 Relids *nullingrels;
57 /* Length of range table (maximum index in nullingrels[]) */
58 int rtlength; /* used only for assertion checks */
59} nullingrel_info;
60
61/* Options for wrapping an expression for identification purposes */
62typedef enum ReplaceWrapOption
63{
64 REPLACE_WRAP_NONE, /* no expressions need to be wrapped */
65 REPLACE_WRAP_ALL, /* all expressions need to be wrapped */
66 REPLACE_WRAP_VARFREE, /* variable-free expressions need to be
67 * wrapped */
68} ReplaceWrapOption;
69
70typedef struct pullup_replace_vars_context
71{
72 PlannerInfo *root;
73 List *targetlist; /* tlist of subquery being pulled up */
74 RangeTblEntry *target_rte; /* RTE of subquery */
75 int result_relation; /* the index of the result relation in the
76 * rewritten query */
77 Relids relids; /* relids within subquery, as numbered after
78 * pullup (set only if target_rte->lateral) */
79 nullingrel_info *nullinfo; /* per-RTE nullingrel info (set only if
80 * target_rte->lateral) */
81 bool *outer_hasSubLinks; /* -> outer query's hasSubLinks */
82 int varno; /* varno of subquery */
83 ReplaceWrapOption wrap_option; /* do we need certain outputs to be PHVs? */
84 Node **rv_cache; /* cache for results with PHVs */
85} pullup_replace_vars_context;
86
87typedef struct reduce_outer_joins_pass1_state
88{
89 Relids relids; /* base relids within this subtree */
90 bool contains_outer; /* does subtree contain outer join(s)? */
91 Relids nullable_rels; /* base relids that are nullable within this
92 * subtree */
93 List *sub_states; /* List of states for subtree components */
94} reduce_outer_joins_pass1_state;
95
96typedef struct reduce_outer_joins_pass2_state
97{
98 Relids inner_reduced; /* OJ relids reduced to plain inner joins */
99 List *partial_reduced; /* List of partially reduced FULL joins */
100} reduce_outer_joins_pass2_state;
101
102typedef struct reduce_outer_joins_partial_state
103{
104 int full_join_rti; /* RT index of a formerly-FULL join */
105 Relids unreduced_side; /* relids in its still-nullable side */
106} reduce_outer_joins_partial_state;
107
108static Query *expand_virtual_generated_columns(PlannerInfo *root, Query *parse,
109 RangeTblEntry *rte, int rt_index,
110 Relation relation);
111static Node *pull_up_sublinks_jointree_recurse(PlannerInfo *root, Node *jtnode,
112 Relids *relids);
113static Node *pull_up_sublinks_qual_recurse(PlannerInfo *root, Node *node,
114 Node **jtlink1, Relids available_rels1,
115 Node **jtlink2, Relids available_rels2);
116static Node *pull_up_subqueries_recurse(PlannerInfo *root, Node *jtnode,
117 JoinExpr *lowest_outer_join,
118 AppendRelInfo *containing_appendrel);
119static Node *pull_up_simple_subquery(PlannerInfo *root, Node *jtnode,
120 RangeTblEntry *rte,
121 JoinExpr *lowest_outer_join,
122 AppendRelInfo *containing_appendrel);
123static Node *pull_up_simple_union_all(PlannerInfo *root, Node *jtnode,
124 RangeTblEntry *rte);
125static void pull_up_union_leaf_queries(Node *setOp, PlannerInfo *root,
126 int parentRTindex, Query *setOpQuery,
127 int childRToffset);
128static void make_setop_translation_list(Query *query, int newvarno,
129 AppendRelInfo *appinfo);
130static bool is_simple_subquery(PlannerInfo *root, Query *subquery,
131 RangeTblEntry *rte,
132 JoinExpr *lowest_outer_join);
133static Node *pull_up_simple_values(PlannerInfo *root, Node *jtnode,
134 RangeTblEntry *rte);
135static bool is_simple_values(PlannerInfo *root, RangeTblEntry *rte);
136static Node *pull_up_constant_function(PlannerInfo *root, Node *jtnode,
137 RangeTblEntry *rte,
138 AppendRelInfo *containing_appendrel);
139static bool is_simple_union_all(Query *subquery);
140static bool is_simple_union_all_recurse(Node *setOp, Query *setOpQuery,
141 List *colTypes);
142static bool is_safe_append_member(Query *subquery);
143static bool jointree_contains_lateral_outer_refs(PlannerInfo *root,
144 Node *jtnode, bool restricted,
145 Relids safe_upper_varnos);
146static void perform_pullup_replace_vars(PlannerInfo *root,
147 pullup_replace_vars_context *rvcontext,
148 AppendRelInfo *containing_appendrel);
149static void replace_vars_in_jointree(Node *jtnode,
150 pullup_replace_vars_context *context);
151static Node *pullup_replace_vars(Node *expr,
152 pullup_replace_vars_context *context);
153static Node *pullup_replace_vars_callback(const Var *var,
154 replace_rte_variables_context *context);
155static Query *pullup_replace_vars_subquery(Query *query,
156 pullup_replace_vars_context *context);
157static reduce_outer_joins_pass1_state *reduce_outer_joins_pass1(Node *jtnode);
158static void reduce_outer_joins_pass2(Node *jtnode,
159 reduce_outer_joins_pass1_state *state1,
160 reduce_outer_joins_pass2_state *state2,
161 PlannerInfo *root,
162 Relids nonnullable_rels,
163 List *forced_null_vars);
164static void report_reduced_full_join(reduce_outer_joins_pass2_state *state2,
165 int rtindex, Relids relids);
166static bool has_notnull_forced_var(PlannerInfo *root, List *forced_null_vars,
167 reduce_outer_joins_pass1_state *right_state);
168static Node *remove_useless_results_recurse(PlannerInfo *root, Node *jtnode,
169 Relids baserels,
170 Node **parent_quals,
171 Relids *dropped_outer_joins);
172static int get_result_relid(PlannerInfo *root, Node *jtnode);
173static void remove_result_refs(PlannerInfo *root, int varno, Node *newjtloc);
174static bool find_dependent_phvs(PlannerInfo *root, int varno, Relids baserels);
175static bool find_dependent_phvs_in_jointree(PlannerInfo *root,
176 Node *node, int varno,
177 Relids baserels);
178static void substitute_phv_relids(Node *node,
179 int varno, Relids subrelids);
180static void fix_append_rel_relids(PlannerInfo *root, int varno,
181 Relids subrelids);
182static Node *find_jointree_node_for_rel(Node *jtnode, int relid);
183static nullingrel_info *get_nullingrels(Query *parse);
184static void get_nullingrels_recurse(Node *jtnode, Relids upper_nullingrels,
185 nullingrel_info *info);
186
187
188/*
189 * transform_MERGE_to_join
190 * Replace a MERGE's jointree to also include the target relation.
191 */
192void
193transform_MERGE_to_join(Query *parse)
194{
195 RangeTblEntry *joinrte;
196 JoinExpr *joinexpr;
197 bool have_action[NUM_MERGE_MATCH_KINDS];
198 JoinType jointype;
199 int joinrti;
200 List *vars;
201 RangeTblRef *rtr;
202 FromExpr *target;
203 Node *source;
204 int sourcerti;
205
206 if (parse->commandType != CMD_MERGE)
207 return;
208
209 /* XXX probably bogus */
210 vars = NIL;
211
212 /*
213 * Work out what kind of join is required. If there any WHEN NOT MATCHED
214 * BY SOURCE/TARGET actions, an outer join is required so that we process
215 * all unmatched tuples from the source and/or target relations.
216 * Otherwise, we can use an inner join.
217 */
218 have_action[MERGE_WHEN_MATCHED] = false;
219 have_action[MERGE_WHEN_NOT_MATCHED_BY_SOURCE] = false;
220 have_action[MERGE_WHEN_NOT_MATCHED_BY_TARGET] = false;
221
222 foreach_node(MergeAction, action, parse->mergeActionList)
223 {
224 if (action->commandType != CMD_NOTHING)
225 have_action[action->matchKind] = true;
226 }
227
228 if (have_action[MERGE_WHEN_NOT_MATCHED_BY_SOURCE] &&
229 have_action[MERGE_WHEN_NOT_MATCHED_BY_TARGET])
230 jointype = JOIN_FULL;
231 else if (have_action[MERGE_WHEN_NOT_MATCHED_BY_SOURCE])
232 jointype = JOIN_LEFT;
233 else if (have_action[MERGE_WHEN_NOT_MATCHED_BY_TARGET])
234 jointype = JOIN_RIGHT;
235 else
236 jointype = JOIN_INNER;
237
238 /* Manufacture a join RTE to use. */
239 joinrte = makeNode(RangeTblEntry);
240 joinrte->rtekind = RTE_JOIN;
241 joinrte->jointype = jointype;
242 joinrte->joinmergedcols = 0;
243 joinrte->joinaliasvars = vars;
244 joinrte->joinleftcols = NIL; /* MERGE does not allow JOIN USING */
245 joinrte->joinrightcols = NIL; /* ditto */
246 joinrte->join_using_alias = NULL;
247
248 joinrte->alias = NULL;
249 joinrte->eref = makeAlias("*MERGE*", NIL);
250 joinrte->lateral = false;
251 joinrte->inh = false;
252 joinrte->inFromCl = true;
253
254 /*
255 * Add completed RTE to pstate's range table list, so that we know its
256 * index.
257 */
258 parse->rtable = lappend(parse->rtable, joinrte);
259 joinrti = list_length(parse->rtable);
260
261 /*
262 * Create a JOIN between the target and the source relation.
263 *
264 * Here the target is identified by parse->mergeTargetRelation. For a
265 * regular table, this will equal parse->resultRelation, but for a
266 * trigger-updatable view, it will be the expanded view subquery that we
267 * need to pull data from.
268 *
269 * The source relation is in parse->jointree->fromlist, but any quals in
270 * parse->jointree->quals are restrictions on the target relation (if the
271 * target relation is an auto-updatable view).
272 */
273 /* target rel, with any quals */
274 rtr = makeNode(RangeTblRef);
275 rtr->rtindex = parse->mergeTargetRelation;
276 target = makeFromExpr(list_make1(rtr), parse->jointree->quals);
277
278 /* source rel (expect exactly one -- see transformMergeStmt()) */
279 Assert(list_length(parse->jointree->fromlist) == 1);
280 source = linitial(parse->jointree->fromlist);
281
282 /*
283 * index of source rel (expect either a RangeTblRef or a JoinExpr -- see
284 * transformFromClauseItem()).
285 */
286 if (IsA(source, RangeTblRef))
287 sourcerti = ((RangeTblRef *) source)->rtindex;
288 else if (IsA(source, JoinExpr))
289 sourcerti = ((JoinExpr *) source)->rtindex;
290 else
291 {
292 elog(ERROR, "unrecognized source node type: %d",
293 (int) nodeTag(source));
294 sourcerti = 0; /* keep compiler quiet */
295 }
296
297 /* Join the source and target */
298 joinexpr = makeNode(JoinExpr);
299 joinexpr->jointype = jointype;
300 joinexpr->isNatural = false;
301 joinexpr->larg = (Node *) target;
302 joinexpr->rarg = source;
303 joinexpr->usingClause = NIL;
304 joinexpr->join_using_alias = NULL;
305 joinexpr->quals = parse->mergeJoinCondition;
306 joinexpr->alias = NULL;
307 joinexpr->rtindex = joinrti;
308
309 /* Make the new join be the sole entry in the query's jointree */
310 parse->jointree->fromlist = list_make1(joinexpr);
311 parse->jointree->quals = NULL;
312
313 /*
314 * If necessary, mark parse->targetlist entries that refer to the target
315 * as nullable by the join. Normally the targetlist will be empty for a
316 * MERGE, but if the target is a trigger-updatable view, it will contain a
317 * whole-row Var referring to the expanded view query.
318 */
319 if (parse->targetList != NIL &&
320 (jointype == JOIN_RIGHT || jointype == JOIN_FULL))
321 parse->targetList = (List *)
322 add_nulling_relids((Node *) parse->targetList,
323 bms_make_singleton(parse->mergeTargetRelation),
324 bms_make_singleton(joinrti));
325
326 /*
327 * If the source relation is on the outer side of the join, mark any
328 * source relation Vars in the join condition, actions, and RETURNING list
329 * as nullable by the join. These Vars will be added to the targetlist by
330 * preprocess_targetlist(), so it's important to mark them correctly here.
331 *
332 * It might seem that this is not necessary for Vars in the join
333 * condition, since it is inside the join, but it is also needed above the
334 * join (in the ModifyTable node) to distinguish between the MATCHED and
335 * NOT MATCHED BY SOURCE cases -- see ExecMergeMatched(). Note that this
336 * creates a modified copy of the join condition, for use above the join,
337 * without modifying the original join condition, inside the join.
338 */
339 if (jointype == JOIN_LEFT || jointype == JOIN_FULL)
340 {
341 parse->mergeJoinCondition =
342 add_nulling_relids(parse->mergeJoinCondition,
343 bms_make_singleton(sourcerti),
344 bms_make_singleton(joinrti));
345
346 foreach_node(MergeAction, action, parse->mergeActionList)
347 {
348 action->qual =
349 add_nulling_relids(action->qual,
350 bms_make_singleton(sourcerti),
351 bms_make_singleton(joinrti));
352
353 action->targetList = (List *)
354 add_nulling_relids((Node *) action->targetList,
355 bms_make_singleton(sourcerti),
356 bms_make_singleton(joinrti));
357 }
358
359 parse->returningList = (List *)
360 add_nulling_relids((Node *) parse->returningList,
361 bms_make_singleton(sourcerti),
362 bms_make_singleton(joinrti));
363 }
364
365 /*
366 * If there are any WHEN NOT MATCHED BY SOURCE actions, the executor will
367 * use the join condition to distinguish between MATCHED and NOT MATCHED
368 * BY SOURCE cases. Otherwise, it's no longer needed, and we set it to
369 * NULL, saving cycles during planning and execution.
370 *
371 * We need to be careful though: the executor evaluates this condition
372 * using the output of the join subplan node, which nulls the output from
373 * the source relation when the join condition doesn't match. That risks
374 * producing incorrect results when rechecking using a "non-strict" join
375 * condition, such as "src.col IS NOT DISTINCT FROM tgt.col". To guard
376 * against that, we add an additional "src IS NOT NULL" check to the join
377 * condition, so that it does the right thing when performing a recheck
378 * based on the output of the join subplan.
379 */
380 if (have_action[MERGE_WHEN_NOT_MATCHED_BY_SOURCE])
381 {
382 Var *var;
383 NullTest *ntest;
384
385 /* source wholerow Var (nullable by the new join) */
386 var = makeWholeRowVar(rt_fetch(sourcerti, parse->rtable),
387 sourcerti, 0, false);
388 var->varnullingrels = bms_make_singleton(joinrti);
389
390 /* "src IS NOT NULL" check */
391 ntest = makeNode(NullTest);
392 ntest->arg = (Expr *) var;
393 ntest->nulltesttype = IS_NOT_NULL;
394 ntest->argisrow = false;
395 ntest->location = -1;
396
397 /* combine it with the original join condition */
398 parse->mergeJoinCondition =
399 (Node *) make_and_qual((Node *) ntest, parse->mergeJoinCondition);
400 }
401 else
402 parse->mergeJoinCondition = NULL; /* join condition not needed */
403}
404
405/*
406 * preprocess_relation_rtes
407 * Do the preprocessing work for any relation RTEs in the FROM clause.
408 *
409 * This scans the rangetable for relation RTEs and retrieves the necessary
410 * catalog information for each relation. Using this information, it clears
411 * the inh flag for any relation that has no children, collects not-null
412 * attribute numbers for any relation that has column not-null constraints, and
413 * expands virtual generated columns for any relation that contains them.
414 *
415 * Note that expanding virtual generated columns may cause the query tree to
416 * have new copies of rangetable entries. Therefore, we have to use list_nth
417 * instead of foreach when iterating over the query's rangetable.
418 *
419 * Returns a modified copy of the query tree, if any relations with virtual
420 * generated columns are present.
421 */
422Query *
423preprocess_relation_rtes(PlannerInfo *root)
424{
425 Query *parse = root->parse;
426 int rtable_size;
427 int rt_index;
428
429 rtable_size = list_length(parse->rtable);
430
431 for (rt_index = 0; rt_index < rtable_size; rt_index++)
432 {
433 RangeTblEntry *rte = rt_fetch(rt_index + 1, parse->rtable);
434 Relation relation;
435
436 /* We only care about relation RTEs. */
437 if (rte->rtekind != RTE_RELATION)
438 continue;
439
440 /*
441 * We need not lock the relation since it was already locked by the
442 * rewriter.
443 */
444 relation = table_open(rte->relid, NoLock);
445
446 /*
447 * Check to see if the relation actually has any children; if not,
448 * clear the inh flag so we can treat it as a plain base relation.
449 *
450 * Note: this could give a false-positive result, if the rel once had
451 * children but no longer does. We used to be able to clear rte->inh
452 * later on when we discovered that, but no more; we have to handle
453 * such cases as full-fledged inheritance.
454 */
455 if (rte->inh)
456 rte->inh = relation->rd_rel->relhassubclass;
457
458 /*
459 * Check to see if the relation has any column not-null constraints;
460 * if so, retrieve the constraint information and store it in a
461 * relation OID based hash table.
462 */
463 get_relation_notnullatts(root, relation);
464
465 /*
466 * Check to see if the relation has any virtual generated columns; if
467 * so, replace all Var nodes in the query that reference these columns
468 * with the generation expressions.
469 */
470 parse = expand_virtual_generated_columns(root, parse,
471 rte, rt_index + 1,
472 relation);
473
474 table_close(relation, NoLock);
475 }
476
477 return parse;
478}
479
480/*
481 * expand_virtual_generated_columns
482 * Expand virtual generated columns for the given relation.
483 *
484 * This checks whether the given relation has any virtual generated columns,
485 * and if so, replaces all Var nodes in the query that reference those columns
486 * with their generation expressions.
487 *
488 * Returns a modified copy of the query tree if the relation contains virtual
489 * generated columns.
490 */
491static Query *
492expand_virtual_generated_columns(PlannerInfo *root, Query *parse,
493 RangeTblEntry *rte, int rt_index,
494 Relation relation)
495{
496 TupleDesc tupdesc;
497
498 /* Only normal relations can have virtual generated columns */
499 Assert(rte->rtekind == RTE_RELATION);
500
501 tupdesc = RelationGetDescr(relation);
502 if (tupdesc->constr && tupdesc->constr->has_generated_virtual)
503 {
504 List *tlist = NIL;
505 pullup_replace_vars_context rvcontext;
506 List *save_exclRelTlist = NIL;
507
508 for (int i = 0; i < tupdesc->natts; i++)
509 {
510 Form_pg_attribute attr = TupleDescAttr(tupdesc, i);
511 TargetEntry *tle;
512
513 if (attr->attgenerated == ATTRIBUTE_GENERATED_VIRTUAL)
514 {
515 Node *defexpr;
516
517 defexpr = build_generation_expression(relation, i + 1);
518 ChangeVarNodes(defexpr, 1, rt_index, 0);
519
520 tle = makeTargetEntry((Expr *) defexpr, i + 1, 0, false);
521 tlist = lappend(tlist, tle);
522 }
523 else
524 {
525 Var *var;
526
527 var = makeVar(rt_index,
528 i + 1,
529 attr->atttypid,
530 attr->atttypmod,
531 attr->attcollation,
532 0);
533
534 tle = makeTargetEntry((Expr *) var, i + 1, 0, false);
535 tlist = lappend(tlist, tle);
536 }
537 }
538
539 Assert(list_length(tlist) > 0);
540 Assert(!rte->lateral);
541
542 /*
543 * The relation's targetlist items are now in the appropriate form to
544 * insert into the query, except that we may need to wrap them in
545 * PlaceHolderVars. Set up required context data for
546 * pullup_replace_vars.
547 */
548 rvcontext.root = root;
549 rvcontext.targetlist = tlist;
550 rvcontext.target_rte = rte;
551 rvcontext.result_relation = parse->resultRelation;
552 /* won't need these values */
553 rvcontext.relids = NULL;
554 rvcontext.nullinfo = NULL;
555 /* pass NULL for outer_hasSubLinks */
556 rvcontext.outer_hasSubLinks = NULL;
557 rvcontext.varno = rt_index;
558 /* this flag will be set below, if needed */
559 rvcontext.wrap_option = REPLACE_WRAP_NONE;
560 /* initialize cache array with indexes 0 .. length(tlist) */
561 rvcontext.rv_cache = palloc0((list_length(tlist) + 1) *
562 sizeof(Node *));
563
564 /*
565 * If the query uses grouping sets, we need a PlaceHolderVar for each
566 * expression of the relation's targetlist items. (See comments in
567 * pull_up_simple_subquery().)
568 */
569 if (parse->groupingSets)
570 rvcontext.wrap_option = REPLACE_WRAP_ALL;
571
572 /*
573 * Apply pullup variable replacement throughout the query tree.
574 *
575 * We intentionally do not touch the EXCLUDED pseudo-relation's
576 * targetlist here. Various places in the planner assume that it
577 * contains only Vars, and we want that to remain the case. More
578 * importantly, we don't want setrefs.c to turn any expanded
579 * EXCLUDED.virtual_column expressions in other parts of the query
580 * back into Vars referencing the original virtual column, which
581 * set_plan_refs() would do if exclRelTlist contained matching
582 * expressions.
583 */
584 if (parse->onConflict)
585 {
586 save_exclRelTlist = parse->onConflict->exclRelTlist;
587 parse->onConflict->exclRelTlist = NIL;
588 }
589
590 parse = (Query *) pullup_replace_vars((Node *) parse, &rvcontext);
591
592 if (parse->onConflict)
593 parse->onConflict->exclRelTlist = save_exclRelTlist;
594 }
595
596 return parse;
597}
598
599/*
600 * replace_empty_jointree
601 * If the Query's jointree is empty, replace it with a dummy RTE_RESULT
602 * relation.
603 *
604 * By doing this, we can avoid a bunch of corner cases that formerly existed
605 * for SELECTs with omitted FROM clauses. An example is that a subquery
606 * with empty jointree previously could not be pulled up, because that would
607 * have resulted in an empty relid set, making the subquery not uniquely
608 * identifiable for join or PlaceHolderVar processing.
609 *
610 * Unlike most other functions in this file, this function doesn't recurse;
611 * we rely on other processing to invoke it on sub-queries at suitable times.
612 */
613void
614replace_empty_jointree(Query *parse)
615{
616 RangeTblEntry *rte;
617 Index rti;
618 RangeTblRef *rtr;
619
620 /* Nothing to do if jointree is already nonempty */
621 if (parse->jointree->fromlist != NIL)
622 return;
623
624 /* We mustn't change it in the top level of a setop tree, either */
625 if (parse->setOperations)
626 return;
627
628 /* Create suitable RTE */
629 rte = makeNode(RangeTblEntry);
630 rte->rtekind = RTE_RESULT;
631 rte->eref = makeAlias("*RESULT*", NIL);
632
633 /* Add it to rangetable */
634 parse->rtable = lappend(parse->rtable, rte);
635 rti = list_length(parse->rtable);
636
637 /* And jam a reference into the jointree */
638 rtr = makeNode(RangeTblRef);
639 rtr->rtindex = rti;
640 parse->jointree->fromlist = list_make1(rtr);
641}
642
643/*
644 * pull_up_sublinks
645 * Attempt to pull up ANY and EXISTS SubLinks to be treated as
646 * semijoins or anti-semijoins.
647 *
648 * A clause "foo op ANY (sub-SELECT)" can be processed by pulling the
649 * sub-SELECT up to become a rangetable entry and treating the implied
650 * comparisons as quals of a semijoin. However, this optimization *only*
651 * works at the top level of WHERE or a JOIN/ON clause, because we cannot
652 * distinguish whether the ANY ought to return FALSE or NULL in cases
653 * involving NULL inputs. Also, in an outer join's ON clause we can only
654 * do this if the sublink is degenerate (ie, references only the nullable
655 * side of the join). In that case it is legal to push the semijoin
656 * down into the nullable side of the join. If the sublink references any
657 * nonnullable-side variables then it would have to be evaluated as part
658 * of the outer join, which makes things way too complicated.
659 *
660 * Under similar conditions, EXISTS and NOT EXISTS clauses can be handled
661 * by pulling up the sub-SELECT and creating a semijoin or anti-semijoin.
662 *
663 * This routine searches for such clauses and does the necessary parsetree
664 * transformations if any are found.
665 *
666 * This routine has to run before preprocess_expression(), so the quals
667 * clauses are not yet reduced to implicit-AND format, and are not guaranteed
668 * to be AND/OR-flat either. That means we need to recursively search through
669 * explicit AND clauses. We stop as soon as we hit a non-AND item.
670 */
671void
672pull_up_sublinks(PlannerInfo *root)
673{
674 Node *jtnode;
675 Relids relids;
676
677 /* Begin recursion through the jointree */
678 jtnode = pull_up_sublinks_jointree_recurse(root,
679 (Node *) root->parse->jointree,
680 &relids);
681
682 /*
683 * root->parse->jointree must always be a FromExpr, so insert a dummy one
684 * if we got a bare RangeTblRef or JoinExpr out of the recursion.
685 */
686 if (IsA(jtnode, FromExpr))
687 root->parse->jointree = (FromExpr *) jtnode;
688 else
689 root->parse->jointree = makeFromExpr(list_make1(jtnode), NULL);
690}
691
692/*
693 * Recurse through jointree nodes for pull_up_sublinks()
694 *
695 * In addition to returning the possibly-modified jointree node, we return
696 * a relids set of the contained rels into *relids.
697 */
698static Node *
699pull_up_sublinks_jointree_recurse(PlannerInfo *root, Node *jtnode,
700 Relids *relids)
701{
702 /* Since this function recurses, it could be driven to stack overflow. */
703 check_stack_depth();
704
705 if (jtnode == NULL)
706 {
707 *relids = NULL;
708 }
709 else if (IsA(jtnode, RangeTblRef))
710 {
711 int varno = ((RangeTblRef *) jtnode)->rtindex;
712
713 *relids = bms_make_singleton(varno);
714 /* jtnode is returned unmodified */
715 }
716 else if (IsA(jtnode, FromExpr))
717 {
718 FromExpr *f = (FromExpr *) jtnode;
719 List *newfromlist = NIL;
720 Relids frelids = NULL;
721 FromExpr *newf;
722 Node *jtlink;
723 ListCell *l;
724
725 /* First, recurse to process children and collect their relids */
726 foreach(l, f->fromlist)
727 {
728 Node *newchild;
729 Relids childrelids;
730
731 newchild = pull_up_sublinks_jointree_recurse(root,
732 lfirst(l),
733 &childrelids);
734 newfromlist = lappend(newfromlist, newchild);
735 frelids = bms_join(frelids, childrelids);
736 }
737 /* Build the replacement FromExpr; no quals yet */
738 newf = makeFromExpr(newfromlist, NULL);
739 /* Set up a link representing the rebuilt jointree */
740 jtlink = (Node *) newf;
741 /* Now process qual --- all children are available for use */
742 newf->quals = pull_up_sublinks_qual_recurse(root, f->quals,
743 &jtlink, frelids,
744 NULL, NULL);
745
746 /*
747 * Note that the result will be either newf, or a stack of JoinExprs
748 * with newf at the base. We rely on subsequent optimization steps to
749 * flatten this and rearrange the joins as needed.
750 *
751 * Although we could include the pulled-up subqueries in the returned
752 * relids, there's no need since upper quals couldn't refer to their
753 * outputs anyway.
754 */
755 *relids = frelids;
756 jtnode = jtlink;
757 }
758 else if (IsA(jtnode, JoinExpr))
759 {
760 JoinExpr *j;
761 Relids leftrelids;
762 Relids rightrelids;
763 Node *jtlink;
764
765 /*
766 * Make a modifiable copy of join node, but don't bother copying its
767 * subnodes (yet).
768 */
769 j = palloc_object(JoinExpr);
770 memcpy(j, jtnode, sizeof(JoinExpr));
771 jtlink = (Node *) j;
772
773 /* Recurse to process children and collect their relids */
774 j->larg = pull_up_sublinks_jointree_recurse(root, j->larg,
775 &leftrelids);
776 j->rarg = pull_up_sublinks_jointree_recurse(root, j->rarg,
777 &rightrelids);
778
779 /*
780 * Now process qual, showing appropriate child relids as available,
781 * and attach any pulled-up jointree items at the right place. In the
782 * inner-join case we put new JoinExprs above the existing one (much
783 * as for a FromExpr-style join). In outer-join cases the new
784 * JoinExprs must go into the nullable side of the outer join. The
785 * point of the available_rels machinations is to ensure that we only
786 * pull up quals for which that's okay.
787 *
788 * We don't expect to see any pre-existing JOIN_SEMI, JOIN_ANTI,
789 * JOIN_RIGHT_SEMI, or JOIN_RIGHT_ANTI jointypes here.
790 */
791 switch (j->jointype)
792 {
793 case JOIN_INNER:
794 j->quals = pull_up_sublinks_qual_recurse(root, j->quals,
795 &jtlink,
796 bms_union(leftrelids,
797 rightrelids),
798 NULL, NULL);
799 break;
800 case JOIN_LEFT:
801 j->quals = pull_up_sublinks_qual_recurse(root, j->quals,
802 &j->rarg,
803 rightrelids,
804 NULL, NULL);
805 break;
806 case JOIN_FULL:
807 /* can't do anything with full-join quals */
808 break;
809 case JOIN_RIGHT:
810 j->quals = pull_up_sublinks_qual_recurse(root, j->quals,
811 &j->larg,
812 leftrelids,
813 NULL, NULL);
814 break;
815 default:
816 elog(ERROR, "unrecognized join type: %d",
817 (int) j->jointype);
818 break;
819 }
820
821 /*
822 * Although we could include the pulled-up subqueries in the returned
823 * relids, there's no need since upper quals couldn't refer to their
824 * outputs anyway. But we *do* need to include the join's own rtindex
825 * because we haven't yet collapsed join alias variables, so upper
826 * levels would mistakenly think they couldn't use references to this
827 * join.
828 */
829 *relids = bms_join(leftrelids, rightrelids);
830 if (j->rtindex)
831 *relids = bms_add_member(*relids, j->rtindex);
832 jtnode = jtlink;
833 }
834 else
835 elog(ERROR, "unrecognized node type: %d",
836 (int) nodeTag(jtnode));
837 return jtnode;
838}
839
840/*
841 * Recurse through top-level qual nodes for pull_up_sublinks()
842 *
843 * jtlink1 points to the link in the jointree where any new JoinExprs should
844 * be inserted if they reference available_rels1 (i.e., available_rels1
845 * denotes the relations present underneath jtlink1). Optionally, jtlink2 can
846 * point to a second link where new JoinExprs should be inserted if they
847 * reference available_rels2 (pass NULL for both those arguments if not used).
848 * Note that SubLinks referencing both sets of variables cannot be optimized.
849 * If we find multiple pull-up-able SubLinks, they'll get stacked onto jtlink1
850 * and/or jtlink2 in the order we encounter them. We rely on subsequent
851 * optimization to rearrange the stack if appropriate.
852 *
853 * Returns the replacement qual node, or NULL if the qual should be removed.
854 */
855static Node *
856pull_up_sublinks_qual_recurse(PlannerInfo *root, Node *node,
857 Node **jtlink1, Relids available_rels1,
858 Node **jtlink2, Relids available_rels2)
859{
860 if (node == NULL)
861 return NULL;
862 if (IsA(node, SubLink))
863 {
864 SubLink *sublink = (SubLink *) node;
865 JoinExpr *j;
866 Relids child_rels;
867
868 /* Is it a convertible ANY or EXISTS clause? */
869 if (sublink->subLinkType == ANY_SUBLINK)
870 {
871 ScalarArrayOpExpr *saop;
872
873 if ((saop = convert_VALUES_to_ANY(root,
874 sublink->testexpr,
875 (Query *) sublink->subselect)) != NULL)
876 {
877 /*
878 * The VALUES sequence was simplified. Nothing more to do
879 * here.
880 */
881 return (Node *) saop;
882 }
883
884 if ((j = convert_ANY_sublink_to_join(root, sublink, false,
885 available_rels1)) != NULL)
886 {
887 /* Yes; insert the new join node into the join tree */
888 j->larg = *jtlink1;
889 *jtlink1 = (Node *) j;
890 /* Recursively process pulled-up jointree nodes */
891 j->rarg = pull_up_sublinks_jointree_recurse(root,
892 j->rarg,
893 &child_rels);
894
895 /*
896 * Now recursively process the pulled-up quals. Any inserted
897 * joins can get stacked onto either j->larg or j->rarg,
898 * depending on which rels they reference.
899 */
900 j->quals = pull_up_sublinks_qual_recurse(root,
901 j->quals,
902 &j->larg,
903 available_rels1,
904 &j->rarg,
905 child_rels);
906 /* Return NULL representing constant TRUE */
907 return NULL;
908 }
909 if (available_rels2 != NULL &&
910 (j = convert_ANY_sublink_to_join(root, sublink, false,
911 available_rels2)) != NULL)
912 {
913 /* Yes; insert the new join node into the join tree */
914 j->larg = *jtlink2;
915 *jtlink2 = (Node *) j;
916 /* Recursively process pulled-up jointree nodes */
917 j->rarg = pull_up_sublinks_jointree_recurse(root,
918 j->rarg,
919 &child_rels);
920
921 /*
922 * Now recursively process the pulled-up quals. Any inserted
923 * joins can get stacked onto either j->larg or j->rarg,
924 * depending on which rels they reference.
925 */
926 j->quals = pull_up_sublinks_qual_recurse(root,
927 j->quals,
928 &j->larg,
929 available_rels2,
930 &j->rarg,
931 child_rels);
932 /* Return NULL representing constant TRUE */
933 return NULL;
934 }
935 }
936 else if (sublink->subLinkType == EXISTS_SUBLINK)
937 {
938 if ((j = convert_EXISTS_sublink_to_join(root, sublink, false,
939 available_rels1)) != NULL)
940 {
941 /* Yes; insert the new join node into the join tree */
942 j->larg = *jtlink1;
943 *jtlink1 = (Node *) j;
944 /* Recursively process pulled-up jointree nodes */
945 j->rarg = pull_up_sublinks_jointree_recurse(root,
946 j->rarg,
947 &child_rels);
948
949 /*
950 * Now recursively process the pulled-up quals. Any inserted
951 * joins can get stacked onto either j->larg or j->rarg,
952 * depending on which rels they reference.
953 */
954 j->quals = pull_up_sublinks_qual_recurse(root,
955 j->quals,
956 &j->larg,
957 available_rels1,
958 &j->rarg,
959 child_rels);
960 /* Return NULL representing constant TRUE */
961 return NULL;
962 }
963 if (available_rels2 != NULL &&
964 (j = convert_EXISTS_sublink_to_join(root, sublink, false,
965 available_rels2)) != NULL)
966 {
967 /* Yes; insert the new join node into the join tree */
968 j->larg = *jtlink2;
969 *jtlink2 = (Node *) j;
970 /* Recursively process pulled-up jointree nodes */
971 j->rarg = pull_up_sublinks_jointree_recurse(root,
972 j->rarg,
973 &child_rels);
974
975 /*
976 * Now recursively process the pulled-up quals. Any inserted
977 * joins can get stacked onto either j->larg or j->rarg,
978 * depending on which rels they reference.
979 */
980 j->quals = pull_up_sublinks_qual_recurse(root,
981 j->quals,
982 &j->larg,
983 available_rels2,
984 &j->rarg,
985 child_rels);
986 /* Return NULL representing constant TRUE */
987 return NULL;
988 }
989 }
990 /* Else return it unmodified */
991 return node;
992 }
993 if (is_notclause(node))
994 {
995 /* If the immediate argument of NOT is ANY or EXISTS, try to convert */
996 SubLink *sublink = (SubLink *) get_notclausearg((Expr *) node);
997 JoinExpr *j;
998 Relids child_rels;
999
1000 if (sublink && IsA(sublink, SubLink))
1001 {
1002 if (sublink->subLinkType == ANY_SUBLINK)
1003 {
1004 if ((j = convert_ANY_sublink_to_join(root, sublink, true,
1005 available_rels1)) != NULL)
1006 {
1007 /* Yes; insert the new join node into the join tree */
1008 j->larg = *jtlink1;
1009 *jtlink1 = (Node *) j;
1010 /* Recursively process pulled-up jointree nodes */
1011 j->rarg = pull_up_sublinks_jointree_recurse(root,
1012 j->rarg,
1013 &child_rels);
1014
1015 /*
1016 * Now recursively process the pulled-up quals. Because
1017 * we are underneath a NOT, we can't pull up sublinks that
1018 * reference the left-hand stuff, but it's still okay to
1019 * pull up sublinks referencing j->rarg.
1020 */
1021 j->quals = pull_up_sublinks_qual_recurse(root,
1022 j->quals,
1023 &j->rarg,
1024 child_rels,
1025 NULL, NULL);
1026 /* Return NULL representing constant TRUE */
1027 return NULL;
1028 }
1029 if (available_rels2 != NULL &&
1030 (j = convert_ANY_sublink_to_join(root, sublink, true,
1031 available_rels2)) != NULL)
1032 {
1033 /* Yes; insert the new join node into the join tree */
1034 j->larg = *jtlink2;
1035 *jtlink2 = (Node *) j;
1036 /* Recursively process pulled-up jointree nodes */
1037 j->rarg = pull_up_sublinks_jointree_recurse(root,
1038 j->rarg,
1039 &child_rels);
1040
1041 /*
1042 * Now recursively process the pulled-up quals. Because
1043 * we are underneath a NOT, we can't pull up sublinks that
1044 * reference the left-hand stuff, but it's still okay to
1045 * pull up sublinks referencing j->rarg.
1046 */
1047 j->quals = pull_up_sublinks_qual_recurse(root,
1048 j->quals,
1049 &j->rarg,
1050 child_rels,
1051 NULL, NULL);
1052 /* Return NULL representing constant TRUE */
1053 return NULL;
1054 }
1055 }
1056 else if (sublink->subLinkType == EXISTS_SUBLINK)
1057 {
1058 if ((j = convert_EXISTS_sublink_to_join(root, sublink, true,
1059 available_rels1)) != NULL)
1060 {
1061 /* Yes; insert the new join node into the join tree */
1062 j->larg = *jtlink1;
1063 *jtlink1 = (Node *) j;
1064 /* Recursively process pulled-up jointree nodes */
1065 j->rarg = pull_up_sublinks_jointree_recurse(root,
1066 j->rarg,
1067 &child_rels);
1068
1069 /*
1070 * Now recursively process the pulled-up quals. Because
1071 * we are underneath a NOT, we can't pull up sublinks that
1072 * reference the left-hand stuff, but it's still okay to
1073 * pull up sublinks referencing j->rarg.
1074 */
1075 j->quals = pull_up_sublinks_qual_recurse(root,
1076 j->quals,
1077 &j->rarg,
1078 child_rels,
1079 NULL, NULL);
1080 /* Return NULL representing constant TRUE */
1081 return NULL;
1082 }
1083 if (available_rels2 != NULL &&
1084 (j = convert_EXISTS_sublink_to_join(root, sublink, true,
1085 available_rels2)) != NULL)
1086 {
1087 /* Yes; insert the new join node into the join tree */
1088 j->larg = *jtlink2;
1089 *jtlink2 = (Node *) j;
1090 /* Recursively process pulled-up jointree nodes */
1091 j->rarg = pull_up_sublinks_jointree_recurse(root,
1092 j->rarg,
1093 &child_rels);
1094
1095 /*
1096 * Now recursively process the pulled-up quals. Because
1097 * we are underneath a NOT, we can't pull up sublinks that
1098 * reference the left-hand stuff, but it's still okay to
1099 * pull up sublinks referencing j->rarg.
1100 */
1101 j->quals = pull_up_sublinks_qual_recurse(root,
1102 j->quals,
1103 &j->rarg,
1104 child_rels,
1105 NULL, NULL);
1106 /* Return NULL representing constant TRUE */
1107 return NULL;
1108 }
1109 }
1110 }
1111 /* Else return it unmodified */
1112 return node;
1113 }
1114 if (is_andclause(node))
1115 {
1116 /* Recurse into AND clause */
1117 List *newclauses = NIL;
1118 ListCell *l;
1119
1120 foreach(l, ((BoolExpr *) node)->args)
1121 {
1122 Node *oldclause = (Node *) lfirst(l);
1123 Node *newclause;
1124
1125 newclause = pull_up_sublinks_qual_recurse(root,
1126 oldclause,
1127 jtlink1,
1128 available_rels1,
1129 jtlink2,
1130 available_rels2);
1131 if (newclause)
1132 newclauses = lappend(newclauses, newclause);
1133 }
1134 /* We might have got back fewer clauses than we started with */
1135 if (newclauses == NIL)
1136 return NULL;
1137 else if (list_length(newclauses) == 1)
1138 return (Node *) linitial(newclauses);
1139 else
1140 return (Node *) make_andclause(newclauses);
1141 }
1142 /* Stop if not an AND */
1143 return node;
1144}
1145
1146/*
1147 * preprocess_function_rtes
1148 * Constant-simplify any FUNCTION RTEs in the FROM clause, and then
1149 * attempt to "inline" any that can be converted to simple subqueries.
1150 *
1151 * If an RTE_FUNCTION rtable entry invokes a set-returning SQL function that
1152 * contains just a simple SELECT, we can convert the rtable entry to an
1153 * RTE_SUBQUERY entry exposing the SELECT directly. Other sorts of functions
1154 * are also inline-able if they have a support function that can generate
1155 * the replacement sub-Query. This is especially useful if the subquery can
1156 * then be "pulled up" for further optimization, but we do it even if not,
1157 * to reduce executor overhead.
1158 *
1159 * This has to be done before we have started to do any optimization of
1160 * subqueries, else any such steps wouldn't get applied to subqueries
1161 * obtained via inlining. However, we do it after pull_up_sublinks
1162 * so that we can inline any functions used in SubLink subselects.
1163 *
1164 * The reason for applying const-simplification at this stage is that
1165 * (a) we'd need to do it anyway to inline a SRF, and (b) by doing it now,
1166 * we can be sure that pull_up_constant_function() will see constants
1167 * if there are constants to be seen. This approach also guarantees
1168 * that every FUNCTION RTE has been const-simplified, allowing planner.c's
1169 * preprocess_expression() to skip doing it again.
1170 *
1171 * Like most of the planner, this feels free to scribble on its input data
1172 * structure.
1173 */
1174void
1175preprocess_function_rtes(PlannerInfo *root)
1176{
1177 ListCell *rt;
1178
1179 foreach(rt, root->parse->rtable)
1180 {
1181 RangeTblEntry *rte = (RangeTblEntry *) lfirst(rt);
1182
1183 if (rte->rtekind == RTE_FUNCTION)
1184 {
1185 Query *funcquery;
1186
1187 /* Apply const-simplification */
1188 rte->functions = (List *)
1189 eval_const_expressions(root, (Node *) rte->functions);
1190
1191 /* Check safety of expansion, and expand if possible */
1192 funcquery = inline_function_in_from(root, rte);
1193 if (funcquery)
1194 {
1195 /* Successful expansion, convert the RTE to a subquery */
1196 rte->rtekind = RTE_SUBQUERY;
1197 rte->subquery = funcquery;
1198 rte->security_barrier = false;
1199
1200 /*
1201 * Clear fields that should not be set in a subquery RTE.
1202 * However, we leave rte->functions filled in for the moment,
1203 * in case makeWholeRowVar needs to consult it. We'll clear
1204 * it in setrefs.c (see add_rte_to_flat_rtable) so that this
1205 * abuse of the data structure doesn't escape the planner.
1206 */
1207 rte->funcordinality = false;
1208 }
1209 }
1210 }
1211}
1212
1213/*
1214 * pull_up_subqueries
1215 * Look for subqueries in the rangetable that can be pulled up into
1216 * the parent query. If the subquery has no special features like
1217 * grouping/aggregation then we can merge it into the parent's jointree.
1218 * Also, subqueries that are simple UNION ALL structures can be
1219 * converted into "append relations".
1220 */
1221void
1222pull_up_subqueries(PlannerInfo *root)
1223{
1224 /* Top level of jointree must always be a FromExpr */
1225 Assert(IsA(root->parse->jointree, FromExpr));
1226 /* Recursion starts with no containing join nor appendrel */
1227 root->parse->jointree = (FromExpr *)
1228 pull_up_subqueries_recurse(root, (Node *) root->parse->jointree,
1229 NULL, NULL);
1230 /* We should still have a FromExpr */
1231 Assert(IsA(root->parse->jointree, FromExpr));
1232}
1233
1234/*
1235 * pull_up_subqueries_recurse
1236 * Recursive guts of pull_up_subqueries.
1237 *
1238 * This recursively processes the jointree and returns a modified jointree.
1239 *
1240 * If this jointree node is within either side of an outer join, then
1241 * lowest_outer_join references the lowest such JoinExpr node; otherwise
1242 * it is NULL. We use this to constrain the effects of LATERAL subqueries.
1243 *
1244 * If we are looking at a member subquery of an append relation,
1245 * containing_appendrel describes that relation; else it is NULL.
1246 * This forces use of the PlaceHolderVar mechanism for all non-Var targetlist
1247 * items, and puts some additional restrictions on what can be pulled up.
1248 *
1249 * A tricky aspect of this code is that if we pull up a subquery we have
1250 * to replace Vars that reference the subquery's outputs throughout the
1251 * parent query, including quals attached to jointree nodes above the one
1252 * we are currently processing! We handle this by being careful to maintain
1253 * validity of the jointree structure while recursing, in the following sense:
1254 * whenever we recurse, all qual expressions in the tree must be reachable
1255 * from the top level, in case the recursive call needs to modify them.
1256 *
1257 * Notice also that we can't turn pullup_replace_vars loose on the whole
1258 * jointree, because it'd return a mutated copy of the tree; we have to
1259 * invoke it just on the quals, instead. This behavior is what makes it
1260 * reasonable to pass lowest_outer_join as a pointer rather than some
1261 * more-indirect way of identifying the lowest OJ. Likewise, we don't
1262 * replace append_rel_list members but only their substructure, so the
1263 * containing_appendrel reference is safe to use.
1264 */
1265static Node *
1266pull_up_subqueries_recurse(PlannerInfo *root, Node *jtnode,
1267 JoinExpr *lowest_outer_join,
1268 AppendRelInfo *containing_appendrel)
1269{
1270 /* Since this function recurses, it could be driven to stack overflow. */
1271 check_stack_depth();
1272 /* Also, since it's a bit expensive, let's check for query cancel. */
1273 CHECK_FOR_INTERRUPTS();
1274
1275 Assert(jtnode != NULL);
1276 if (IsA(jtnode, RangeTblRef))
1277 {
1278 int varno = ((RangeTblRef *) jtnode)->rtindex;
1279 RangeTblEntry *rte = rt_fetch(varno, root->parse->rtable);
1280
1281 /*
1282 * Is this a subquery RTE, and if so, is the subquery simple enough to
1283 * pull up?
1284 *
1285 * If we are looking at an append-relation member, we can't pull it up
1286 * unless is_safe_append_member says so.
1287 */
1288 if (rte->rtekind == RTE_SUBQUERY &&
1289 is_simple_subquery(root, rte->subquery, rte, lowest_outer_join) &&
1290 (containing_appendrel == NULL ||
1291 is_safe_append_member(rte->subquery)))
1292 return pull_up_simple_subquery(root, jtnode, rte,
1293 lowest_outer_join,
1294 containing_appendrel);
1295
1296 /*
1297 * Alternatively, is it a simple UNION ALL subquery? If so, flatten
1298 * into an "append relation".
1299 *
1300 * It's safe to do this regardless of whether this query is itself an
1301 * appendrel member. (If you're thinking we should try to flatten the
1302 * two levels of appendrel together, you're right; but we handle that
1303 * in set_append_rel_pathlist, not here.)
1304 */
1305 if (rte->rtekind == RTE_SUBQUERY &&
1306 is_simple_union_all(rte->subquery))
1307 return pull_up_simple_union_all(root, jtnode, rte);
1308
1309 /*
1310 * Or perhaps it's a simple VALUES RTE?
1311 *
1312 * We don't allow VALUES pullup below an outer join nor into an
1313 * appendrel (such cases are impossible anyway at the moment).
1314 */
1315 if (rte->rtekind == RTE_VALUES &&
1316 lowest_outer_join == NULL &&
1317 containing_appendrel == NULL &&
1318 is_simple_values(root, rte))
1319 return pull_up_simple_values(root, jtnode, rte);
1320
1321 /*
1322 * Or perhaps it's a FUNCTION RTE that we could inline?
1323 */
1324 if (rte->rtekind == RTE_FUNCTION)
1325 return pull_up_constant_function(root, jtnode, rte,
1326 containing_appendrel);
1327
1328 /* Otherwise, do nothing at this node. */
1329 }
1330 else if (IsA(jtnode, FromExpr))
1331 {
1332 FromExpr *f = (FromExpr *) jtnode;
1333 ListCell *l;
1334
1335 Assert(containing_appendrel == NULL);
1336 /* Recursively transform all the child nodes */
1337 foreach(l, f->fromlist)
1338 {
1339 lfirst(l) = pull_up_subqueries_recurse(root, lfirst(l),
1340 lowest_outer_join,
1341 NULL);
1342 }
1343 }
1344 else if (IsA(jtnode, JoinExpr))
1345 {
1346 JoinExpr *j = (JoinExpr *) jtnode;
1347
1348 Assert(containing_appendrel == NULL);
1349 /* Recurse, being careful to tell myself when inside outer join */
1350 switch (j->jointype)
1351 {
1352 case JOIN_INNER:
1353 j->larg = pull_up_subqueries_recurse(root, j->larg,
1354 lowest_outer_join,
1355 NULL);
1356 j->rarg = pull_up_subqueries_recurse(root, j->rarg,
1357 lowest_outer_join,
1358 NULL);
1359 break;
1360 case JOIN_LEFT:
1361 case JOIN_SEMI:
1362 case JOIN_ANTI:
1363 j->larg = pull_up_subqueries_recurse(root, j->larg,
1364 j,
1365 NULL);
1366 j->rarg = pull_up_subqueries_recurse(root, j->rarg,
1367 j,
1368 NULL);
1369 break;
1370 case JOIN_FULL:
1371 j->larg = pull_up_subqueries_recurse(root, j->larg,
1372 j,
1373 NULL);
1374 j->rarg = pull_up_subqueries_recurse(root, j->rarg,
1375 j,
1376 NULL);
1377 break;
1378 case JOIN_RIGHT:
1379 j->larg = pull_up_subqueries_recurse(root, j->larg,
1380 j,
1381 NULL);
1382 j->rarg = pull_up_subqueries_recurse(root, j->rarg,
1383 j,
1384 NULL);
1385 break;
1386 default:
1387 elog(ERROR, "unrecognized join type: %d",
1388 (int) j->jointype);
1389 break;
1390 }
1391 }
1392 else
1393 elog(ERROR, "unrecognized node type: %d",
1394 (int) nodeTag(jtnode));
1395 return jtnode;
1396}
1397
1398/*
1399 * pull_up_simple_subquery
1400 * Attempt to pull up a single simple subquery.
1401 *
1402 * jtnode is a RangeTblRef that has been tentatively identified as a simple
1403 * subquery by pull_up_subqueries. We return the replacement jointree node,
1404 * or jtnode itself if we determine that the subquery can't be pulled up
1405 * after all.
1406 *
1407 * rte is the RangeTblEntry referenced by jtnode. Remaining parameters are
1408 * as for pull_up_subqueries_recurse.
1409 */
1410static Node *
1411pull_up_simple_subquery(PlannerInfo *root, Node *jtnode, RangeTblEntry *rte,
1412 JoinExpr *lowest_outer_join,
1413 AppendRelInfo *containing_appendrel)
1414{
1415 Query *parse = root->parse;
1416 int varno = ((RangeTblRef *) jtnode)->rtindex;
1417 Query *subquery;
1418 PlannerInfo *subroot;
1419 int rtoffset;
1420 pullup_replace_vars_context rvcontext;
1421 ListCell *lc;
1422
1423 /*
1424 * Make a modifiable copy of the subquery to hack on, so that the RTE will
1425 * be left unchanged in case we decide below that we can't pull it up
1426 * after all.
1427 */
1428 subquery = copyObject(rte->subquery);
1429
1430 /*
1431 * Create a PlannerInfo data structure for this subquery.
1432 *
1433 * NOTE: the next few steps should match the first processing in
1434 * subquery_planner(). Can we refactor to avoid code duplication, or
1435 * would that just make things uglier?
1436 */
1437 subroot = makeNode(PlannerInfo);
1438 subroot->parse = subquery;
1439 subroot->glob = root->glob;
1440 subroot->query_level = root->query_level;
1441 subroot->plan_name = root->plan_name;
1442 subroot->alternative_plan_name = root->alternative_plan_name;
1443 subroot->parent_root = root->parent_root;
1444 subroot->plan_params = NIL;
1445 subroot->outer_params = NULL;
1446 subroot->planner_cxt = CurrentMemoryContext;
1447 subroot->init_plans = NIL;
1448 subroot->cte_plan_ids = NIL;
1449 subroot->multiexpr_params = NIL;
1450 subroot->join_domains = NIL;
1451 subroot->eq_classes = NIL;
1452 subroot->ec_merging_done = false;
1453 subroot->last_rinfo_serial = 0;
1454 subroot->all_result_relids = NULL;
1455 subroot->leaf_result_relids = NULL;
1456 subroot->append_rel_list = NIL;
1457 subroot->row_identity_vars = NIL;
1458 subroot->rowMarks = NIL;
1459 memset(subroot->upper_rels, 0, sizeof(subroot->upper_rels));
1460 memset(subroot->upper_targets, 0, sizeof(subroot->upper_targets));
1461 subroot->processed_groupClause = NIL;
1462 subroot->processed_distinctClause = NIL;
1463 subroot->processed_tlist = NIL;
1464 subroot->update_colnos = NIL;
1465 subroot->grouping_map = NULL;
1466 subroot->minmax_aggs = NIL;
1467 subroot->qual_security_level = 0;
1468 subroot->placeholdersFrozen = false;
1469 subroot->hasRecursion = false;
1470 subroot->assumeReplanning = false;
1471 subroot->wt_param_id = -1;
1472 subroot->non_recursive_path = NULL;
1473 /* We don't currently need a top JoinDomain for the subroot */
1474
1475 /* No CTEs to worry about */
1476 Assert(subquery->cteList == NIL);
1477
1478 /*
1479 * Scan the rangetable for relation RTEs and retrieve the necessary
1480 * catalog information for each relation. Using this information, clear
1481 * the inh flag for any relation that has no children, collect not-null
1482 * attribute numbers for any relation that has column not-null
1483 * constraints, and expand virtual generated columns for any relation that
1484 * contains them.
1485 */
1486 subquery = subroot->parse = preprocess_relation_rtes(subroot);
1487
1488 /*
1489 * If the FROM clause is empty, replace it with a dummy RTE_RESULT RTE, so
1490 * that we don't need so many special cases to deal with that situation.
1491 */
1492 replace_empty_jointree(subquery);
1493
1494 /*
1495 * Pull up any SubLinks within the subquery's quals, so that we don't
1496 * leave unoptimized SubLinks behind.
1497 */
1498 if (subquery->hasSubLinks)
1499 pull_up_sublinks(subroot);
1500
1501 /*
1502 * Similarly, preprocess its function RTEs to inline any set-returning
1503 * functions in its rangetable.
1504 */
1505 preprocess_function_rtes(subroot);
1506
1507 /*
1508 * Recursively pull up the subquery's subqueries, so that
1509 * pull_up_subqueries' processing is complete for its jointree and
1510 * rangetable.
1511 *
1512 * Note: it's okay that the subquery's recursion starts with NULL for
1513 * containing-join info, even if we are within an outer join in the upper
1514 * query; the lower query starts with a clean slate for outer-join
1515 * semantics. Likewise, we needn't pass down appendrel state.
1516 */
1517 pull_up_subqueries(subroot);
1518
1519 /*
1520 * Now we must recheck whether the subquery is still simple enough to pull
1521 * up. If not, abandon processing it.
1522 *
1523 * We don't really need to recheck all the conditions involved, but it's
1524 * easier just to keep this "if" looking the same as the one in
1525 * pull_up_subqueries_recurse.
1526 */
1527 if (is_simple_subquery(root, subquery, rte, lowest_outer_join) &&
1528 (containing_appendrel == NULL || is_safe_append_member(subquery)))
1529 {
1530 /* good to go */
1531 }
1532 else
1533 {
1534 /*
1535 * Give up, return unmodified RangeTblRef.
1536 *
1537 * Note: The work we just did will be redone when the subquery gets
1538 * planned on its own. Perhaps we could avoid that by storing the
1539 * modified subquery back into the rangetable, but I'm not gonna risk
1540 * it now.
1541 */
1542 return jtnode;
1543 }
1544
1545 /*
1546 * We must flatten any join alias Vars in the subquery's targetlist,
1547 * because pulling up the subquery's subqueries might have changed their
1548 * expansions into arbitrary expressions, which could affect
1549 * pullup_replace_vars' decisions about whether PlaceHolderVar wrappers
1550 * are needed for tlist entries. (Likely it'd be better to do
1551 * flatten_join_alias_vars on the whole query tree at some earlier stage,
1552 * maybe even in the rewriter; but for now let's just fix this case here.)
1553 */
1554 subquery->targetList = (List *)
1555 flatten_join_alias_vars(subroot, subroot->parse,
1556 (Node *) subquery->targetList);
1557
1558 /*
1559 * Adjust level-0 varnos in subquery so that we can append its rangetable
1560 * to upper query's. We have to fix the subquery's append_rel_list as
1561 * well.
1562 */
1563 rtoffset = list_length(parse->rtable);
1564 OffsetVarNodes((Node *) subquery, rtoffset, 0);
1565 OffsetVarNodes((Node *) subroot->append_rel_list, rtoffset, 0);
1566
1567 /*
1568 * Upper-level vars in subquery are now one level closer to their parent
1569 * than before.
1570 */
1571 IncrementVarSublevelsUp((Node *) subquery, -1, 1);
1572 IncrementVarSublevelsUp((Node *) subroot->append_rel_list, -1, 1);
1573
1574 /*
1575 * The subquery's targetlist items are now in the appropriate form to
1576 * insert into the top query, except that we may need to wrap them in
1577 * PlaceHolderVars. Set up required context data for pullup_replace_vars.
1578 * (Note that we should include the subquery's inner joins in relids,
1579 * since it may include join alias vars referencing them.)
1580 */
1581 rvcontext.root = root;
1582 rvcontext.targetlist = subquery->targetList;
1583 rvcontext.target_rte = rte;
1584 rvcontext.result_relation = 0;
1585 if (rte->lateral)
1586 {
1587 rvcontext.relids = get_relids_in_jointree((Node *) subquery->jointree,
1588 true, true);
1589 rvcontext.nullinfo = get_nullingrels(parse);
1590 }
1591 else /* won't need these values */
1592 {
1593 rvcontext.relids = NULL;
1594 rvcontext.nullinfo = NULL;
1595 }
1596 rvcontext.outer_hasSubLinks = &parse->hasSubLinks;
1597 rvcontext.varno = varno;
1598 /* this flag will be set below, if needed */
1599 rvcontext.wrap_option = REPLACE_WRAP_NONE;
1600 /* initialize cache array with indexes 0 .. length(tlist) */
1601 rvcontext.rv_cache = palloc0((list_length(subquery->targetList) + 1) *
1602 sizeof(Node *));
1603
1604 /*
1605 * If the parent query uses grouping sets, we need a PlaceHolderVar for
1606 * each expression of the subquery's targetlist items. This ensures that
1607 * expressions retain their separate identity so that they will match
1608 * grouping set columns when appropriate. (It'd be sufficient to wrap
1609 * values used in grouping set columns, and do so only in non-aggregated
1610 * portions of the tlist and havingQual, but that would require a lot of
1611 * infrastructure that pullup_replace_vars hasn't currently got.)
1612 */
1613 if (parse->groupingSets)
1614 rvcontext.wrap_option = REPLACE_WRAP_ALL;
1615
1616 /*
1617 * Replace all of the top query's references to the subquery's outputs
1618 * with copies of the adjusted subtlist items, being careful not to
1619 * replace any of the jointree structure.
1620 */
1621 perform_pullup_replace_vars(root, &rvcontext,
1622 containing_appendrel);
1623
1624 /*
1625 * If the subquery had a LATERAL marker, propagate that to any of its
1626 * child RTEs that could possibly now contain lateral cross-references.
1627 * The children might or might not contain any actual lateral
1628 * cross-references, but we have to mark the pulled-up child RTEs so that
1629 * later planner stages will check for such.
1630 */
1631 if (rte->lateral)
1632 {
1633 foreach(lc, subquery->rtable)
1634 {
1635 RangeTblEntry *child_rte = (RangeTblEntry *) lfirst(lc);
1636
1637 switch (child_rte->rtekind)
1638 {
1639 case RTE_RELATION:
1640 if (child_rte->tablesample)
1641 child_rte->lateral = true;
1642 break;
1643 case RTE_SUBQUERY:
1644 case RTE_FUNCTION:
1645 case RTE_VALUES:
1646 case RTE_TABLEFUNC:
1647 child_rte->lateral = true;
1648 break;
1649 case RTE_JOIN:
1650 case RTE_CTE:
1651 case RTE_NAMEDTUPLESTORE:
1652 case RTE_RESULT:
1653 case RTE_GROUP:
1654 /* these can't contain any lateral references */
1655 break;
1656 case RTE_GRAPH_TABLE:
1657 /* shouldn't happen here */
1658 Assert(false);
1659 break;
1660 }
1661 }
1662 }
1663
1664 /*
1665 * Now append the adjusted rtable entries and their perminfos to upper
1666 * query. (We hold off until after fixing the upper rtable entries; no
1667 * point in running that code on the subquery ones too.)
1668 */
1669 CombineRangeTables(&parse->rtable, &parse->rteperminfos,
1670 subquery->rtable, subquery->rteperminfos);
1671
1672 /*
1673 * Pull up any FOR UPDATE/SHARE markers, too. (OffsetVarNodes already
1674 * adjusted the marker rtindexes, so just concat the lists.)
1675 */
1676 parse->rowMarks = list_concat(parse->rowMarks, subquery->rowMarks);
1677
1678 /*
1679 * We also have to fix the relid sets of any PlaceHolderVar nodes in the
1680 * parent query. (This could perhaps be done by pullup_replace_vars(),
1681 * but it seems cleaner to use two passes.) Note in particular that any
1682 * PlaceHolderVar nodes just created by pullup_replace_vars() will be
1683 * adjusted, so having created them with the subquery's varno is correct.
1684 *
1685 * Likewise, relids appearing in AppendRelInfo nodes have to be fixed. We
1686 * already checked that this won't require introducing multiple subrelids
1687 * into the single-slot AppendRelInfo structs.
1688 */
1689 if (root->glob->lastPHId != 0 || root->append_rel_list)
1690 {
1691 Relids subrelids;
1692
1693 subrelids = get_relids_in_jointree((Node *) subquery->jointree,
1694 true, false);
1695 if (root->glob->lastPHId != 0)
1696 substitute_phv_relids((Node *) parse, varno, subrelids);
1697 fix_append_rel_relids(root, varno, subrelids);
1698 }
1699
1700 /*
1701 * And now add subquery's AppendRelInfos to our list.
1702 */
1703 root->append_rel_list = list_concat(root->append_rel_list,
1704 subroot->append_rel_list);
1705
1706 /*
1707 * We don't have to do the equivalent bookkeeping for outer-join info,
1708 * because that hasn't been set up yet. placeholder_list likewise.
1709 */
1710 Assert(root->join_info_list == NIL);
1711 Assert(subroot->join_info_list == NIL);
1712 Assert(root->placeholder_list == NIL);
1713 Assert(subroot->placeholder_list == NIL);
1714
1715 /*
1716 * We no longer need the RTE's copy of the subquery's query tree. Getting
1717 * rid of it saves nothing in particular so far as this level of query is
1718 * concerned; but if this query level is in turn pulled up into a parent,
1719 * we'd waste cycles copying the now-unused query tree.
1720 */
1721 rte->subquery = NULL;
1722
1723 /*
1724 * Miscellaneous housekeeping.
1725 *
1726 * Although replace_rte_variables() faithfully updated parse->hasSubLinks
1727 * if it copied any SubLinks out of the subquery's targetlist, we still
1728 * could have SubLinks added to the query in the expressions of FUNCTION
1729 * and VALUES RTEs copied up from the subquery. So it's necessary to copy
1730 * subquery->hasSubLinks anyway. Perhaps this can be improved someday.
1731 */
1732 parse->hasSubLinks |= subquery->hasSubLinks;
1733
1734 /* If subquery had any RLS conditions, now main query does too */
1735 parse->hasRowSecurity |= subquery->hasRowSecurity;
1736
1737 /*
1738 * subquery won't be pulled up if it hasAggs, hasWindowFuncs, or
1739 * hasTargetSRFs, so no work needed on those flags
1740 */
1741
1742 /*
1743 * Return the adjusted subquery jointree to replace the RangeTblRef entry
1744 * in parent's jointree; or, if the FromExpr is degenerate, just return
1745 * its single member.
1746 */
1747 Assert(IsA(subquery->jointree, FromExpr));
1748 Assert(subquery->jointree->fromlist != NIL);
1749 if (subquery->jointree->quals == NULL &&
1750 list_length(subquery->jointree->fromlist) == 1)
1751 return (Node *) linitial(subquery->jointree->fromlist);
1752
1753 return (Node *) subquery->jointree;
1754}
1755
1756/*
1757 * pull_up_simple_union_all
1758 * Pull up a single simple UNION ALL subquery.
1759 *
1760 * jtnode is a RangeTblRef that has been identified as a simple UNION ALL
1761 * subquery by pull_up_subqueries. We pull up the leaf subqueries and
1762 * build an "append relation" for the union set. The result value is just
1763 * jtnode, since we don't actually need to change the query jointree.
1764 */
1765static Node *
1766pull_up_simple_union_all(PlannerInfo *root, Node *jtnode, RangeTblEntry *rte)
1767{
1768 int varno = ((RangeTblRef *) jtnode)->rtindex;
1769 Query *subquery = rte->subquery;
1770 int rtoffset = list_length(root->parse->rtable);
1771 List *rtable;
1772
1773 /*
1774 * Make a modifiable copy of the subquery's rtable, so we can adjust
1775 * upper-level Vars in it. There are no such Vars in the setOperations
1776 * tree proper, so fixing the rtable should be sufficient.
1777 */
1778 rtable = copyObject(subquery->rtable);
1779
1780 /*
1781 * Upper-level vars in subquery are now one level closer to their parent
1782 * than before. We don't have to worry about offsetting varnos, though,
1783 * because the UNION leaf queries can't cross-reference each other.
1784 */
1785 IncrementVarSublevelsUp_rtable(rtable, -1, 1);
1786
1787 /*
1788 * If the UNION ALL subquery had a LATERAL marker, propagate that to all
1789 * its children. The individual children might or might not contain any
1790 * actual lateral cross-references, but we have to mark the pulled-up
1791 * child RTEs so that later planner stages will check for such.
1792 */
1793 if (rte->lateral)
1794 {
1795 ListCell *rt;
1796
1797 foreach(rt, rtable)
1798 {
1799 RangeTblEntry *child_rte = (RangeTblEntry *) lfirst(rt);
1800
1801 Assert(child_rte->rtekind == RTE_SUBQUERY);
1802 child_rte->lateral = true;
1803 }
1804 }
1805
1806 /*
1807 * Append child RTEs (and their perminfos) to parent rtable.
1808 */
1809 CombineRangeTables(&root->parse->rtable, &root->parse->rteperminfos,
1810 rtable, subquery->rteperminfos);
1811
1812 /*
1813 * Recursively scan the subquery's setOperations tree and add
1814 * AppendRelInfo nodes for leaf subqueries to the parent's
1815 * append_rel_list. Also apply pull_up_subqueries to the leaf subqueries.
1816 */
1817 Assert(subquery->setOperations);
1818 pull_up_union_leaf_queries(subquery->setOperations, root, varno, subquery,
1819 rtoffset);
1820
1821 /*
1822 * Mark the parent as an append relation.
1823 */
1824 rte->inh = true;
1825
1826 return jtnode;
1827}
1828
1829/*
1830 * pull_up_union_leaf_queries -- recursive guts of pull_up_simple_union_all
1831 *
1832 * Build an AppendRelInfo for each leaf query in the setop tree, and then
1833 * apply pull_up_subqueries to the leaf query.
1834 *
1835 * Note that setOpQuery is the Query containing the setOp node, whose tlist
1836 * contains references to all the setop output columns. When called from
1837 * pull_up_simple_union_all, this is *not* the same as root->parse, which is
1838 * the parent Query we are pulling up into.
1839 *
1840 * parentRTindex is the appendrel parent's index in root->parse->rtable.
1841 *
1842 * The child RTEs have already been copied to the parent. childRToffset
1843 * tells us where in the parent's range table they were copied. When called
1844 * from flatten_simple_union_all, childRToffset is 0 since the child RTEs
1845 * were already in root->parse->rtable and no RT index adjustment is needed.
1846 */
1847static void
1848pull_up_union_leaf_queries(Node *setOp, PlannerInfo *root, int parentRTindex,
1849 Query *setOpQuery, int childRToffset)
1850{
1851 if (IsA(setOp, RangeTblRef))
1852 {
1853 RangeTblRef *rtr = (RangeTblRef *) setOp;
1854 int childRTindex;
1855 AppendRelInfo *appinfo;
1856
1857 /*
1858 * Calculate the index in the parent's range table
1859 */
1860 childRTindex = childRToffset + rtr->rtindex;
1861
1862 /*
1863 * Build a suitable AppendRelInfo, and attach to parent's list.
1864 */
1865 appinfo = makeNode(AppendRelInfo);
1866 appinfo->parent_relid = parentRTindex;
1867 appinfo->child_relid = childRTindex;
1868 appinfo->parent_reltype = InvalidOid;
1869 appinfo->child_reltype = InvalidOid;
1870 make_setop_translation_list(setOpQuery, childRTindex, appinfo);
1871 appinfo->parent_reloid = InvalidOid;
1872 root->append_rel_list = lappend(root->append_rel_list, appinfo);
1873
1874 /*
1875 * Recursively apply pull_up_subqueries to the new child RTE. (We
1876 * must build the AppendRelInfo first, because this will modify it;
1877 * indeed, that's the only part of the upper query where Vars
1878 * referencing childRTindex can exist at this point.)
1879 *
1880 * Note that we can pass NULL for containing-join info even if we're
1881 * actually under an outer join, because the child's expressions
1882 * aren't going to propagate up to the join. Also, we ignore the
1883 * possibility that pull_up_subqueries_recurse() returns a different
1884 * jointree node than what we pass it; if it does, the important thing
1885 * is that it replaced the child relid in the AppendRelInfo node.
1886 */
1887 rtr = makeNode(RangeTblRef);
1888 rtr->rtindex = childRTindex;
1889 (void) pull_up_subqueries_recurse(root, (Node *) rtr,
1890 NULL, appinfo);
1891 }
1892 else if (IsA(setOp, SetOperationStmt))
1893 {
1894 SetOperationStmt *op = (SetOperationStmt *) setOp;
1895
1896 /* Recurse to reach leaf queries */
1897 pull_up_union_leaf_queries(op->larg, root, parentRTindex, setOpQuery,
1898 childRToffset);
1899 pull_up_union_leaf_queries(op->rarg, root, parentRTindex, setOpQuery,
1900 childRToffset);
1901 }
1902 else
1903 {
1904 elog(ERROR, "unrecognized node type: %d",
1905 (int) nodeTag(setOp));
1906 }
1907}
1908
1909/*
1910 * make_setop_translation_list
1911 * Build the list of translations from parent Vars to child Vars for
1912 * a UNION ALL member. (At this point it's just a simple list of
1913 * referencing Vars, but if we succeed in pulling up the member
1914 * subquery, the Vars will get replaced by pulled-up expressions.)
1915 * Also create the rather trivial reverse-translation array.
1916 */
1917static void
1918make_setop_translation_list(Query *query, int newvarno,
1919 AppendRelInfo *appinfo)
1920{
1921 List *vars = NIL;
1922 AttrNumber *pcolnos;
1923 ListCell *l;
1924
1925 /* Initialize reverse-translation array with all entries zero */
1926 /* (entries for resjunk columns will stay that way) */
1927 appinfo->num_child_cols = list_length(query->targetList);
1928 appinfo->parent_colnos = pcolnos =
1929 (AttrNumber *) palloc0(appinfo->num_child_cols * sizeof(AttrNumber));
1930
1931 foreach(l, query->targetList)
1932 {
1933 TargetEntry *tle = (TargetEntry *) lfirst(l);
1934
1935 if (tle->resjunk)
1936 continue;
1937
1938 vars = lappend(vars, makeVarFromTargetEntry(newvarno, tle));
1939 pcolnos[tle->resno - 1] = tle->resno;
1940 }
1941
1942 appinfo->translated_vars = vars;
1943}
1944
1945/*
1946 * is_simple_subquery
1947 * Check a subquery in the range table to see if it's simple enough
1948 * to pull up into the parent query.
1949 *
1950 * rte is the RTE_SUBQUERY RangeTblEntry that contained the subquery.
1951 * (Note subquery is not necessarily equal to rte->subquery; it could be a
1952 * processed copy of that.)
1953 * lowest_outer_join is the lowest outer join above the subquery, or NULL.
1954 */
1955static bool
1956is_simple_subquery(PlannerInfo *root, Query *subquery, RangeTblEntry *rte,
1957 JoinExpr *lowest_outer_join)
1958{
1959 /*
1960 * Let's just make sure it's a valid subselect ...
1961 */
1962 if (!IsA(subquery, Query) ||
1963 subquery->commandType != CMD_SELECT)
1964 elog(ERROR, "subquery is bogus");
1965
1966 /*
1967 * Can't currently pull up a query with setops (unless it's simple UNION
1968 * ALL, which is handled by a different code path). Maybe after querytree
1969 * redesign...
1970 */
1971 if (subquery->setOperations)
1972 return false;
1973
1974 /*
1975 * Can't pull up a subquery involving grouping, aggregation, SRFs,
1976 * sorting, limiting, or WITH. (XXX WITH could possibly be allowed later)
1977 *
1978 * We also don't pull up a subquery that has explicit FOR UPDATE/SHARE
1979 * clauses, because pullup would cause the locking to occur semantically
1980 * higher than it should. Implicit FOR UPDATE/SHARE is okay because in
1981 * that case the locking was originally declared in the upper query
1982 * anyway.
1983 */
1984 if (subquery->hasAggs ||
1985 subquery->hasWindowFuncs ||
1986 subquery->hasTargetSRFs ||
1987 subquery->groupClause ||
1988 subquery->groupingSets ||
1989 subquery->havingQual ||
1990 subquery->sortClause ||
1991 subquery->distinctClause ||
1992 subquery->limitOffset ||
1993 subquery->limitCount ||
1994 subquery->hasForUpdate ||
1995 subquery->cteList)
1996 return false;
1997
1998 /*
1999 * Don't pull up if the RTE represents a security-barrier view; we
2000 * couldn't prevent information leakage once the RTE's Vars are scattered
2001 * about in the upper query.
2002 */
2003 if (rte->security_barrier)
2004 return false;
2005
2006 /*
2007 * If the subquery is LATERAL, check for pullup restrictions from that.
2008 */
2009 if (rte->lateral)
2010 {
2011 bool restricted;
2012 Relids safe_upper_varnos;
2013
2014 /*
2015 * The subquery's WHERE and JOIN/ON quals mustn't contain any lateral
2016 * references to rels outside a higher outer join (including the case
2017 * where the outer join is within the subquery itself). In such a
2018 * case, pulling up would result in a situation where we need to
2019 * postpone quals from below an outer join to above it, which is
2020 * probably completely wrong and in any case is a complication that
2021 * doesn't seem worth addressing at the moment.
2022 */
2023 if (lowest_outer_join != NULL)
2024 {
2025 restricted = true;
2026 safe_upper_varnos = get_relids_in_jointree((Node *) lowest_outer_join,
2027 true, true);
2028 }
2029 else
2030 {
2031 restricted = false;
2032 safe_upper_varnos = NULL; /* doesn't matter */
2033 }
2034
2035 if (jointree_contains_lateral_outer_refs(root,
2036 (Node *) subquery->jointree,
2037 restricted, safe_upper_varnos))
2038 return false;
2039
2040 /*
2041 * If there's an outer join above the LATERAL subquery, also disallow
2042 * pullup if the subquery's targetlist has any references to rels
2043 * outside the outer join, since these might get pulled into quals
2044 * above the subquery (but in or below the outer join) and then lead
2045 * to qual-postponement issues similar to the case checked for above.
2046 * (We wouldn't need to prevent pullup if no such references appear in
2047 * outer-query quals, but we don't have enough info here to check
2048 * that. Also, maybe this restriction could be removed if we forced
2049 * such refs to be wrapped in PlaceHolderVars, even when they're below
2050 * the nearest outer join? But it's a pretty hokey usage, so not
2051 * clear this is worth sweating over.)
2052 *
2053 * If you change this, see also the comments about lateral references
2054 * in pullup_replace_vars_callback().
2055 */
2056 if (lowest_outer_join != NULL)
2057 {
2058 Relids lvarnos = pull_varnos_of_level(root,
2059 (Node *) subquery->targetList,
2060 1);
2061
2062 if (!bms_is_subset(lvarnos, safe_upper_varnos))
2063 return false;
2064 }
2065 }
2066
2067 /*
2068 * Don't pull up a subquery that has any volatile functions in its
2069 * targetlist. Otherwise we might introduce multiple evaluations of these
2070 * functions, if they get copied to multiple places in the upper query,
2071 * leading to surprising results. (Note: the PlaceHolderVar mechanism
2072 * doesn't quite guarantee single evaluation; else we could pull up anyway
2073 * and just wrap such items in PlaceHolderVars ...)
2074 */
2075 if (contain_volatile_functions((Node *) subquery->targetList))
2076 return false;
2077
2078 return true;
2079}
2080
2081/*
2082 * pull_up_simple_values
2083 * Pull up a single simple VALUES RTE.
2084 *
2085 * jtnode is a RangeTblRef that has been identified as a simple VALUES RTE
2086 * by pull_up_subqueries. We always return a RangeTblRef representing a
2087 * RESULT RTE to replace it (all failure cases should have been detected by
2088 * is_simple_values()). Actually, what we return is just jtnode, because
2089 * we replace the VALUES RTE in the rangetable with the RESULT RTE.
2090 *
2091 * rte is the RangeTblEntry referenced by jtnode. Because of the limited
2092 * possible usage of VALUES RTEs, we do not need the remaining parameters
2093 * of pull_up_subqueries_recurse.
2094 */
2095static Node *
2096pull_up_simple_values(PlannerInfo *root, Node *jtnode, RangeTblEntry *rte)
2097{
2098 Query *parse = root->parse;
2099 int varno = ((RangeTblRef *) jtnode)->rtindex;
2100 List *values_list;
2101 List *tlist;
2102 AttrNumber attrno;
2103 pullup_replace_vars_context rvcontext;
2104 ListCell *lc;
2105
2106 Assert(rte->rtekind == RTE_VALUES);
2107 Assert(list_length(rte->values_lists) == 1);
2108
2109 /*
2110 * Need a modifiable copy of the VALUES list to hack on, just in case it's
2111 * multiply referenced.
2112 */
2113 values_list = copyObject(linitial(rte->values_lists));
2114
2115 /*
2116 * The VALUES RTE can't contain any Vars of level zero, let alone any that
2117 * are join aliases, so no need to flatten join alias Vars.
2118 */
2119 Assert(!contain_vars_of_level((Node *) values_list, 0));
2120
2121 /*
2122 * Set up required context data for pullup_replace_vars. In particular,
2123 * we have to make the VALUES list look like a subquery targetlist.
2124 */
2125 tlist = NIL;
2126 attrno = 1;
2127 foreach(lc, values_list)
2128 {
2129 tlist = lappend(tlist,
2130 makeTargetEntry((Expr *) lfirst(lc),
2131 attrno,
2132 NULL,
2133 false));
2134 attrno++;
2135 }
2136 rvcontext.root = root;
2137 rvcontext.targetlist = tlist;
2138 rvcontext.target_rte = rte;
2139 rvcontext.result_relation = 0;
2140 rvcontext.relids = NULL; /* can't be any lateral references here */
2141 rvcontext.nullinfo = NULL;
2142 rvcontext.outer_hasSubLinks = &parse->hasSubLinks;
2143 rvcontext.varno = varno;
2144 rvcontext.wrap_option = REPLACE_WRAP_NONE;
2145 /* initialize cache array with indexes 0 .. length(tlist) */
2146 rvcontext.rv_cache = palloc0((list_length(tlist) + 1) *
2147 sizeof(Node *));
2148
2149 /*
2150 * Replace all of the top query's references to the RTE's outputs with
2151 * copies of the adjusted VALUES expressions, being careful not to replace
2152 * any of the jointree structure. We can assume there's no outer joins or
2153 * appendrels in the dummy Query that surrounds a VALUES RTE.
2154 */
2155 perform_pullup_replace_vars(root, &rvcontext, NULL);
2156
2157 /*
2158 * There should be no appendrels to fix, nor any outer joins and hence no
2159 * PlaceHolderVars.
2160 */
2161 Assert(root->append_rel_list == NIL);
2162 Assert(root->join_info_list == NIL);
2163 Assert(root->placeholder_list == NIL);
2164
2165 /*
2166 * Replace the VALUES RTE with a RESULT RTE. The VALUES RTE is the only
2167 * rtable entry in the current query level, so this is easy.
2168 */
2169 Assert(list_length(parse->rtable) == 1);
2170
2171 /* Create suitable RTE */
2172 rte = makeNode(RangeTblEntry);
2173 rte->rtekind = RTE_RESULT;
2174 rte->eref = makeAlias("*RESULT*", NIL);
2175
2176 /* Replace rangetable */
2177 parse->rtable = list_make1(rte);
2178
2179 /* We could manufacture a new RangeTblRef, but the one we have is fine */
2180 Assert(varno == 1);
2181
2182 return jtnode;
2183}
2184
2185/*
2186 * is_simple_values
2187 * Check a VALUES RTE in the range table to see if it's simple enough
2188 * to pull up into the parent query.
2189 *
2190 * rte is the RTE_VALUES RangeTblEntry to check.
2191 */
2192static bool
2193is_simple_values(PlannerInfo *root, RangeTblEntry *rte)
2194{
2195 Assert(rte->rtekind == RTE_VALUES);
2196
2197 /*
2198 * There must be exactly one VALUES list, else it's not semantically
2199 * correct to replace the VALUES RTE with a RESULT RTE, nor would we have
2200 * a unique set of expressions to substitute into the parent query.
2201 */
2202 if (list_length(rte->values_lists) != 1)
2203 return false;
2204
2205 /*
2206 * Because VALUES can't appear under an outer join (or at least, we won't
2207 * try to pull it up if it does), we need not worry about LATERAL, nor
2208 * about validity of PHVs for the VALUES' outputs.
2209 */
2210
2211 /*
2212 * Don't pull up a VALUES that contains any set-returning or volatile
2213 * functions. The considerations here are basically identical to the
2214 * restrictions on a pull-able subquery's targetlist.
2215 */
2216 if (expression_returns_set((Node *) rte->values_lists) ||
2217 contain_volatile_functions((Node *) rte->values_lists))
2218 return false;
2219
2220 /*
2221 * Do not pull up a VALUES that's not the only RTE in its parent query.
2222 * This is actually the only case that the parser will generate at the
2223 * moment, and assuming this is true greatly simplifies
2224 * pull_up_simple_values().
2225 */
2226 if (list_length(root->parse->rtable) != 1 ||
2227 rte != (RangeTblEntry *) linitial(root->parse->rtable))
2228 return false;
2229
2230 return true;
2231}
2232
2233/*
2234 * pull_up_constant_function
2235 * Pull up an RTE_FUNCTION expression that was simplified to a constant.
2236 *
2237 * jtnode is a RangeTblRef that has been identified as a FUNCTION RTE by
2238 * pull_up_subqueries. If its expression is just a Const, hoist that value
2239 * up into the parent query, and replace the RTE_FUNCTION with RTE_RESULT.
2240 *
2241 * In principle we could pull up any immutable expression, but we don't.
2242 * That might result in multiple evaluations of the expression, which could
2243 * be costly if it's not just a Const. Also, the main value of this is
2244 * to let the constant participate in further const-folding, and of course
2245 * that won't happen for a non-Const.
2246 *
2247 * The pulled-up value might need to be wrapped in a PlaceHolderVar if the
2248 * RTE is below an outer join or is part of an appendrel; the extra
2249 * parameters show whether that's needed.
2250 */
2251static Node *
2252pull_up_constant_function(PlannerInfo *root, Node *jtnode,
2253 RangeTblEntry *rte,
2254 AppendRelInfo *containing_appendrel)
2255{
2256 Query *parse = root->parse;
2257 RangeTblFunction *rtf;
2258 TypeFuncClass functypclass;
2259 Oid funcrettype;
2260 TupleDesc tupdesc;
2261 pullup_replace_vars_context rvcontext;
2262
2263 /* Fail if the RTE has ORDINALITY - we don't implement that here. */
2264 if (rte->funcordinality)
2265 return jtnode;
2266
2267 /* Fail if RTE isn't a single, simple Const expr */
2268 if (list_length(rte->functions) != 1)
2269 return jtnode;
2270 rtf = linitial_node(RangeTblFunction, rte->functions);
2271 if (!IsA(rtf->funcexpr, Const))
2272 return jtnode;
2273
2274 /*
2275 * If the function's result is not a scalar, we punt. In principle we
2276 * could break the composite constant value apart into per-column
2277 * constants, but for now it seems not worth the work.
2278 */
2279 if (rtf->funccolcount != 1)
2280 return jtnode; /* definitely composite */
2281
2282 /* If it has a coldeflist, it certainly returns RECORD */
2283 if (rtf->funccolnames != NIL)
2284 return jtnode; /* must be a one-column RECORD type */
2285
2286 functypclass = get_expr_result_type(rtf->funcexpr,
2287 &funcrettype,
2288 &tupdesc);
2289 if (functypclass != TYPEFUNC_SCALAR)
2290 return jtnode; /* must be a one-column composite type */
2291
2292 /* Create context for applying pullup_replace_vars */
2293 rvcontext.root = root;
2294 rvcontext.targetlist = list_make1(makeTargetEntry((Expr *) rtf->funcexpr,
2295 1, /* resno */
2296 NULL, /* resname */
2297 false)); /* resjunk */
2298 rvcontext.target_rte = rte;
2299 rvcontext.result_relation = 0;
2300
2301 /*
2302 * Since this function was reduced to a Const, it doesn't contain any
2303 * lateral references, even if it's marked as LATERAL. This means we
2304 * don't need to fill relids or nullinfo.
2305 */
2306 rvcontext.relids = NULL;
2307 rvcontext.nullinfo = NULL;
2308
2309 rvcontext.outer_hasSubLinks = &parse->hasSubLinks;
2310 rvcontext.varno = ((RangeTblRef *) jtnode)->rtindex;
2311 /* this flag will be set below, if needed */
2312 rvcontext.wrap_option = REPLACE_WRAP_NONE;
2313 /* initialize cache array with indexes 0 .. length(tlist) */
2314 rvcontext.rv_cache = palloc0((list_length(rvcontext.targetlist) + 1) *
2315 sizeof(Node *));
2316
2317 /*
2318 * If the parent query uses grouping sets, we need a PlaceHolderVar for
2319 * each expression of the subquery's targetlist items. (See comments in
2320 * pull_up_simple_subquery().)
2321 */
2322 if (parse->groupingSets)
2323 rvcontext.wrap_option = REPLACE_WRAP_ALL;
2324
2325 /*
2326 * Replace all of the top query's references to the RTE's output with
2327 * copies of the funcexpr, being careful not to replace any of the
2328 * jointree structure.
2329 */
2330 perform_pullup_replace_vars(root, &rvcontext,
2331 containing_appendrel);
2332
2333 /*
2334 * We don't need to bother with changing PlaceHolderVars in the parent
2335 * query. Their references to the RT index are still good for now, and
2336 * will get removed later if we're able to drop the RTE_RESULT.
2337 */
2338
2339 /*
2340 * Convert the RTE to be RTE_RESULT type, signifying that we don't need to
2341 * scan it anymore, and zero out RTE_FUNCTION-specific fields. Also make
2342 * sure the RTE is not marked LATERAL, since elsewhere we don't expect
2343 * RTE_RESULTs to be LATERAL.
2344 */
2345 rte->rtekind = RTE_RESULT;
2346 rte->functions = NIL;
2347 rte->lateral = false;
2348
2349 /*
2350 * We can reuse the RangeTblRef node.
2351 */
2352 return jtnode;
2353}
2354
2355/*
2356 * is_simple_union_all
2357 * Check a subquery to see if it's a simple UNION ALL.
2358 *
2359 * We require all the setops to be UNION ALL (no mixing) and there can't be
2360 * any datatype coercions involved, ie, all the leaf queries must emit the
2361 * same datatypes.
2362 */
2363static bool
2364is_simple_union_all(Query *subquery)
2365{
2366 SetOperationStmt *topop;
2367
2368 /* Let's just make sure it's a valid subselect ... */
2369 if (!IsA(subquery, Query) ||
2370 subquery->commandType != CMD_SELECT)
2371 elog(ERROR, "subquery is bogus");
2372
2373 /* Is it a set-operation query at all? */
2374 topop = castNode(SetOperationStmt, subquery->setOperations);
2375 if (!topop)
2376 return false;
2377
2378 /* Can't handle ORDER BY, LIMIT/OFFSET, locking, or WITH */
2379 if (subquery->sortClause ||
2380 subquery->limitOffset ||
2381 subquery->limitCount ||
2382 subquery->rowMarks ||
2383 subquery->cteList)
2384 return false;
2385
2386 /* Recursively check the tree of set operations */
2387 return is_simple_union_all_recurse((Node *) topop, subquery,
2388 topop->colTypes);
2389}
2390
2391static bool
2392is_simple_union_all_recurse(Node *setOp, Query *setOpQuery, List *colTypes)
2393{
2394 /* Since this function recurses, it could be driven to stack overflow. */
2395 check_stack_depth();
2396
2397 if (IsA(setOp, RangeTblRef))
2398 {
2399 RangeTblRef *rtr = (RangeTblRef *) setOp;
2400 RangeTblEntry *rte = rt_fetch(rtr->rtindex, setOpQuery->rtable);
2401 Query *subquery = rte->subquery;
2402
2403 Assert(subquery != NULL);
2404
2405 /* Leaf nodes are OK if they match the toplevel column types */
2406 /* We don't have to compare typmods or collations here */
2407 return tlist_same_datatypes(subquery->targetList, colTypes, true);
2408 }
2409 else if (IsA(setOp, SetOperationStmt))
2410 {
2411 SetOperationStmt *op = (SetOperationStmt *) setOp;
2412
2413 /* Must be UNION ALL */
2414 if (op->op != SETOP_UNION || !op->all)
2415 return false;
2416
2417 /* Recurse to check inputs */
2418 return is_simple_union_all_recurse(op->larg, setOpQuery, colTypes) &&
2419 is_simple_union_all_recurse(op->rarg, setOpQuery, colTypes);
2420 }
2421 else
2422 {
2423 elog(ERROR, "unrecognized node type: %d",
2424 (int) nodeTag(setOp));
2425 return false; /* keep compiler quiet */
2426 }
2427}
2428
2429/*
2430 * is_safe_append_member
2431 * Check a subquery that is a leaf of a UNION ALL appendrel to see if it's
2432 * safe to pull up.
2433 */
2434static bool
2435is_safe_append_member(Query *subquery)
2436{
2437 FromExpr *jtnode;
2438
2439 /*
2440 * It's only safe to pull up the child if its jointree contains exactly
2441 * one RTE, else the AppendRelInfo data structure breaks. The one base RTE
2442 * could be buried in several levels of FromExpr, however. Also, if the
2443 * child's jointree is completely empty, we can pull up because
2444 * pull_up_simple_subquery will insert a single RTE_RESULT RTE instead.
2445 *
2446 * Also, the child can't have any WHERE quals because there's no place to
2447 * put them in an appendrel. (This is a bit annoying...) If we didn't
2448 * need to check this, we'd just test whether get_relids_in_jointree()
2449 * yields a singleton set, to be more consistent with the coding of
2450 * fix_append_rel_relids().
2451 */
2452 jtnode = subquery->jointree;
2453 Assert(IsA(jtnode, FromExpr));
2454 /* Check the completely-empty case */
2455 if (jtnode->fromlist == NIL && jtnode->quals == NULL)
2456 return true;
2457 /* Check the more general case */
2458 while (IsA(jtnode, FromExpr))
2459 {
2460 if (jtnode->quals != NULL)
2461 return false;
2462 if (list_length(jtnode->fromlist) != 1)
2463 return false;
2464 jtnode = linitial(jtnode->fromlist);
2465 }
2466 if (!IsA(jtnode, RangeTblRef))
2467 return false;
2468
2469 return true;
2470}
2471
2472/*
2473 * jointree_contains_lateral_outer_refs
2474 * Check for disallowed lateral references in a jointree's quals
2475 *
2476 * If restricted is false, all level-1 Vars are allowed (but we still must
2477 * search the jointree, since it might contain outer joins below which there
2478 * will be restrictions). If restricted is true, return true when any qual
2479 * in the jointree contains level-1 Vars coming from outside the rels listed
2480 * in safe_upper_varnos.
2481 */
2482static bool
2483jointree_contains_lateral_outer_refs(PlannerInfo *root, Node *jtnode,
2484 bool restricted,
2485 Relids safe_upper_varnos)
2486{
2487 if (jtnode == NULL)
2488 return false;
2489 if (IsA(jtnode, RangeTblRef))
2490 return false;
2491 else if (IsA(jtnode, FromExpr))
2492 {
2493 FromExpr *f = (FromExpr *) jtnode;
2494 ListCell *l;
2495
2496 /* First, recurse to check child joins */
2497 foreach(l, f->fromlist)
2498 {
2499 if (jointree_contains_lateral_outer_refs(root,
2500 lfirst(l),
2501 restricted,
2502 safe_upper_varnos))
2503 return true;
2504 }
2505
2506 /* Then check the top-level quals */
2507 if (restricted &&
2508 !bms_is_subset(pull_varnos_of_level(root, f->quals, 1),
2509 safe_upper_varnos))
2510 return true;
2511 }
2512 else if (IsA(jtnode, JoinExpr))
2513 {
2514 JoinExpr *j = (JoinExpr *) jtnode;
2515
2516 /*
2517 * If this is an outer join, we mustn't allow any upper lateral
2518 * references in or below it.
2519 */
2520 if (j->jointype != JOIN_INNER)
2521 {
2522 restricted = true;
2523 safe_upper_varnos = NULL;
2524 }
2525
2526 /* Check the child joins */
2527 if (jointree_contains_lateral_outer_refs(root,
2528 j->larg,
2529 restricted,
2530 safe_upper_varnos))
2531 return true;
2532 if (jointree_contains_lateral_outer_refs(root,
2533 j->rarg,
2534 restricted,
2535 safe_upper_varnos))
2536 return true;
2537
2538 /* Check the JOIN's qual clauses */
2539 if (restricted &&
2540 !bms_is_subset(pull_varnos_of_level(root, j->quals, 1),
2541 safe_upper_varnos))
2542 return true;
2543 }
2544 else
2545 elog(ERROR, "unrecognized node type: %d",
2546 (int) nodeTag(jtnode));
2547 return false;
2548}
2549
2550/*
2551 * Perform pullup_replace_vars everyplace it's needed in the query tree.
2552 *
2553 * Caller has already filled *rvcontext with data describing what to
2554 * substitute for Vars referencing the target subquery. In addition
2555 * we need the identity of the containing appendrel if any.
2556 */
2557static void
2558perform_pullup_replace_vars(PlannerInfo *root,
2559 pullup_replace_vars_context *rvcontext,
2560 AppendRelInfo *containing_appendrel)
2561{
2562 Query *parse = root->parse;
2563 ListCell *lc;
2564
2565 /*
2566 * If we are considering an appendrel child subquery (that is, a UNION ALL
2567 * member query that we're pulling up), then the only part of the upper
2568 * query that could reference the child yet is the translated_vars list of
2569 * the associated AppendRelInfo. Furthermore, we do not want to force use
2570 * of PHVs in the AppendRelInfo --- there isn't any outer join between.
2571 */
2572 if (containing_appendrel)
2573 {
2574 ReplaceWrapOption save_wrap_option = rvcontext->wrap_option;
2575
2576 rvcontext->wrap_option = REPLACE_WRAP_NONE;
2577 containing_appendrel->translated_vars = (List *)
2578 pullup_replace_vars((Node *) containing_appendrel->translated_vars,
2579 rvcontext);
2580 rvcontext->wrap_option = save_wrap_option;
2581 return;
2582 }
2583
2584 /*
2585 * Replace all of the top query's references to the subquery's outputs
2586 * with copies of the adjusted subtlist items, being careful not to
2587 * replace any of the jointree structure. (This'd be a lot cleaner if we
2588 * could use query_tree_mutator.) We have to use PHVs in the targetList,
2589 * returningList, and havingQual, since those are certainly above any
2590 * outer join. replace_vars_in_jointree tracks its location in the
2591 * jointree and uses PHVs or not appropriately.
2592 */
2593 parse->targetList = (List *)
2594 pullup_replace_vars((Node *) parse->targetList, rvcontext);
2595 parse->returningList = (List *)
2596 pullup_replace_vars((Node *) parse->returningList, rvcontext);
2597
2598 if (parse->onConflict)
2599 {
2600 parse->onConflict->onConflictSet = (List *)
2601 pullup_replace_vars((Node *) parse->onConflict->onConflictSet,
2602 rvcontext);
2603 parse->onConflict->onConflictWhere =
2604 pullup_replace_vars(parse->onConflict->onConflictWhere,
2605 rvcontext);
2606
2607 /*
2608 * We assume ON CONFLICT's arbiterElems, arbiterWhere, exclRelTlist
2609 * can't contain any references to a subquery.
2610 */
2611 }
2612 if (parse->mergeActionList)
2613 {
2614 foreach(lc, parse->mergeActionList)
2615 {
2616 MergeAction *action = lfirst(lc);
2617
2618 action->qual = pullup_replace_vars(action->qual, rvcontext);
2619 action->targetList = (List *)
2620 pullup_replace_vars((Node *) action->targetList, rvcontext);
2621 }
2622 }
2623 parse->mergeJoinCondition = pullup_replace_vars(parse->mergeJoinCondition,
2624 rvcontext);
2625 replace_vars_in_jointree((Node *) parse->jointree, rvcontext);
2626 Assert(parse->setOperations == NULL);
2627 parse->havingQual = pullup_replace_vars(parse->havingQual, rvcontext);
2628
2629 /*
2630 * Replace references in the translated_vars lists of appendrels.
2631 */
2632 foreach(lc, root->append_rel_list)
2633 {
2634 AppendRelInfo *appinfo = (AppendRelInfo *) lfirst(lc);
2635
2636 appinfo->translated_vars = (List *)
2637 pullup_replace_vars((Node *) appinfo->translated_vars, rvcontext);
2638 }
2639
2640 /*
2641 * Replace references in the joinaliasvars lists of join RTEs and the
2642 * groupexprs list of group RTE.
2643 */
2644 foreach(lc, parse->rtable)
2645 {
2646 RangeTblEntry *otherrte = (RangeTblEntry *) lfirst(lc);
2647
2648 if (otherrte->rtekind == RTE_JOIN)
2649 otherrte->joinaliasvars = (List *)
2650 pullup_replace_vars((Node *) otherrte->joinaliasvars,
2651 rvcontext);
2652 else if (otherrte->rtekind == RTE_GROUP)
2653 otherrte->groupexprs = (List *)
2654 pullup_replace_vars((Node *) otherrte->groupexprs,
2655 rvcontext);
2656 }
2657}
2658
2659/*
2660 * Helper routine for perform_pullup_replace_vars: do pullup_replace_vars on
2661 * every expression in the jointree, without changing the jointree structure
2662 * itself. Ugly, but there's no other way...
2663 */
2664static void
2665replace_vars_in_jointree(Node *jtnode,
2666 pullup_replace_vars_context *context)
2667{
2668 if (jtnode == NULL)
2669 return;
2670 if (IsA(jtnode, RangeTblRef))
2671 {
2672 /*
2673 * If the RangeTblRef refers to a LATERAL subquery (that isn't the
2674 * same subquery we're pulling up), it might contain references to the
2675 * target subquery, which we must replace. We drive this from the
2676 * jointree scan, rather than a scan of the rtable, so that we can
2677 * avoid processing no-longer-referenced RTEs.
2678 */
2679 int varno = ((RangeTblRef *) jtnode)->rtindex;
2680
2681 if (varno != context->varno) /* ignore target subquery itself */
2682 {
2683 RangeTblEntry *rte = rt_fetch(varno, context->root->parse->rtable);
2684
2685 Assert(rte != context->target_rte);
2686 if (rte->lateral)
2687 {
2688 switch (rte->rtekind)
2689 {
2690 case RTE_RELATION:
2691 /* shouldn't be marked LATERAL unless tablesample */
2692 Assert(rte->tablesample);
2693 rte->tablesample = (TableSampleClause *)
2694 pullup_replace_vars((Node *) rte->tablesample,
2695 context);
2696 break;
2697 case RTE_SUBQUERY:
2698 rte->subquery =
2699 pullup_replace_vars_subquery(rte->subquery,
2700 context);
2701 break;
2702 case RTE_FUNCTION:
2703 rte->functions = (List *)
2704 pullup_replace_vars((Node *) rte->functions,
2705 context);
2706 break;
2707 case RTE_TABLEFUNC:
2708 rte->tablefunc = (TableFunc *)
2709 pullup_replace_vars((Node *) rte->tablefunc,
2710 context);
2711 break;
2712 case RTE_VALUES:
2713 rte->values_lists = (List *)
2714 pullup_replace_vars((Node *) rte->values_lists,
2715 context);
2716 break;
2717 case RTE_JOIN:
2718 case RTE_CTE:
2719 case RTE_NAMEDTUPLESTORE:
2720 case RTE_RESULT:
2721 case RTE_GROUP:
2722 /* these shouldn't be marked LATERAL */
2723 Assert(false);
2724 break;
2725 case RTE_GRAPH_TABLE:
2726 /* shouldn't happen here */
2727 Assert(false);
2728 break;
2729 }
2730 }
2731 }
2732 }
2733 else if (IsA(jtnode, FromExpr))
2734 {
2735 FromExpr *f = (FromExpr *) jtnode;
2736 ListCell *l;
2737
2738 foreach(l, f->fromlist)
2739 replace_vars_in_jointree(lfirst(l), context);
2740 f->quals = pullup_replace_vars(f->quals, context);
2741 }
2742 else if (IsA(jtnode, JoinExpr))
2743 {
2744 JoinExpr *j = (JoinExpr *) jtnode;
2745 ReplaceWrapOption save_wrap_option = context->wrap_option;
2746
2747 replace_vars_in_jointree(j->larg, context);
2748 replace_vars_in_jointree(j->rarg, context);
2749
2750 /*
2751 * Use PHVs within the join quals of a full join for variable-free
2752 * expressions. Otherwise, we cannot identify which side of the join
2753 * a pulled-up variable-free expression came from, which can lead to
2754 * failure to make a plan at all because none of the quals appear to
2755 * be mergeable or hashable conditions.
2756 */
2757 if (j->jointype == JOIN_FULL)
2758 context->wrap_option = REPLACE_WRAP_VARFREE;
2759
2760 j->quals = pullup_replace_vars(j->quals, context);
2761
2762 context->wrap_option = save_wrap_option;
2763 }
2764 else
2765 elog(ERROR, "unrecognized node type: %d",
2766 (int) nodeTag(jtnode));
2767}
2768
2769/*
2770 * Apply pullup variable replacement throughout an expression tree
2771 *
2772 * Returns a modified copy of the tree, so this can't be used where we
2773 * need to do in-place replacement.
2774 */
2775static Node *
2776pullup_replace_vars(Node *expr, pullup_replace_vars_context *context)
2777{
2778 return replace_rte_variables(expr,
2779 context->varno, 0,
2780 pullup_replace_vars_callback,
2781 context,
2782 context->outer_hasSubLinks);
2783}
2784
2785static Node *
2786pullup_replace_vars_callback(const Var *var,
2787 replace_rte_variables_context *context)
2788{
2789 pullup_replace_vars_context *rcon = (pullup_replace_vars_context *) context->callback_arg;
2790 int varattno = var->varattno;
2791 bool need_phv;
2792 Node *newnode;
2793
2794 /* System columns are not replaced. */
2795 if (varattno < InvalidAttrNumber)
2796 return (Node *) copyObject(var);
2797
2798 /*
2799 * We need a PlaceHolderVar if the Var-to-be-replaced has nonempty
2800 * varnullingrels (unless we find below that the replacement expression is
2801 * a Var or PlaceHolderVar that we can just add the nullingrels to). We
2802 * also need one if the caller has instructed us that certain expression
2803 * replacements need to be wrapped for identification purposes.
2804 */
2805 need_phv = (var->varnullingrels != NULL) ||
2806 (rcon->wrap_option != REPLACE_WRAP_NONE);
2807
2808 /*
2809 * If PlaceHolderVars are needed, we cache the modified expressions in
2810 * rcon->rv_cache[]. This is not in hopes of any material speed gain
2811 * within this function, but to avoid generating identical PHVs with
2812 * different IDs. That would result in duplicate evaluations at runtime,
2813 * and possibly prevent optimizations that rely on recognizing different
2814 * references to the same subquery output as being equal(). So it's worth
2815 * a bit of extra effort to avoid it.
2816 *
2817 * The cached items have phlevelsup = 0 and phnullingrels = NULL; we'll
2818 * copy them and adjust those values for this reference site below.
2819 */
2820 if (need_phv &&
2821 varattno >= InvalidAttrNumber &&
2822 varattno <= list_length(rcon->targetlist) &&
2823 rcon->rv_cache[varattno] != NULL)
2824 {
2825 /* Just copy the entry and fall through to adjust phlevelsup etc */
2826 newnode = copyObject(rcon->rv_cache[varattno]);
2827 }
2828 else
2829 {
2830 /*
2831 * Generate the replacement expression. This takes care of expanding
2832 * wholerow references and dealing with non-default varreturningtype.
2833 */
2834 newnode = ReplaceVarFromTargetList(var,
2835 rcon->target_rte,
2836 rcon->targetlist,
2837 rcon->result_relation,
2838 REPLACEVARS_REPORT_ERROR,
2839 0);
2840
2841 /* Insert PlaceHolderVar if needed */
2842 if (need_phv)
2843 {
2844 bool wrap;
2845
2846 if (rcon->wrap_option == REPLACE_WRAP_ALL)
2847 {
2848 /* Caller told us to wrap all expressions in a PlaceHolderVar */
2849 wrap = true;
2850 }
2851 else if (varattno == InvalidAttrNumber)
2852 {
2853 /*
2854 * Insert PlaceHolderVar for whole-tuple reference. Notice
2855 * that we are wrapping one PlaceHolderVar around the whole
2856 * RowExpr, rather than putting one around each element of the
2857 * row. This is because we need the expression to yield NULL,
2858 * not ROW(NULL,NULL,...) when it is forced to null by an
2859 * outer join.
2860 */
2861 wrap = true;
2862 }
2863 else if (newnode && IsA(newnode, Var) &&
2864 ((Var *) newnode)->varlevelsup == 0)
2865 {
2866 /*
2867 * Simple Vars always escape being wrapped, unless they are
2868 * lateral references to something outside the subquery being
2869 * pulled up and the referenced rel is not under the same
2870 * lowest nulling outer join.
2871 */
2872 wrap = false;
2873 if (rcon->target_rte->lateral &&
2874 !bms_is_member(((Var *) newnode)->varno, rcon->relids))
2875 {
2876 nullingrel_info *nullinfo = rcon->nullinfo;
2877 int lvarno = ((Var *) newnode)->varno;
2878
2879 Assert(lvarno > 0 && lvarno <= nullinfo->rtlength);
2880 if (!bms_is_subset(nullinfo->nullingrels[rcon->varno],
2881 nullinfo->nullingrels[lvarno]))
2882 wrap = true;
2883 }
2884 }
2885 else if (newnode && IsA(newnode, PlaceHolderVar) &&
2886 ((PlaceHolderVar *) newnode)->phlevelsup == 0)
2887 {
2888 /* The same rules apply for a PlaceHolderVar */
2889 wrap = false;
2890 if (rcon->target_rte->lateral &&
2891 !bms_is_subset(((PlaceHolderVar *) newnode)->phrels,
2892 rcon->relids))
2893 {
2894 nullingrel_info *nullinfo = rcon->nullinfo;
2895 Relids lvarnos = ((PlaceHolderVar *) newnode)->phrels;
2896 int lvarno;
2897
2898 lvarno = -1;
2899 while ((lvarno = bms_next_member(lvarnos, lvarno)) >= 0)
2900 {
2901 Assert(lvarno > 0 && lvarno <= nullinfo->rtlength);
2902 if (!bms_is_subset(nullinfo->nullingrels[rcon->varno],
2903 nullinfo->nullingrels[lvarno]))
2904 {
2905 wrap = true;
2906 break;
2907 }
2908 }
2909 }
2910 }
2911 else
2912 {
2913 /*
2914 * If the node contains Var(s) or PlaceHolderVar(s) of the
2915 * subquery being pulled up, or of rels that are under the
2916 * same lowest nulling outer join as the subquery, and does
2917 * not contain any non-strict constructs, then instead of
2918 * adding a PHV on top we can add the required nullingrels to
2919 * those Vars/PHVs. (This is fundamentally a generalization
2920 * of the above cases for bare Vars and PHVs.)
2921 *
2922 * This test is somewhat expensive, but it avoids pessimizing
2923 * the plan in cases where the nullingrels get removed again
2924 * later by outer join reduction.
2925 *
2926 * Note that we don't force wrapping of expressions containing
2927 * lateral references, so long as they also contain Vars/PHVs
2928 * of the subquery, or of rels that are under the same lowest
2929 * nulling outer join as the subquery. This is okay because
2930 * of the restriction to strict constructs: if those Vars/PHVs
2931 * have been forced to NULL by an outer join then the end
2932 * result of the expression will be NULL too, regardless of
2933 * the lateral references. So it's not necessary to force the
2934 * expression to be evaluated below the outer join. This can
2935 * be a very valuable optimization, because it may allow us to
2936 * avoid using a nested loop to pass the lateral reference
2937 * down.
2938 *
2939 * This analysis could be tighter: in particular, a non-strict
2940 * construct hidden within a lower-level PlaceHolderVar is not
2941 * reason to add another PHV. But for now it doesn't seem
2942 * worth the code to be more exact. This is also why it's
2943 * preferable to handle bare PHVs in the above branch, rather
2944 * than this branch. We also prefer to handle bare Vars in a
2945 * separate branch, as it's cheaper this way and parallels the
2946 * handling of PHVs.
2947 *
2948 * For a LATERAL subquery, we have to check the actual var
2949 * membership of the node, but if it's non-lateral then any
2950 * level-zero var must belong to the subquery.
2951 */
2952 bool contain_nullable_vars = false;
2953
2954 if (!rcon->target_rte->lateral)
2955 {
2956 if (contain_vars_of_level(newnode, 0))
2957 contain_nullable_vars = true;
2958 }
2959 else
2960 {
2961 Relids all_varnos;
2962
2963 all_varnos = pull_varnos(rcon->root, newnode);
2964 if (bms_overlap(all_varnos, rcon->relids))
2965 contain_nullable_vars = true;
2966 else
2967 {
2968 nullingrel_info *nullinfo = rcon->nullinfo;
2969 int varno;
2970
2971 varno = -1;
2972 while ((varno = bms_next_member(all_varnos, varno)) >= 0)
2973 {
2974 Assert(varno > 0 && varno <= nullinfo->rtlength);
2975 if (bms_is_subset(nullinfo->nullingrels[rcon->varno],
2976 nullinfo->nullingrels[varno]))
2977 {
2978 contain_nullable_vars = true;
2979 break;
2980 }
2981 }
2982 }
2983 }
2984
2985 if (contain_nullable_vars &&
2986 !contain_nonstrict_functions(newnode))
2987 {
2988 /* No wrap needed */
2989 wrap = false;
2990 }
2991 else
2992 {
2993 /* Else wrap it in a PlaceHolderVar */
2994 wrap = true;
2995 }
2996 }
2997
2998 if (wrap)
2999 {
3000 newnode = (Node *)
3001 make_placeholder_expr(rcon->root,
3002 (Expr *) newnode,
3003 bms_make_singleton(rcon->varno));
3004
3005 /*
3006 * Cache it if possible (ie, if the attno is in range, which
3007 * it probably always should be).
3008 */
3009 if (varattno >= InvalidAttrNumber &&
3010 varattno <= list_length(rcon->targetlist))
3011 rcon->rv_cache[varattno] = copyObject(newnode);
3012 }
3013 }
3014 }
3015
3016 /* Propagate any varnullingrels into the replacement expression */
3017 if (var->varnullingrels != NULL)
3018 {
3019 if (IsA(newnode, Var))
3020 {
3021 Var *newvar = (Var *) newnode;
3022
3023 Assert(newvar->varlevelsup == 0);
3024 newvar->varnullingrels = bms_add_members(newvar->varnullingrels,
3025 var->varnullingrels);
3026 }
3027 else if (IsA(newnode, PlaceHolderVar))
3028 {
3029 PlaceHolderVar *newphv = (PlaceHolderVar *) newnode;
3030
3031 Assert(newphv->phlevelsup == 0);
3032 newphv->phnullingrels = bms_add_members(newphv->phnullingrels,
3033 var->varnullingrels);
3034 }
3035 else
3036 {
3037 /*
3038 * There should be Vars/PHVs within the expression that we can
3039 * modify. Vars/PHVs of the subquery should have the full
3040 * var->varnullingrels added to them, but if there are lateral
3041 * references within the expression, those must be marked with
3042 * only the nullingrels that potentially apply to them. (This
3043 * corresponds to the fact that the expression will now be
3044 * evaluated at the join level of the Var that we are replacing:
3045 * the lateral references may have bubbled up through fewer outer
3046 * joins than the subquery's Vars have. Per the discussion above,
3047 * we'll still get the right answers.) That relid set could be
3048 * different for different lateral relations, so we have to do
3049 * this work for each one.
3050 *
3051 * (Currently, the restrictions in is_simple_subquery() mean that
3052 * at most we have to remove the lowest outer join's relid from
3053 * the nullingrels of a lateral reference. However, we might
3054 * relax those restrictions someday, so let's do this right.)
3055 */
3056 if (rcon->target_rte->lateral)
3057 {
3058 nullingrel_info *nullinfo = rcon->nullinfo;
3059 Relids lvarnos;
3060 int lvarno;
3061
3062 /*
3063 * Identify lateral varnos used within newnode. We must do
3064 * this before injecting var->varnullingrels into the tree.
3065 */
3066 lvarnos = pull_varnos(rcon->root, newnode);
3067 lvarnos = bms_del_members(lvarnos, rcon->relids);
3068 /* For each one, add relevant nullingrels if any */
3069 lvarno = -1;
3070 while ((lvarno = bms_next_member(lvarnos, lvarno)) >= 0)
3071 {
3072 Relids lnullingrels;
3073
3074 Assert(lvarno > 0 && lvarno <= nullinfo->rtlength);
3075 lnullingrels = bms_intersect(var->varnullingrels,
3076 nullinfo->nullingrels[lvarno]);
3077 if (!bms_is_empty(lnullingrels))
3078 newnode = add_nulling_relids(newnode,
3079 bms_make_singleton(lvarno),
3080 lnullingrels);
3081 }
3082 }
3083
3084 /* Finally, deal with Vars/PHVs of the subquery itself */
3085 newnode = add_nulling_relids(newnode,
3086 rcon->relids,
3087 var->varnullingrels);
3088 /* Assert we did put the varnullingrels into the expression */
3089 Assert(bms_is_subset(var->varnullingrels,
3090 pull_varnos(rcon->root, newnode)));
3091 }
3092 }
3093
3094 /* Must adjust varlevelsup if replaced Var is within a subquery */
3095 if (var->varlevelsup > 0)
3096 IncrementVarSublevelsUp(newnode, var->varlevelsup, 0);
3097
3098 return newnode;
3099}
3100
3101/*
3102 * Apply pullup variable replacement to a subquery
3103 *
3104 * This needs to be different from pullup_replace_vars() because
3105 * replace_rte_variables will think that it shouldn't increment sublevels_up
3106 * before entering the Query; so we need to call it with sublevels_up == 1.
3107 */
3108static Query *
3109pullup_replace_vars_subquery(Query *query,
3110 pullup_replace_vars_context *context)
3111{
3112 Assert(IsA(query, Query));
3113 return (Query *) replace_rte_variables((Node *) query,
3114 context->varno, 1,
3115 pullup_replace_vars_callback,
3116 context,
3117 NULL);
3118}
3119
3120
3121/*
3122 * flatten_simple_union_all
3123 * Try to optimize top-level UNION ALL structure into an appendrel
3124 *
3125 * If a query's setOperations tree consists entirely of simple UNION ALL
3126 * operations, flatten it into an append relation, which we can process more
3127 * intelligently than the general setops case. Otherwise, do nothing.
3128 *
3129 * In most cases, this can succeed only for a top-level query, because for a
3130 * subquery in FROM, the parent query's invocation of pull_up_subqueries would
3131 * already have flattened the UNION via pull_up_simple_union_all. But there
3132 * are a few cases we can support here but not in that code path, for example
3133 * when the subquery also contains ORDER BY.
3134 */
3135void
3136flatten_simple_union_all(PlannerInfo *root)
3137{
3138 Query *parse = root->parse;
3139 SetOperationStmt *topop;
3140 Node *leftmostjtnode;
3141 int leftmostRTI;
3142 RangeTblEntry *leftmostRTE;
3143 int childRTI;
3144 RangeTblEntry *childRTE;
3145 RangeTblRef *rtr;
3146
3147 /* Shouldn't be called unless query has setops */
3148 topop = castNode(SetOperationStmt, parse->setOperations);
3149 Assert(topop);
3150
3151 /* Can't optimize away a recursive UNION */
3152 if (root->hasRecursion)
3153 return;
3154
3155 /*
3156 * Recursively check the tree of set operations. If not all UNION ALL
3157 * with identical column types, punt.
3158 */
3159 if (!is_simple_union_all_recurse((Node *) topop, parse, topop->colTypes))
3160 return;
3161
3162 /*
3163 * Locate the leftmost leaf query in the setops tree. The upper query's
3164 * Vars all refer to this RTE (see transformSetOperationStmt).
3165 */
3166 leftmostjtnode = topop->larg;
3167 while (leftmostjtnode && IsA(leftmostjtnode, SetOperationStmt))
3168 leftmostjtnode = ((SetOperationStmt *) leftmostjtnode)->larg;
3169 Assert(leftmostjtnode && IsA(leftmostjtnode, RangeTblRef));
3170 leftmostRTI = ((RangeTblRef *) leftmostjtnode)->rtindex;
3171 leftmostRTE = rt_fetch(leftmostRTI, parse->rtable);
3172 Assert(leftmostRTE->rtekind == RTE_SUBQUERY);
3173
3174 /*
3175 * Make a copy of the leftmost RTE and add it to the rtable. This copy
3176 * will represent the leftmost leaf query in its capacity as a member of
3177 * the appendrel. The original will represent the appendrel as a whole.
3178 * (We must do things this way because the upper query's Vars have to be
3179 * seen as referring to the whole appendrel.)
3180 */
3181 childRTE = copyObject(leftmostRTE);
3182 parse->rtable = lappend(parse->rtable, childRTE);
3183 childRTI = list_length(parse->rtable);
3184
3185 /* Modify the setops tree to reference the child copy */
3186 ((RangeTblRef *) leftmostjtnode)->rtindex = childRTI;
3187
3188 /* Modify the formerly-leftmost RTE to mark it as an appendrel parent */
3189 leftmostRTE->inh = true;
3190
3191 /*
3192 * Form a RangeTblRef for the appendrel, and insert it into FROM. The top
3193 * Query of a setops tree should have had an empty FromClause initially.
3194 */
3195 rtr = makeNode(RangeTblRef);
3196 rtr->rtindex = leftmostRTI;
3197 Assert(parse->jointree->fromlist == NIL);
3198 parse->jointree->fromlist = list_make1(rtr);
3199
3200 /*
3201 * Now pretend the query has no setops. We must do this before trying to
3202 * do subquery pullup, because of Assert in pull_up_simple_subquery.
3203 */
3204 parse->setOperations = NULL;
3205
3206 /*
3207 * Build AppendRelInfo information, and apply pull_up_subqueries to the
3208 * leaf queries of the UNION ALL. (We must do that now because they
3209 * weren't previously referenced by the jointree, and so were missed by
3210 * the main invocation of pull_up_subqueries.)
3211 */
3212 pull_up_union_leaf_queries((Node *) topop, root, leftmostRTI, parse, 0);
3213}
3214
3215
3216/*
3217 * reduce_outer_joins
3218 * Attempt to reduce outer joins to plain inner joins.
3219 *
3220 * The idea here is that given a query like
3221 * SELECT ... FROM a LEFT JOIN b ON (...) WHERE b.y = 42;
3222 * we can reduce the LEFT JOIN to a plain JOIN if the "=" operator in WHERE
3223 * is strict. The strict operator will always return NULL, causing the outer
3224 * WHERE to fail, on any row where the LEFT JOIN filled in NULLs for b's
3225 * columns. Therefore, there's no need for the join to produce null-extended
3226 * rows in the first place --- which makes it a plain join not an outer join.
3227 * (This scenario may not be very likely in a query written out by hand, but
3228 * it's reasonably likely when pushing quals down into complex views.)
3229 *
3230 * More generally, an outer join can be reduced in strength if there is a
3231 * strict qual above it in the qual tree that constrains a Var from the
3232 * nullable side of the join to be non-null. (For FULL joins this applies
3233 * to each side separately.)
3234 *
3235 * Another transformation we apply here is to recognize cases like
3236 * SELECT ... FROM a LEFT JOIN b ON (a.x = b.y) WHERE b.z IS NULL;
3237 * If we can prove that b.z must be non-null for any matching row, either
3238 * because the join clause is strict for b.z and b.z happens to be the join
3239 * key b.y, or because b.z is defined NOT NULL by table constraints and is
3240 * not nullable due to lower-level outer joins, then only null-extended rows
3241 * could pass the upper WHERE, and we can conclude that what the query is
3242 * really specifying is an anti-semijoin. We change the join type from
3243 * JOIN_LEFT to JOIN_ANTI. The IS NULL clause then becomes redundant, and
3244 * must be removed to prevent bogus selectivity calculations, but we leave
3245 * it to distribute_qual_to_rels to get rid of such clauses.
3246 *
3247 * Also, we get rid of JOIN_RIGHT cases by flipping them around to become
3248 * JOIN_LEFT. This saves some code here and in some later planner routines;
3249 * the main benefit is to reduce the number of jointypes that can appear in
3250 * SpecialJoinInfo nodes. Note that we can still generate Paths and Plans
3251 * that use JOIN_RIGHT (or JOIN_RIGHT_ANTI) by switching the inputs again.
3252 *
3253 * To ease recognition of strict qual clauses, we require this routine to be
3254 * run after expression preprocessing (i.e., qual canonicalization and JOIN
3255 * alias-var expansion).
3256 */
3257void
3258reduce_outer_joins(PlannerInfo *root)
3259{
3260 reduce_outer_joins_pass1_state *state1;
3261 reduce_outer_joins_pass2_state state2;
3262 ListCell *lc;
3263
3264 /*
3265 * To avoid doing strictness checks on more quals than necessary, we want
3266 * to stop descending the jointree as soon as there are no outer joins
3267 * below our current point. This consideration forces a two-pass process.
3268 * The first pass gathers information about which base rels appear below
3269 * each side of each join clause, about whether there are outer join(s)
3270 * below each side of each join clause, and about which base rels are from
3271 * the nullable side of those outer join(s). The second pass examines
3272 * qual clauses and changes join types as it descends the tree.
3273 */
3274 state1 = reduce_outer_joins_pass1((Node *) root->parse->jointree);
3275
3276 /* planner.c shouldn't have called me if no outer joins */
3277 if (state1 == NULL || !state1->contains_outer)
3278 elog(ERROR, "so where are the outer joins?");
3279
3280 state2.inner_reduced = NULL;
3281 state2.partial_reduced = NIL;
3282
3283 reduce_outer_joins_pass2((Node *) root->parse->jointree,
3284 state1, &state2,
3285 root, NULL, NIL);
3286
3287 /*
3288 * If we successfully reduced the strength of any outer joins, we must
3289 * remove references to those joins as nulling rels. This is handled as
3290 * an additional pass, for simplicity and because we can handle all
3291 * fully-reduced joins in a single pass over the parse tree.
3292 */
3293 if (!bms_is_empty(state2.inner_reduced))
3294 {
3295 root->parse = (Query *)
3296 remove_nulling_relids((Node *) root->parse,
3297 state2.inner_reduced,
3298 NULL);
3299 /* There could be references in the append_rel_list, too */
3300 root->append_rel_list = (List *)
3301 remove_nulling_relids((Node *) root->append_rel_list,
3302 state2.inner_reduced,
3303 NULL);
3304 }
3305
3306 /*
3307 * Partially-reduced full joins have to be done one at a time, since
3308 * they'll each need a different setting of except_relids.
3309 */
3310 foreach(lc, state2.partial_reduced)
3311 {
3312 reduce_outer_joins_partial_state *statep = lfirst(lc);
3313 Relids full_join_relids = bms_make_singleton(statep->full_join_rti);
3314
3315 root->parse = (Query *)
3316 remove_nulling_relids((Node *) root->parse,
3317 full_join_relids,
3318 statep->unreduced_side);
3319 root->append_rel_list = (List *)
3320 remove_nulling_relids((Node *) root->append_rel_list,
3321 full_join_relids,
3322 statep->unreduced_side);
3323 }
3324}
3325
3326/*
3327 * reduce_outer_joins_pass1 - phase 1 data collection
3328 *
3329 * Returns a state node describing the given jointree node.
3330 */
3331static reduce_outer_joins_pass1_state *
3332reduce_outer_joins_pass1(Node *jtnode)
3333{
3334 reduce_outer_joins_pass1_state *result;
3335
3336 result = palloc_object(reduce_outer_joins_pass1_state);
3337 result->relids = NULL;
3338 result->contains_outer = false;
3339 result->nullable_rels = NULL;
3340 result->sub_states = NIL;
3341
3342 if (jtnode == NULL)
3343 return result;
3344 if (IsA(jtnode, RangeTblRef))
3345 {
3346 int varno = ((RangeTblRef *) jtnode)->rtindex;
3347
3348 result->relids = bms_make_singleton(varno);
3349 }
3350 else if (IsA(jtnode, FromExpr))
3351 {
3352 FromExpr *f = (FromExpr *) jtnode;
3353 ListCell *l;
3354
3355 foreach(l, f->fromlist)
3356 {
3357 reduce_outer_joins_pass1_state *sub_state;
3358
3359 sub_state = reduce_outer_joins_pass1(lfirst(l));
3360 result->relids = bms_add_members(result->relids,
3361 sub_state->relids);
3362 result->contains_outer |= sub_state->contains_outer;
3363 result->nullable_rels = bms_add_members(result->nullable_rels,
3364 sub_state->nullable_rels);
3365 result->sub_states = lappend(result->sub_states, sub_state);
3366 }
3367 }
3368 else if (IsA(jtnode, JoinExpr))
3369 {
3370 JoinExpr *j = (JoinExpr *) jtnode;
3371 reduce_outer_joins_pass1_state *left_state;
3372 reduce_outer_joins_pass1_state *right_state;
3373
3374 /* Recurse to children */
3375 left_state = reduce_outer_joins_pass1(j->larg);
3376 right_state = reduce_outer_joins_pass1(j->rarg);
3377
3378 /* join's own RT index is not wanted in result->relids */
3379 result->relids = bms_union(left_state->relids, right_state->relids);
3380
3381 /* Store children's states for pass 2 */
3382 result->sub_states = list_make2(left_state, right_state);
3383
3384 /* Collect outer join information */
3385 switch (j->jointype)
3386 {
3387 case JOIN_INNER:
3388 case JOIN_SEMI:
3389 /* No new nullability; propagate state from children */
3390 result->contains_outer = left_state->contains_outer ||
3391 right_state->contains_outer;
3392 result->nullable_rels = bms_union(left_state->nullable_rels,
3393 right_state->nullable_rels);
3394 break;
3395 case JOIN_LEFT:
3396 case JOIN_ANTI:
3397 /* RHS is nullable; LHS keeps existing status */
3398 result->contains_outer = true;
3399 result->nullable_rels = bms_union(left_state->nullable_rels,
3400 right_state->relids);
3401 break;
3402 case JOIN_RIGHT:
3403 /* LHS is nullable; RHS keeps existing status */
3404 result->contains_outer = true;
3405 result->nullable_rels = bms_union(left_state->relids,
3406 right_state->nullable_rels);
3407 break;
3408 case JOIN_FULL:
3409 /* Both sides are nullable */
3410 result->contains_outer = true;
3411 result->nullable_rels = bms_union(left_state->relids,
3412 right_state->relids);
3413 break;
3414 default:
3415 elog(ERROR, "unrecognized join type: %d",
3416 (int) j->jointype);
3417 break;
3418 }
3419 }
3420 else
3421 elog(ERROR, "unrecognized node type: %d",
3422 (int) nodeTag(jtnode));
3423 return result;
3424}
3425
3426/*
3427 * reduce_outer_joins_pass2 - phase 2 processing
3428 *
3429 * jtnode: current jointree node
3430 * state1: state data collected by phase 1 for this node
3431 * state2: where to accumulate info about successfully-reduced joins
3432 * root: toplevel planner state
3433 * nonnullable_rels: set of base relids forced non-null by upper quals
3434 * forced_null_vars: multibitmapset of Vars forced null by upper quals
3435 *
3436 * Returns info in state2 about outer joins that were successfully simplified.
3437 * Joins that were fully reduced to inner joins are all added to
3438 * state2->inner_reduced. If a full join is reduced to a left join,
3439 * it needs its own entry in state2->partial_reduced, since that will
3440 * require custom processing to remove only the correct nullingrel markers.
3441 */
3442static void
3443reduce_outer_joins_pass2(Node *jtnode,
3444 reduce_outer_joins_pass1_state *state1,
3445 reduce_outer_joins_pass2_state *state2,
3446 PlannerInfo *root,
3447 Relids nonnullable_rels,
3448 List *forced_null_vars)
3449{
3450 /*
3451 * pass 2 should never descend as far as an empty subnode or base rel,
3452 * because it's only called on subtrees marked as contains_outer.
3453 */
3454 if (jtnode == NULL)
3455 elog(ERROR, "reached empty jointree");
3456 if (IsA(jtnode, RangeTblRef))
3457 elog(ERROR, "reached base rel");
3458 else if (IsA(jtnode, FromExpr))
3459 {
3460 FromExpr *f = (FromExpr *) jtnode;
3461 ListCell *l;
3462 ListCell *s;
3463 Relids pass_nonnullable_rels;
3464 List *pass_forced_null_vars;
3465
3466 /* Scan quals to see if we can add any constraints */
3467 pass_nonnullable_rels = find_nonnullable_rels(f->quals);
3468 pass_nonnullable_rels = bms_add_members(pass_nonnullable_rels,
3469 nonnullable_rels);
3470 pass_forced_null_vars = find_forced_null_vars(f->quals);
3471 pass_forced_null_vars = mbms_add_members(pass_forced_null_vars,
3472 forced_null_vars);
3473 /* And recurse --- but only into interesting subtrees */
3474 Assert(list_length(f->fromlist) == list_length(state1->sub_states));
3475 forboth(l, f->fromlist, s, state1->sub_states)
3476 {
3477 reduce_outer_joins_pass1_state *sub_state = lfirst(s);
3478
3479 if (sub_state->contains_outer)
3480 reduce_outer_joins_pass2(lfirst(l), sub_state,
3481 state2, root,
3482 pass_nonnullable_rels,
3483 pass_forced_null_vars);
3484 }
3485 bms_free(pass_nonnullable_rels);
3486 /* can't so easily clean up var lists, unfortunately */
3487 }
3488 else if (IsA(jtnode, JoinExpr))
3489 {
3490 JoinExpr *j = (JoinExpr *) jtnode;
3491 int rtindex = j->rtindex;
3492 JoinType jointype = j->jointype;
3493 reduce_outer_joins_pass1_state *left_state = linitial(state1->sub_states);
3494 reduce_outer_joins_pass1_state *right_state = lsecond(state1->sub_states);
3495
3496 /* Can we simplify this join? */
3497 switch (jointype)
3498 {
3499 case JOIN_INNER:
3500 break;
3501 case JOIN_LEFT:
3502 if (bms_overlap(nonnullable_rels, right_state->relids))
3503 jointype = JOIN_INNER;
3504 break;
3505 case JOIN_RIGHT:
3506 if (bms_overlap(nonnullable_rels, left_state->relids))
3507 jointype = JOIN_INNER;
3508 break;
3509 case JOIN_FULL:
3510 if (bms_overlap(nonnullable_rels, left_state->relids))
3511 {
3512 if (bms_overlap(nonnullable_rels, right_state->relids))
3513 jointype = JOIN_INNER;
3514 else
3515 {
3516 jointype = JOIN_LEFT;
3517 /* Also report partial reduction in state2 */
3518 report_reduced_full_join(state2, rtindex,
3519 right_state->relids);
3520 }
3521 }
3522 else
3523 {
3524 if (bms_overlap(nonnullable_rels, right_state->relids))
3525 {
3526 jointype = JOIN_RIGHT;
3527 /* Also report partial reduction in state2 */
3528 report_reduced_full_join(state2, rtindex,
3529 left_state->relids);
3530 }
3531 }
3532 break;
3533 case JOIN_SEMI:
3534 case JOIN_ANTI:
3535
3536 /*
3537 * These could only have been introduced by pull_up_sublinks,
3538 * so there's no way that upper quals could refer to their
3539 * righthand sides, and no point in checking. We don't expect
3540 * to see JOIN_RIGHT_SEMI or JOIN_RIGHT_ANTI yet.
3541 */
3542 break;
3543 default:
3544 elog(ERROR, "unrecognized join type: %d",
3545 (int) jointype);
3546 break;
3547 }
3548
3549 /*
3550 * Convert JOIN_RIGHT to JOIN_LEFT. Note that in the case where we
3551 * reduced JOIN_FULL to JOIN_RIGHT, this will mean the JoinExpr no
3552 * longer matches the internal ordering of any CoalesceExpr's built to
3553 * represent merged join variables. We don't care about that at
3554 * present, but be wary of it ...
3555 */
3556 if (jointype == JOIN_RIGHT)
3557 {
3558 Node *tmparg;
3559
3560 tmparg = j->larg;
3561 j->larg = j->rarg;
3562 j->rarg = tmparg;
3563 jointype = JOIN_LEFT;
3564 right_state = linitial(state1->sub_states);
3565 left_state = lsecond(state1->sub_states);
3566 }
3567
3568 /*
3569 * See if we can reduce JOIN_LEFT to JOIN_ANTI. This is the case if
3570 * any var from the RHS was forced null by higher qual levels, but is
3571 * known to be non-nullable. We detect this either by seeing if the
3572 * join's own quals are strict for the var, or by checking if the var
3573 * is defined NOT NULL by table constraints (being careful to exclude
3574 * vars that are nullable due to lower-level outer joins). In either
3575 * case, the only way the higher qual clause's requirement for NULL
3576 * can be met is if the join fails to match, producing a null-extended
3577 * row. Thus, we can treat this as an anti-join.
3578 */
3579 if (jointype == JOIN_LEFT && forced_null_vars != NIL)
3580 {
3581 List *nonnullable_vars;
3582 Bitmapset *overlap;
3583
3584 /* Find Vars in j->quals that must be non-null in joined rows */
3585 nonnullable_vars = find_nonnullable_vars(j->quals);
3586
3587 /*
3588 * It's not sufficient to check whether nonnullable_vars and
3589 * forced_null_vars overlap: we need to know if the overlap
3590 * includes any RHS variables.
3591 *
3592 * Also check if any forced-null var is defined NOT NULL by table
3593 * constraints.
3594 */
3595 overlap = mbms_overlap_sets(nonnullable_vars, forced_null_vars);
3596 if (bms_overlap(overlap, right_state->relids) ||
3597 has_notnull_forced_var(root, forced_null_vars, right_state))
3598 jointype = JOIN_ANTI;
3599 }
3600
3601 /*
3602 * Apply the jointype change, if any, to both jointree node and RTE.
3603 * Also, if we changed an RTE to INNER, add its RTI to inner_reduced.
3604 */
3605 if (rtindex && jointype != j->jointype)
3606 {
3607 RangeTblEntry *rte = rt_fetch(rtindex, root->parse->rtable);
3608
3609 Assert(rte->rtekind == RTE_JOIN);
3610 Assert(rte->jointype == j->jointype);
3611 rte->jointype = jointype;
3612 if (jointype == JOIN_INNER)
3613 state2->inner_reduced = bms_add_member(state2->inner_reduced,
3614 rtindex);
3615 }
3616 j->jointype = jointype;
3617
3618 /* Only recurse if there's more to do below here */
3619 if (left_state->contains_outer || right_state->contains_outer)
3620 {
3621 Relids local_nonnullable_rels;
3622 List *local_forced_null_vars;
3623 Relids pass_nonnullable_rels;
3624 List *pass_forced_null_vars;
3625
3626 /*
3627 * If this join is (now) inner, we can add any constraints its
3628 * quals provide to those we got from above. But if it is outer,
3629 * we can pass down the local constraints only into the nullable
3630 * side, because an outer join never eliminates any rows from its
3631 * non-nullable side. Also, there is no point in passing upper
3632 * constraints into the nullable side, since if there were any
3633 * we'd have been able to reduce the join. (In the case of upper
3634 * forced-null constraints, we *must not* pass them into the
3635 * nullable side --- they either applied here, or not.) The upshot
3636 * is that we pass either the local or the upper constraints,
3637 * never both, to the children of an outer join.
3638 *
3639 * Note that a SEMI join works like an inner join here: it's okay
3640 * to pass down both local and upper constraints. (There can't be
3641 * any upper constraints affecting its inner side, but it's not
3642 * worth having a separate code path to avoid passing them.)
3643 *
3644 * At a FULL join we just punt and pass nothing down --- is it
3645 * possible to be smarter?
3646 */
3647 if (jointype != JOIN_FULL)
3648 {
3649 local_nonnullable_rels = find_nonnullable_rels(j->quals);
3650 local_forced_null_vars = find_forced_null_vars(j->quals);
3651 if (jointype == JOIN_INNER || jointype == JOIN_SEMI)
3652 {
3653 /* OK to merge upper and local constraints */
3654 local_nonnullable_rels = bms_add_members(local_nonnullable_rels,
3655 nonnullable_rels);
3656 local_forced_null_vars = mbms_add_members(local_forced_null_vars,
3657 forced_null_vars);
3658 }
3659 }
3660 else
3661 {
3662 /* no use in calculating these */
3663 local_nonnullable_rels = NULL;
3664 local_forced_null_vars = NIL;
3665 }
3666
3667 if (left_state->contains_outer)
3668 {
3669 if (jointype == JOIN_INNER || jointype == JOIN_SEMI)
3670 {
3671 /* pass union of local and upper constraints */
3672 pass_nonnullable_rels = local_nonnullable_rels;
3673 pass_forced_null_vars = local_forced_null_vars;
3674 }
3675 else if (jointype != JOIN_FULL) /* ie, LEFT or ANTI */
3676 {
3677 /* can't pass local constraints to non-nullable side */
3678 pass_nonnullable_rels = nonnullable_rels;
3679 pass_forced_null_vars = forced_null_vars;
3680 }
3681 else
3682 {
3683 /* no constraints pass through JOIN_FULL */
3684 pass_nonnullable_rels = NULL;
3685 pass_forced_null_vars = NIL;
3686 }
3687 reduce_outer_joins_pass2(j->larg, left_state,
3688 state2, root,
3689 pass_nonnullable_rels,
3690 pass_forced_null_vars);
3691 }
3692
3693 if (right_state->contains_outer)
3694 {
3695 if (jointype != JOIN_FULL) /* ie, INNER/LEFT/SEMI/ANTI */
3696 {
3697 /* pass appropriate constraints, per comment above */
3698 pass_nonnullable_rels = local_nonnullable_rels;
3699 pass_forced_null_vars = local_forced_null_vars;
3700 }
3701 else
3702 {
3703 /* no constraints pass through JOIN_FULL */
3704 pass_nonnullable_rels = NULL;
3705 pass_forced_null_vars = NIL;
3706 }
3707 reduce_outer_joins_pass2(j->rarg, right_state,
3708 state2, root,
3709 pass_nonnullable_rels,
3710 pass_forced_null_vars);
3711 }
3712 bms_free(local_nonnullable_rels);
3713 }
3714 }
3715 else
3716 elog(ERROR, "unrecognized node type: %d",
3717 (int) nodeTag(jtnode));
3718}
3719
3720/* Helper for reduce_outer_joins_pass2 */
3721static void
3722report_reduced_full_join(reduce_outer_joins_pass2_state *state2,
3723 int rtindex, Relids relids)
3724{
3725 reduce_outer_joins_partial_state *statep;
3726
3727 statep = palloc_object(reduce_outer_joins_partial_state);
3728 statep->full_join_rti = rtindex;
3729 statep->unreduced_side = relids;
3730 state2->partial_reduced = lappend(state2->partial_reduced, statep);
3731}
3732
3733/*
3734 * has_notnull_forced_var
3735 * Check if "forced_null_vars" contains any Vars belonging to the subtree
3736 * indicated by "right_state" that are known to be non-nullable due to
3737 * table constraints.
3738 *
3739 * Note that we must also consider the situation where a NOT NULL Var can be
3740 * nulled by lower-level outer joins.
3741 *
3742 * Helper for reduce_outer_joins_pass2.
3743 */
3744static bool
3745has_notnull_forced_var(PlannerInfo *root, List *forced_null_vars,
3746 reduce_outer_joins_pass1_state *right_state)
3747{
3748 int varno = -1;
3749
3750 foreach_node(Bitmapset, attrs, forced_null_vars)
3751 {
3752 RangeTblEntry *rte;
3753 Bitmapset *notnullattnums;
3754 Bitmapset *forcednullattnums = NULL;
3755 int lowest_attno;
3756
3757 varno++;
3758
3759 /* Skip empty bitmaps */
3760 if (bms_is_empty(attrs))
3761 continue;
3762
3763 /* Skip Vars that do not belong to the target relations */
3764 if (!bms_is_member(varno, right_state->relids))
3765 continue;
3766
3767 /*
3768 * Skip Vars that can be nulled by lower-level outer joins within the
3769 * given subtree. These Vars might be NULL even if the schema defines
3770 * them as NOT NULL.
3771 */
3772 if (bms_is_member(varno, right_state->nullable_rels))
3773 continue;
3774
3775 /* find the lowest member to check if system columns are present */
3776 lowest_attno = bms_next_member(attrs, -1);
3777
3778 /* we checked for an empty set above */
3779 Assert(lowest_attno >= 0);
3780
3781 /* system columns cannot be NULL */
3782 if (lowest_attno + FirstLowInvalidHeapAttributeNumber < 0)
3783 return true;
3784
3785 /*
3786 * Offset the bitmap members by FirstLowInvalidHeapAttributeNumber to
3787 * get the actual attribute numbers.
3788 */
3789 forcednullattnums = bms_offset_members(attrs,
3790 FirstLowInvalidHeapAttributeNumber);
3791
3792 rte = rt_fetch(varno, root->parse->rtable);
3793
3794 /* We can only reason about ordinary relations */
3795 if (rte->rtekind != RTE_RELATION)
3796 {
3797 bms_free(forcednullattnums);
3798 continue;
3799 }
3800
3801 /*
3802 * We must skip inheritance parent tables, as some child tables may
3803 * have a NOT NULL constraint for a column while others may not. This
3804 * cannot happen with partitioned tables, though.
3805 */
3806 if (rte->inh && rte->relkind != RELKIND_PARTITIONED_TABLE)
3807 {
3808 bms_free(forcednullattnums);
3809 continue;
3810 }
3811
3812 /* Get the column not-null constraint information for this relation */
3813 notnullattnums = find_relation_notnullatts(root, rte->relid);
3814
3815 /*
3816 * Check if any forced-null attributes are defined as NOT NULL by
3817 * table constraints.
3818 */
3819 if (bms_overlap(notnullattnums, forcednullattnums))
3820 {
3821 bms_free(forcednullattnums);
3822 return true;
3823 }
3824
3825 bms_free(forcednullattnums);
3826 }
3827
3828 return false;
3829}
3830
3831
3832/*
3833 * remove_useless_result_rtes
3834 * Attempt to remove RTE_RESULT RTEs from the join tree.
3835 * Also, elide single-child FromExprs where possible.
3836 *
3837 * We can remove RTE_RESULT entries from the join tree using the knowledge
3838 * that RTE_RESULT returns exactly one row and has no output columns. Hence,
3839 * if one is inner-joined to anything else, we can delete it. Optimizations
3840 * are also possible for some outer-join cases, as detailed below.
3841 *
3842 * This pass also replaces single-child FromExprs with their child node
3843 * where possible. It's appropriate to do that here and not earlier because
3844 * RTE_RESULT removal might reduce a multiple-child FromExpr to have only one
3845 * child. We can remove such a FromExpr if its quals are empty, or if it's
3846 * semantically valid to merge the quals into those of the parent node.
3847 * While removing unnecessary join tree nodes has some micro-efficiency value,
3848 * the real reason to do this is to eliminate cases where the nullable side of
3849 * an outer join node is a FromExpr whose single child is another outer join.
3850 * To correctly determine whether the two outer joins can commute,
3851 * deconstruct_jointree() must treat any quals of such a FromExpr as being
3852 * degenerate quals of the upper outer join. The best way to do that is to
3853 * make them actually *be* quals of the upper join, by dropping the FromExpr
3854 * and hoisting the quals up into the upper join's quals. (Note that there is
3855 * no hazard when the intermediate FromExpr has multiple children, since then
3856 * it represents an inner join that cannot commute with the upper outer join.)
3857 * As long as we have to do that, we might as well elide such FromExprs
3858 * everywhere.
3859 *
3860 * Some of these optimizations depend on recognizing empty (constant-true)
3861 * quals for FromExprs and JoinExprs. That makes it useful to apply this
3862 * optimization pass after expression preprocessing, since that will have
3863 * eliminated constant-true quals, allowing more cases to be recognized as
3864 * optimizable. What's more, the usual reason for an RTE_RESULT to be present
3865 * is that we pulled up a subquery or VALUES clause, thus very possibly
3866 * replacing Vars with constants, making it more likely that a qual can be
3867 * reduced to constant true. Also, because some optimizations depend on
3868 * the outer-join type, it's best to have done reduce_outer_joins() first.
3869 *
3870 * A PlaceHolderVar referencing an RTE_RESULT RTE poses an obstacle to this
3871 * process: we must remove the RTE_RESULT's relid from the PHV's phrels, but
3872 * we must not reduce the phrels set to empty. If that would happen, and
3873 * the RTE_RESULT is an immediate child of an outer join, we have to give up
3874 * and not remove the RTE_RESULT: there is noplace else to evaluate the
3875 * PlaceHolderVar. (That is, in such cases the RTE_RESULT *does* have output
3876 * columns.) But if the RTE_RESULT is an immediate child of an inner join,
3877 * we can usually change the PlaceHolderVar's phrels so as to evaluate it at
3878 * the inner join instead. This is OK because we really only care that PHVs
3879 * are evaluated above or below the correct outer joins. We can't, however,
3880 * postpone the evaluation of a PHV to above where it is used; so there are
3881 * some checks below on whether output PHVs are laterally referenced in the
3882 * other join input rel(s).
3883 *
3884 * We used to try to do this work as part of pull_up_subqueries() where the
3885 * potentially-optimizable cases get introduced; but it's way simpler, and
3886 * more effective, to do it separately.
3887 */
3888void
3889remove_useless_result_rtes(PlannerInfo *root)
3890{
3891 Relids baserels = NULL;
3892 Relids dropped_outer_joins = NULL;
3893 ListCell *cell;
3894
3895 /*
3896 * We'll need the set of baserels in the jointree to perform
3897 * find_dependent_phvs() checks. But if there are no PHVs anywhere in the
3898 * query, those checks are no-ops, so we can skip the work.
3899 */
3900 if (root->glob->lastPHId != 0)
3901 baserels = get_relids_in_jointree((Node *) root->parse->jointree,
3902 false, false);
3903
3904 /* Top level of jointree must always be a FromExpr */
3905 Assert(IsA(root->parse->jointree, FromExpr));
3906 /* Recurse ... */
3907 root->parse->jointree = (FromExpr *)
3908 remove_useless_results_recurse(root,
3909 (Node *) root->parse->jointree,
3910 baserels,
3911 NULL,
3912 &dropped_outer_joins);
3913 /* We should still have a FromExpr */
3914 Assert(IsA(root->parse->jointree, FromExpr));
3915
3916 /*
3917 * If we removed any outer-join nodes from the jointree, run around and
3918 * remove references to those joins as nulling rels. (There could be such
3919 * references in PHVs that we pulled up out of the original subquery that
3920 * the RESULT rel replaced. This is kosher on the grounds that we now
3921 * know that such an outer join wouldn't really have nulled anything.) We
3922 * don't do this during the main recursion, for simplicity and because we
3923 * can handle all such joins in a single pass over the parse tree.
3924 */
3925 if (!bms_is_empty(dropped_outer_joins))
3926 {
3927 root->parse = (Query *)
3928 remove_nulling_relids((Node *) root->parse,
3929 dropped_outer_joins,
3930 NULL);
3931 /* There could be references in the append_rel_list, too */
3932 root->append_rel_list = (List *)
3933 remove_nulling_relids((Node *) root->append_rel_list,
3934 dropped_outer_joins,
3935 NULL);
3936 }
3937
3938 /*
3939 * Remove any PlanRowMark referencing an RTE_RESULT RTE. We obviously
3940 * must do that for any RTE_RESULT that we just removed. But one for a
3941 * RTE that we did not remove can be dropped anyway: since the RTE has
3942 * only one possible output row, there is no need for EPQ to mark and
3943 * restore that row.
3944 *
3945 * It's necessary, not optional, to remove the PlanRowMark for a surviving
3946 * RTE_RESULT RTE; otherwise we'll generate a whole-row Var for the
3947 * RTE_RESULT, which the executor has no support for.
3948 */
3949 foreach(cell, root->rowMarks)
3950 {
3951 PlanRowMark *rc = (PlanRowMark *) lfirst(cell);
3952
3953 if (rt_fetch(rc->rti, root->parse->rtable)->rtekind == RTE_RESULT)
3954 root->rowMarks = foreach_delete_current(root->rowMarks, cell);
3955 }
3956}
3957
3958/*
3959 * remove_useless_results_recurse
3960 * Recursive guts of remove_useless_result_rtes.
3961 *
3962 * This recursively processes the jointree and returns a modified jointree.
3963 * In addition, the RT indexes of any removed outer-join nodes are added to
3964 * *dropped_outer_joins.
3965 *
3966 * jtnode is the current jointree node. If it could be valid to merge
3967 * its quals into those of the parent node, parent_quals should point to
3968 * the parent's quals list; otherwise, pass NULL for parent_quals.
3969 * (Note that in some cases, parent_quals points to the quals of a parent
3970 * more than one level up in the tree.)
3971 *
3972 * baserels is the set of base (non-join) RT indexes in the whole jointree;
3973 * it can be NULL if the query contains no PHVs.
3974 */
3975static Node *
3976remove_useless_results_recurse(PlannerInfo *root, Node *jtnode,
3977 Relids baserels,
3978 Node **parent_quals,
3979 Relids *dropped_outer_joins)
3980{
3981 Assert(jtnode != NULL);
3982 if (IsA(jtnode, RangeTblRef))
3983 {
3984 /* Can't immediately do anything with a RangeTblRef */
3985 }
3986 else if (IsA(jtnode, FromExpr))
3987 {
3988 FromExpr *f = (FromExpr *) jtnode;
3989 Relids result_relids = NULL;
3990 ListCell *cell;
3991
3992 /*
3993 * We can drop RTE_RESULT rels from the fromlist so long as at least
3994 * one child remains, since joining to a one-row table changes
3995 * nothing. (But we can't drop a RTE_RESULT that computes PHV(s) that
3996 * are needed by some sibling. The cleanup transformation below would
3997 * reassign the PHVs to be computed at the join, which is too late for
3998 * the sibling's use.) The easiest way to mechanize this rule is to
3999 * modify the list in-place.
4000 */
4001 foreach(cell, f->fromlist)
4002 {
4003 Node *child = (Node *) lfirst(cell);
4004 int varno;
4005
4006 /* Recursively transform child, allowing it to push up quals ... */
4007 child = remove_useless_results_recurse(root, child,
4008 baserels,
4009 &f->quals,
4010 dropped_outer_joins);
4011 /* ... and stick it back into the tree */
4012 lfirst(cell) = child;
4013
4014 /*
4015 * If it's an RTE_RESULT with at least one sibling, and no sibling
4016 * references dependent PHVs, we can drop it. We don't yet know
4017 * what the inner join's final relid set will be, so postpone
4018 * cleanup of PHVs etc till after this loop.
4019 */
4020 if (list_length(f->fromlist) > 1 &&
4021 (varno = get_result_relid(root, child)) != 0 &&
4022 !find_dependent_phvs_in_jointree(root, (Node *) f, varno,
4023 baserels))
4024 {
4025 f->fromlist = foreach_delete_current(f->fromlist, cell);
4026 result_relids = bms_add_member(result_relids, varno);
4027 }
4028 }
4029
4030 /*
4031 * Clean up if we dropped any RTE_RESULT RTEs. This is a bit
4032 * inefficient if there's more than one, but it seems better to
4033 * optimize the support code for the single-relid case.
4034 */
4035 if (result_relids)
4036 {
4037 int varno = -1;
4038
4039 while ((varno = bms_next_member(result_relids, varno)) >= 0)
4040 remove_result_refs(root, varno, (Node *) f);
4041 }
4042
4043 /*
4044 * If the FromExpr now has only one child, see if we can elide it.
4045 * This is always valid if there are no quals, except at the top of
4046 * the jointree (since Query.jointree is required to point to a
4047 * FromExpr). Otherwise, we can do it if we can push the quals up to
4048 * the parent node.
4049 *
4050 * Note: while it would not be terribly hard to generalize this
4051 * transformation to merge multi-child FromExprs into their parent
4052 * FromExpr, that risks making the parent join too expensive to plan.
4053 * We leave it to later processing to decide heuristically whether
4054 * that's a good idea. Pulling up a single child is always OK,
4055 * however.
4056 */
4057 if (list_length(f->fromlist) == 1 &&
4058 f != root->parse->jointree &&
4059 (f->quals == NULL || parent_quals != NULL))
4060 {
4061 /*
4062 * Merge any quals up to parent. They should be in implicit-AND
4063 * format by now, so we just need to concatenate lists. Put the
4064 * child quals at the front, on the grounds that they should
4065 * nominally be evaluated earlier.
4066 */
4067 if (f->quals != NULL)
4068 *parent_quals = (Node *)
4069 list_concat(castNode(List, f->quals),
4070 castNode(List, *parent_quals));
4071 return (Node *) linitial(f->fromlist);
4072 }
4073 }
4074 else if (IsA(jtnode, JoinExpr))
4075 {
4076 JoinExpr *j = (JoinExpr *) jtnode;
4077 int varno;
4078
4079 /*
4080 * First, recurse. We can absorb pushed-up FromExpr quals from either
4081 * child into this node if the jointype is INNER, since then this is
4082 * equivalent to a FromExpr. When the jointype is LEFT, we can absorb
4083 * quals from the RHS child into the current node, as they're
4084 * essentially degenerate quals of the outer join. Moreover, if we've
4085 * been passed down a parent_quals pointer then we can allow quals of
4086 * the LHS child to be absorbed into the parent. (This is important
4087 * to ensure we remove single-child FromExprs immediately below
4088 * commutable left joins.) For other jointypes, we can't move child
4089 * quals up, or at least there's no particular reason to.
4090 */
4091 j->larg = remove_useless_results_recurse(root, j->larg,
4092 baserels,
4093 (j->jointype == JOIN_INNER) ?
4094 &j->quals :
4095 (j->jointype == JOIN_LEFT) ?
4096 parent_quals : NULL,
4097 dropped_outer_joins);
4098 j->rarg = remove_useless_results_recurse(root, j->rarg,
4099 baserels,
4100 (j->jointype == JOIN_INNER ||
4101 j->jointype == JOIN_LEFT) ?
4102 &j->quals : NULL,
4103 dropped_outer_joins);
4104
4105 /* Apply join-type-specific optimization rules */
4106 switch (j->jointype)
4107 {
4108 case JOIN_INNER:
4109
4110 /*
4111 * An inner join is equivalent to a FromExpr, so if either
4112 * side was simplified to an RTE_RESULT rel, we can replace
4113 * the join with a FromExpr with just the other side.
4114 * Furthermore, we can elide that FromExpr according to the
4115 * same rules as above.
4116 *
4117 * Just as in the FromExpr case, we can't simplify if the
4118 * other input rel references any PHVs that are marked as to
4119 * be evaluated at the RTE_RESULT rel, because we can't
4120 * postpone their evaluation in that case. But we only have
4121 * to check this in cases where it's syntactically legal for
4122 * the other input to have a LATERAL reference to the
4123 * RTE_RESULT rel. Only RHSes of inner and left joins are
4124 * allowed to have such refs.
4125 */
4126 if ((varno = get_result_relid(root, j->larg)) != 0 &&
4127 !find_dependent_phvs_in_jointree(root, j->rarg, varno,
4128 baserels))
4129 {
4130 remove_result_refs(root, varno, j->rarg);
4131 if (j->quals != NULL && parent_quals == NULL)
4132 jtnode = (Node *)
4133 makeFromExpr(list_make1(j->rarg), j->quals);
4134 else
4135 {
4136 /* Merge any quals up to parent */
4137 if (j->quals != NULL)
4138 *parent_quals = (Node *)
4139 list_concat(castNode(List, j->quals),
4140 castNode(List, *parent_quals));
4141 jtnode = j->rarg;
4142 }
4143 }
4144 else if ((varno = get_result_relid(root, j->rarg)) != 0)
4145 {
4146 remove_result_refs(root, varno, j->larg);
4147 if (j->quals != NULL && parent_quals == NULL)
4148 jtnode = (Node *)
4149 makeFromExpr(list_make1(j->larg), j->quals);
4150 else
4151 {
4152 /* Merge any quals up to parent */
4153 if (j->quals != NULL)
4154 *parent_quals = (Node *)
4155 list_concat(castNode(List, j->quals),
4156 castNode(List, *parent_quals));
4157 jtnode = j->larg;
4158 }
4159 }
4160 break;
4161 case JOIN_LEFT:
4162
4163 /*
4164 * We can simplify this case if the RHS is an RTE_RESULT, with
4165 * two different possibilities:
4166 *
4167 * If the qual is empty (JOIN ON TRUE), then the join can be
4168 * strength-reduced to a plain inner join, since each LHS row
4169 * necessarily has exactly one join partner. So we can always
4170 * discard the RHS, much as in the JOIN_INNER case above.
4171 * (Again, the LHS could not contain a lateral reference to
4172 * the RHS.)
4173 *
4174 * Otherwise, it's still true that each LHS row should be
4175 * returned exactly once, and since the RHS returns no columns
4176 * (unless there are PHVs that have to be evaluated there), we
4177 * don't much care if it's null-extended or not. So in this
4178 * case also, we can just ignore the qual and discard the left
4179 * join.
4180 */
4181 if ((varno = get_result_relid(root, j->rarg)) != 0 &&
4182 (j->quals == NULL ||
4183 !find_dependent_phvs(root, varno, baserels)))
4184 {
4185 remove_result_refs(root, varno, j->larg);
4186 *dropped_outer_joins = bms_add_member(*dropped_outer_joins,
4187 j->rtindex);
4188 jtnode = j->larg;
4189 }
4190 break;
4191 case JOIN_SEMI:
4192
4193 /*
4194 * We may simplify this case if the RHS is an RTE_RESULT; the
4195 * join qual becomes effectively just a filter qual for the
4196 * LHS, since we should either return the LHS row or not. The
4197 * filter clause must go into a new FromExpr if we can't push
4198 * it up to the parent.
4199 *
4200 * There is a fine point about PHVs that are supposed to be
4201 * evaluated at the RHS. Such PHVs could only appear in the
4202 * semijoin's qual, since the rest of the query cannot
4203 * reference any outputs of the semijoin's RHS. Therefore,
4204 * they can't actually go to null before being examined, and
4205 * it'd be OK to just remove the PHV wrapping. We don't have
4206 * infrastructure for that, but remove_result_refs() will
4207 * relabel them as to be evaluated at the LHS, which is fine.
4208 *
4209 * Also, we don't need to worry about removing traces of the
4210 * join's rtindex, since it hasn't got one.
4211 */
4212 if ((varno = get_result_relid(root, j->rarg)) != 0)
4213 {
4214 Assert(j->rtindex == 0);
4215 remove_result_refs(root, varno, j->larg);
4216 if (j->quals != NULL && parent_quals == NULL)
4217 jtnode = (Node *)
4218 makeFromExpr(list_make1(j->larg), j->quals);
4219 else
4220 {
4221 /* Merge any quals up to parent */
4222 if (j->quals != NULL)
4223 *parent_quals = (Node *)
4224 list_concat(castNode(List, j->quals),
4225 castNode(List, *parent_quals));
4226 jtnode = j->larg;
4227 }
4228 }
4229 break;
4230 case JOIN_FULL:
4231 case JOIN_ANTI:
4232 /* We have no special smarts for these cases */
4233 break;
4234 default:
4235 /* Note: JOIN_RIGHT should be gone at this point */
4236 elog(ERROR, "unrecognized join type: %d",
4237 (int) j->jointype);
4238 break;
4239 }
4240 }
4241 else
4242 elog(ERROR, "unrecognized node type: %d",
4243 (int) nodeTag(jtnode));
4244 return jtnode;
4245}
4246
4247/*
4248 * get_result_relid
4249 * If jtnode is a RangeTblRef for an RTE_RESULT RTE, return its relid;
4250 * otherwise return 0.
4251 */
4252static int
4253get_result_relid(PlannerInfo *root, Node *jtnode)
4254{
4255 int varno;
4256
4257 if (!IsA(jtnode, RangeTblRef))
4258 return 0;
4259 varno = ((RangeTblRef *) jtnode)->rtindex;
4260 if (rt_fetch(varno, root->parse->rtable)->rtekind != RTE_RESULT)
4261 return 0;
4262 return varno;
4263}
4264
4265/*
4266 * remove_result_refs
4267 * Helper routine for dropping an unneeded RTE_RESULT RTE.
4268 *
4269 * This doesn't physically remove the RTE from the jointree, because that's
4270 * more easily handled in remove_useless_results_recurse. What it does do
4271 * is the necessary cleanup in the rest of the tree: we must adjust any PHVs
4272 * that may reference the RTE. Be sure to call this at a point where the
4273 * jointree is valid (no disconnected nodes).
4274 *
4275 * Note that we don't need to process the append_rel_list, since RTEs
4276 * referenced directly in the jointree won't be appendrel members.
4277 *
4278 * varno is the RTE_RESULT's relid.
4279 * newjtloc is the jointree location at which any PHVs referencing the
4280 * RTE_RESULT should be evaluated instead.
4281 */
4282static void
4283remove_result_refs(PlannerInfo *root, int varno, Node *newjtloc)
4284{
4285 /* Fix up PlaceHolderVars as needed */
4286 /* If there are no PHVs anywhere, we can skip this bit */
4287 if (root->glob->lastPHId != 0)
4288 {
4289 Relids subrelids;
4290
4291 subrelids = get_relids_in_jointree(newjtloc, true, false);
4292 Assert(!bms_is_empty(subrelids));
4293 substitute_phv_relids((Node *) root->parse, varno, subrelids);
4294 fix_append_rel_relids(root, varno, subrelids);
4295 }
4296
4297 /*
4298 * We also need to remove any PlanRowMark referencing the RTE, but we
4299 * postpone that work until we return to remove_useless_result_rtes.
4300 */
4301}
4302
4303
4304/*
4305 * find_dependent_phvs - are there any PlaceHolderVars whose base relids are
4306 * exactly the given varno?
4307 *
4308 * We ignore outer-join relids present in a PHV's phrels, by intersecting
4309 * with the caller-supplied "baserels" set. This is necessary in part
4310 * because some of the OJ relids may be stale, that is we may have
4311 * already decided to remove those joins in remove_useless_result_rtes
4312 * and not yet have cleaned their relid bits out of upper PHVs.
4313 * But in general, it's the set of baserels that identify possible places
4314 * to evaluate a PHV, and we mustn't let that go to empty. (The caller is
4315 * allowed to pass baserels as NULL if the query contains no PHVs at all,
4316 * since then there is no work to do anyway.)
4317 *
4318 * find_dependent_phvs should be used when we want to see if there are
4319 * any such PHVs anywhere in the Query. Another use-case is to see if
4320 * a subtree of the join tree contains such PHVs; but for that, we have
4321 * to look not only at the join tree nodes themselves but at the
4322 * referenced RTEs. For that, use find_dependent_phvs_in_jointree.
4323 */
4324
4325typedef struct
4326{
4327 Relids relids; /* target relid, represented as a relid set */
4328 Relids baserels; /* base RT indexes in query, NULL if no PHVs */
4329 int sublevels_up; /* current nesting level */
4330} find_dependent_phvs_context;
4331
4332static bool
4333find_dependent_phvs_walker(Node *node,
4334 find_dependent_phvs_context *context)
4335{
4336 if (node == NULL)
4337 return false;
4338 if (IsA(node, PlaceHolderVar))
4339 {
4340 PlaceHolderVar *phv = (PlaceHolderVar *) node;
4341
4342 if (phv->phlevelsup == context->sublevels_up)
4343 {
4344 Relids phbaserels = bms_intersect(phv->phrels,
4345 context->baserels);
4346 bool match = bms_equal(context->relids, phbaserels);
4347
4348 bms_free(phbaserels);
4349 if (match)
4350 return true;
4351 }
4352 /* fall through to examine children */
4353 }
4354 if (IsA(node, Query))
4355 {
4356 /* Recurse into subselects */
4357 bool result;
4358
4359 context->sublevels_up++;
4360 result = query_tree_walker((Query *) node,
4361 find_dependent_phvs_walker,
4362 context, 0);
4363 context->sublevels_up--;
4364 return result;
4365 }
4366 /* Shouldn't need to handle most planner auxiliary nodes here */
4367 Assert(!IsA(node, SpecialJoinInfo));
4368 Assert(!IsA(node, PlaceHolderInfo));
4369 Assert(!IsA(node, MinMaxAggInfo));
4370
4371 return expression_tree_walker(node, find_dependent_phvs_walker, context);
4372}
4373
4374static bool
4375find_dependent_phvs(PlannerInfo *root, int varno, Relids baserels)
4376{
4377 find_dependent_phvs_context context;
4378
4379 /* If there are no PHVs anywhere, we needn't work hard */
4380 if (root->glob->lastPHId == 0)
4381 return false;
4382
4383 context.relids = bms_make_singleton(varno);
4384 context.baserels = baserels;
4385 context.sublevels_up = 0;
4386
4387 if (query_tree_walker(root->parse, find_dependent_phvs_walker, &context, 0))
4388 return true;
4389 /* The append_rel_list could be populated already, so check it too */
4390 if (expression_tree_walker((Node *) root->append_rel_list,
4391 find_dependent_phvs_walker,
4392 &context))
4393 return true;
4394 return false;
4395}
4396
4397static bool
4398find_dependent_phvs_in_jointree(PlannerInfo *root, Node *node, int varno,
4399 Relids baserels)
4400{
4401 find_dependent_phvs_context context;
4402 Relids subrelids;
4403 int relid;
4404
4405 /* If there are no PHVs anywhere, we needn't work hard */
4406 if (root->glob->lastPHId == 0)
4407 return false;
4408
4409 context.relids = bms_make_singleton(varno);
4410 context.baserels = baserels;
4411 context.sublevels_up = 0;
4412
4413 /*
4414 * See if the jointree fragment itself contains references (in join quals)
4415 */
4416 if (find_dependent_phvs_walker(node, &context))
4417 return true;
4418
4419 /*
4420 * Otherwise, identify the set of referenced RTEs (we can ignore joins,
4421 * since they should be flattened already, so their join alias lists no
4422 * longer matter), and tediously check each RTE. We can ignore RTEs that
4423 * are not marked LATERAL, though, since they couldn't possibly contain
4424 * any cross-references to other RTEs.
4425 */
4426 subrelids = get_relids_in_jointree(node, false, false);
4427 relid = -1;
4428 while ((relid = bms_next_member(subrelids, relid)) >= 0)
4429 {
4430 RangeTblEntry *rte = rt_fetch(relid, root->parse->rtable);
4431
4432 if (rte->lateral &&
4433 range_table_entry_walker(rte, find_dependent_phvs_walker, &context, 0))
4434 return true;
4435 }
4436
4437 return false;
4438}
4439
4440/*
4441 * substitute_phv_relids - adjust PlaceHolderVar relid sets after pulling up
4442 * a subquery or removing an RTE_RESULT jointree item
4443 *
4444 * Find any PlaceHolderVar nodes in the given tree that reference the
4445 * pulled-up relid, and change them to reference the replacement relid(s).
4446 *
4447 * NOTE: although this has the form of a walker, we cheat and modify the
4448 * nodes in-place. This should be OK since the tree was copied by
4449 * pullup_replace_vars earlier. Avoid scribbling on the original values of
4450 * the bitmapsets, though, because expression_tree_mutator doesn't copy those.
4451 */
4452
4459
4460static bool
4461substitute_phv_relids_walker(Node *node,
4462 substitute_phv_relids_context *context)
4463{
4464 if (node == NULL)
4465 return false;
4466 if (IsA(node, PlaceHolderVar))
4467 {
4468 PlaceHolderVar *phv = (PlaceHolderVar *) node;
4469
4470 if (phv->phlevelsup == context->sublevels_up &&
4471 bms_is_member(context->varno, phv->phrels))
4472 {
4473 phv->phrels = bms_union(phv->phrels,
4474 context->subrelids);
4475 phv->phrels = bms_del_member(phv->phrels,
4476 context->varno);
4477 /* Assert we haven't broken the PHV */
4478 Assert(!bms_is_empty(phv->phrels));
4479 }
4480 /* fall through to examine children */
4481 }
4482 if (IsA(node, Query))
4483 {
4484 /* Recurse into subselects */
4485 bool result;
4486
4487 context->sublevels_up++;
4488 result = query_tree_walker((Query *) node,
4489 substitute_phv_relids_walker,
4490 context, 0);
4491 context->sublevels_up--;
4492 return result;
4493 }
4494 /* Shouldn't need to handle planner auxiliary nodes here */
4495 Assert(!IsA(node, SpecialJoinInfo));
4496 Assert(!IsA(node, AppendRelInfo));
4497 Assert(!IsA(node, PlaceHolderInfo));
4498 Assert(!IsA(node, MinMaxAggInfo));
4499
4500 return expression_tree_walker(node, substitute_phv_relids_walker, context);
4501}
4502
4503static void
4504substitute_phv_relids(Node *node, int varno, Relids subrelids)
4505{
4506 substitute_phv_relids_context context;
4507
4508 context.varno = varno;
4509 context.sublevels_up = 0;
4510 context.subrelids = subrelids;
4511
4512 /*
4513 * Must be prepared to start with a Query or a bare expression tree.
4514 */
4515 query_or_expression_tree_walker(node,
4516 substitute_phv_relids_walker,
4517 &context,
4518 0);
4519}
4520
4521/*
4522 * fix_append_rel_relids: update RT-index fields of AppendRelInfo nodes
4523 *
4524 * When we pull up a subquery, any AppendRelInfo references to the subquery's
4525 * RT index have to be replaced by the substituted relid (and there had better
4526 * be only one). We also need to apply substitute_phv_relids to their
4527 * translated_vars lists, since those might contain PlaceHolderVars.
4528 *
4529 * We assume we may modify the AppendRelInfo nodes in-place.
4530 */
4531static void
4532fix_append_rel_relids(PlannerInfo *root, int varno, Relids subrelids)
4533{
4534 ListCell *l;
4535 int subvarno = -1;
4536
4537 /*
4538 * We only want to extract the member relid once, but we mustn't fail
4539 * immediately if there are multiple members; it could be that none of the
4540 * AppendRelInfo nodes refer to it. So compute it on first use. Note that
4541 * bms_singleton_member will complain if set is not singleton.
4542 */
4543 foreach(l, root->append_rel_list)
4544 {
4545 AppendRelInfo *appinfo = (AppendRelInfo *) lfirst(l);
4546
4547 /* The parent_relid shouldn't ever be a pullup target */
4548 Assert(appinfo->parent_relid != varno);
4549
4550 if (appinfo->child_relid == varno)
4551 {
4552 if (subvarno < 0)
4553 subvarno = bms_singleton_member(subrelids);
4554 appinfo->child_relid = subvarno;
4555 }
4556
4557 /* Also fix up any PHVs in its translated vars */
4558 if (root->glob->lastPHId != 0)
4559 substitute_phv_relids((Node *) appinfo->translated_vars,
4560 varno, subrelids);
4561 }
4562}
4563
4564/*
4565 * get_relids_in_jointree: get set of RT indexes present in a jointree
4566 *
4567 * Base-relation relids are always included in the result.
4568 * If include_outer_joins is true, outer-join RT indexes are included.
4569 * If include_inner_joins is true, inner-join RT indexes are included.
4570 *
4571 * Note that for most purposes in the planner, outer joins are included
4572 * in standard relid sets. Setting include_inner_joins true is only
4573 * appropriate for special purposes during subquery flattening.
4574 */
4575Relids
4576get_relids_in_jointree(Node *jtnode, bool include_outer_joins,
4577 bool include_inner_joins)
4578{
4579 Relids result = NULL;
4580
4581 if (jtnode == NULL)
4582 return result;
4583 if (IsA(jtnode, RangeTblRef))
4584 {
4585 int varno = ((RangeTblRef *) jtnode)->rtindex;
4586
4587 result = bms_make_singleton(varno);
4588 }
4589 else if (IsA(jtnode, FromExpr))
4590 {
4591 FromExpr *f = (FromExpr *) jtnode;
4592 ListCell *l;
4593
4594 foreach(l, f->fromlist)
4595 {
4596 result = bms_join(result,
4597 get_relids_in_jointree(lfirst(l),
4598 include_outer_joins,
4599 include_inner_joins));
4600 }
4601 }
4602 else if (IsA(jtnode, JoinExpr))
4603 {
4604 JoinExpr *j = (JoinExpr *) jtnode;
4605
4606 result = get_relids_in_jointree(j->larg,
4607 include_outer_joins,
4608 include_inner_joins);
4609 result = bms_join(result,
4610 get_relids_in_jointree(j->rarg,
4611 include_outer_joins,
4612 include_inner_joins));
4613 if (j->rtindex)
4614 {
4615 if (j->jointype == JOIN_INNER)
4616 {
4617 if (include_inner_joins)
4618 result = bms_add_member(result, j->rtindex);
4619 }
4620 else
4621 {
4622 if (include_outer_joins)
4623 result = bms_add_member(result, j->rtindex);
4624 }
4625 }
4626 }
4627 else
4628 elog(ERROR, "unrecognized node type: %d",
4629 (int) nodeTag(jtnode));
4630 return result;
4631}
4632
4633/*
4634 * get_relids_for_join: get set of base+OJ RT indexes making up a join
4635 */
4636Relids
4637get_relids_for_join(Query *query, int joinrelid)
4638{
4639 Node *jtnode;
4640
4641 jtnode = find_jointree_node_for_rel((Node *) query->jointree,
4642 joinrelid);
4643 if (!jtnode)
4644 elog(ERROR, "could not find join node %d", joinrelid);
4645 return get_relids_in_jointree(jtnode, true, false);
4646}
4647
4648/*
4649 * find_jointree_node_for_rel: locate jointree node for a base or join RT index
4650 *
4651 * Returns NULL if not found
4652 */
4653static Node *
4654find_jointree_node_for_rel(Node *jtnode, int relid)
4655{
4656 if (jtnode == NULL)
4657 return NULL;
4658 if (IsA(jtnode, RangeTblRef))
4659 {
4660 int varno = ((RangeTblRef *) jtnode)->rtindex;
4661
4662 if (relid == varno)
4663 return jtnode;
4664 }
4665 else if (IsA(jtnode, FromExpr))
4666 {
4667 FromExpr *f = (FromExpr *) jtnode;
4668 ListCell *l;
4669
4670 foreach(l, f->fromlist)
4671 {
4672 jtnode = find_jointree_node_for_rel(lfirst(l), relid);
4673 if (jtnode)
4674 return jtnode;
4675 }
4676 }
4677 else if (IsA(jtnode, JoinExpr))
4678 {
4679 JoinExpr *j = (JoinExpr *) jtnode;
4680
4681 if (relid == j->rtindex)
4682 return jtnode;
4683 jtnode = find_jointree_node_for_rel(j->larg, relid);
4684 if (jtnode)
4685 return jtnode;
4686 jtnode = find_jointree_node_for_rel(j->rarg, relid);
4687 if (jtnode)
4688 return jtnode;
4689 }
4690 else
4691 elog(ERROR, "unrecognized node type: %d",
4692 (int) nodeTag(jtnode));
4693 return NULL;
4694}
4695
4696/*
4697 * get_nullingrels: collect info about which outer joins null which relations
4698 *
4699 * The result struct contains, for each leaf relation used in the query,
4700 * the set of relids of outer joins that potentially null that rel.
4701 */
4702static nullingrel_info *
4703get_nullingrels(Query *parse)
4704{
4705 nullingrel_info *result = palloc_object(nullingrel_info);
4706
4707 result->rtlength = list_length(parse->rtable);
4708 result->nullingrels = palloc0_array(Relids, result->rtlength + 1);
4709 get_nullingrels_recurse((Node *) parse->jointree, NULL, result);
4710 return result;
4711}
4712
4713/*
4714 * Recursive guts of get_nullingrels().
4715 *
4716 * Note: at any recursion level, the passed-down upper_nullingrels must be
4717 * treated as a constant, but it can be stored directly into *info
4718 * if we're at leaf level. Upper recursion levels do not free their mutated
4719 * copies of the nullingrels, because those are probably referenced by
4720 * at least one leaf rel.
4721 */
4722static void
4723get_nullingrels_recurse(Node *jtnode, Relids upper_nullingrels,
4724 nullingrel_info *info)
4725{
4726 if (jtnode == NULL)
4727 return;
4728 if (IsA(jtnode, RangeTblRef))
4729 {
4730 int varno = ((RangeTblRef *) jtnode)->rtindex;
4731
4732 Assert(varno > 0 && varno <= info->rtlength);
4733 info->nullingrels[varno] = upper_nullingrels;
4734 }
4735 else if (IsA(jtnode, FromExpr))
4736 {
4737 FromExpr *f = (FromExpr *) jtnode;
4738 ListCell *l;
4739
4740 foreach(l, f->fromlist)
4741 {
4742 get_nullingrels_recurse(lfirst(l), upper_nullingrels, info);
4743 }
4744 }
4745 else if (IsA(jtnode, JoinExpr))
4746 {
4747 JoinExpr *j = (JoinExpr *) jtnode;
4748 Relids local_nullingrels;
4749
4750 switch (j->jointype)
4751 {
4752 case JOIN_INNER:
4753 get_nullingrels_recurse(j->larg, upper_nullingrels, info);
4754 get_nullingrels_recurse(j->rarg, upper_nullingrels, info);
4755 break;
4756 case JOIN_LEFT:
4757 case JOIN_SEMI:
4758 case JOIN_ANTI:
4759 local_nullingrels = bms_add_member(bms_copy(upper_nullingrels),
4760 j->rtindex);
4761 get_nullingrels_recurse(j->larg, upper_nullingrels, info);
4762 get_nullingrels_recurse(j->rarg, local_nullingrels, info);
4763 break;
4764 case JOIN_FULL:
4765 local_nullingrels = bms_add_member(bms_copy(upper_nullingrels),
4766 j->rtindex);
4767 get_nullingrels_recurse(j->larg, local_nullingrels, info);
4768 get_nullingrels_recurse(j->rarg, local_nullingrels, info);
4769 break;
4770 case JOIN_RIGHT:
4771 local_nullingrels = bms_add_member(bms_copy(upper_nullingrels),
4772 j->rtindex);
4773 get_nullingrels_recurse(j->larg, local_nullingrels, info);
4774 get_nullingrels_recurse(j->rarg, upper_nullingrels, info);
4775 break;
4776 default:
4777 elog(ERROR, "unrecognized join type: %d",
4778 (int) j->jointype);
4779 break;
4780 }
4781 }
4782 else
4783 elog(ERROR, "unrecognized node type: %d",
4784 (int) nodeTag(jtnode));
4785}
AttrNumber
int16 AttrNumber
Definition attnum.h:21
InvalidAttrNumber
#define InvalidAttrNumber
Definition attnum.h:23
bms_make_singleton
Bitmapset * bms_make_singleton(int x)
Definition bitmapset.c:217
bms_intersect
Bitmapset * bms_intersect(const Bitmapset *a, const Bitmapset *b)
Definition bitmapset.c:293
bms_equal
bool bms_equal(const Bitmapset *a, const Bitmapset *b)
Definition bitmapset.c:143
bms_next_member
int bms_next_member(const Bitmapset *a, int prevbit)
Definition bitmapset.c:1425
bms_del_members
Bitmapset * bms_del_members(Bitmapset *a, const Bitmapset *b)
Definition bitmapset.c:1280
bms_del_member
Bitmapset * bms_del_member(Bitmapset *a, int x)
Definition bitmapset.c:987
bms_is_subset
bool bms_is_subset(const Bitmapset *a, const Bitmapset *b)
Definition bitmapset.c:547
bms_singleton_member
int bms_singleton_member(const Bitmapset *a)
Definition bitmapset.c:800
bms_free
void bms_free(Bitmapset *a)
Definition bitmapset.c:240
bms_is_member
bool bms_is_member(int x, const Bitmapset *a)
Definition bitmapset.c:645
bms_add_member
Bitmapset * bms_add_member(Bitmapset *a, int x)
Definition bitmapset.c:934
bms_add_members
Bitmapset * bms_add_members(Bitmapset *a, const Bitmapset *b)
Definition bitmapset.c:1036
bms_offset_members
Bitmapset * bms_offset_members(const Bitmapset *a, int offset)
Definition bitmapset.c:419
bms_union
Bitmapset * bms_union(const Bitmapset *a, const Bitmapset *b)
Definition bitmapset.c:252
bms_overlap
bool bms_overlap(const Bitmapset *a, const Bitmapset *b)
Definition bitmapset.c:710
bms_join
Bitmapset * bms_join(Bitmapset *a, Bitmapset *b)
Definition bitmapset.c:1349
bms_copy
Bitmapset * bms_copy(const Bitmapset *a)
Definition bitmapset.c:123
bms_is_empty
#define bms_is_empty(a)
Definition bitmapset.h:119
Assert
#define Assert(condition)
Definition c.h:1002
Index
unsigned int Index
Definition c.h:757
result
uint32 result
Definition checksum_block_internal.h:18
memcpy
memcpy(sums, checksumBaseOffsets, sizeof(checksumBaseOffsets))
find_forced_null_vars
List * find_forced_null_vars(Node *node)
Definition clauses.c:1952
inline_function_in_from
Query * inline_function_in_from(PlannerInfo *root, RangeTblEntry *rte)
Definition clauses.c:5835
eval_const_expressions
Node * eval_const_expressions(PlannerInfo *root, Node *node)
Definition clauses.c:2516
find_nonnullable_vars
List * find_nonnullable_vars(Node *clause)
Definition clauses.c:1743
find_nonnullable_rels
Relids find_nonnullable_rels(Node *clause)
Definition clauses.c:1492
contain_nonstrict_functions
bool contain_nonstrict_functions(Node *clause)
Definition clauses.c:1022
contain_volatile_functions
bool contain_volatile_functions(Node *clause)
Definition clauses.c:567
restricted
static bool restricted
Definition command.c:199
ERROR
#define ERROR
Definition elog.h:40
elog
#define elog(elevel,...)
Definition elog.h:228
palloc_object
#define palloc_object(type)
Definition fe_memutils.h:89
palloc0_array
#define palloc0_array(type, count)
Definition fe_memutils.h:92
get_expr_result_type
TypeFuncClass get_expr_result_type(Node *expr, Oid *resultTypeId, TupleDesc *resultTupleDesc)
Definition funcapi.c:299
TypeFuncClass
TypeFuncClass
Definition funcapi.h:147
TYPEFUNC_SCALAR
@ TYPEFUNC_SCALAR
Definition funcapi.h:148
parse
void parse(int)
Definition parse.c:49
j
int j
Definition isn.c:78
i
int i
Definition isn.c:77
lappend
List * lappend(List *list, void *datum)
Definition list.c:339
list_concat
List * list_concat(List *list1, const List *list2)
Definition list.c:561
NoLock
#define NoLock
Definition lockdefs.h:34
makeAlias
Alias * makeAlias(const char *aliasname, List *colnames)
Definition makefuncs.c:438
makeVarFromTargetEntry
Var * makeVarFromTargetEntry(int varno, TargetEntry *tle)
Definition makefuncs.c:107
makeFromExpr
FromExpr * makeFromExpr(List *fromlist, Node *quals)
Definition makefuncs.c:336
makeVar
Var * makeVar(int varno, AttrNumber varattno, Oid vartype, int32 vartypmod, Oid varcollid, Index varlevelsup)
Definition makefuncs.c:66
makeWholeRowVar
Var * makeWholeRowVar(RangeTblEntry *rte, int varno, Index varlevelsup, bool allowScalar)
Definition makefuncs.c:137
make_andclause
Expr * make_andclause(List *andclauses)
Definition makefuncs.c:727
makeTargetEntry
TargetEntry * makeTargetEntry(Expr *expr, AttrNumber resno, char *resname, bool resjunk)
Definition makefuncs.c:289
make_and_qual
Node * make_and_qual(Node *qual1, Node *qual2)
Definition makefuncs.c:780
palloc0
void * palloc0(Size size)
Definition mcxt.c:1420
CurrentMemoryContext
MemoryContext CurrentMemoryContext
Definition mcxt.c:161
CHECK_FOR_INTERRUPTS
#define CHECK_FOR_INTERRUPTS()
Definition miscadmin.h:125
mbms_add_members
List * mbms_add_members(List *a, const List *b)
Definition multibitmapset.c:71
mbms_overlap_sets
Bitmapset * mbms_overlap_sets(const List *a, const List *b)
Definition multibitmapset.c:146
expression_returns_set
bool expression_returns_set(Node *clause)
Definition nodeFuncs.c:768
is_andclause
static bool is_andclause(const void *clause)
Definition nodeFuncs.h:107
query_tree_walker
#define query_tree_walker(q, w, c, f)
Definition nodeFuncs.h:158
query_or_expression_tree_walker
#define query_or_expression_tree_walker(n, w, c, f)
Definition nodeFuncs.h:171
range_table_entry_walker
#define range_table_entry_walker(r, w, c, f)
Definition nodeFuncs.h:168
expression_tree_walker
#define expression_tree_walker(n, w, c)
Definition nodeFuncs.h:153
is_notclause
static bool is_notclause(const void *clause)
Definition nodeFuncs.h:125
get_notclausearg
static Expr * get_notclausearg(const void *notclause)
Definition nodeFuncs.h:134
IsA
#define IsA(nodeptr, _type_)
Definition nodes.h:162
copyObject
#define copyObject(obj)
Definition nodes.h:230
nodeTag
#define nodeTag(nodeptr)
Definition nodes.h:137
CMD_MERGE
@ CMD_MERGE
Definition nodes.h:277
CMD_SELECT
@ CMD_SELECT
Definition nodes.h:273
CMD_NOTHING
@ CMD_NOTHING
Definition nodes.h:280
makeNode
#define makeNode(_type_)
Definition nodes.h:159
castNode
#define castNode(_type_, nodeptr)
Definition nodes.h:180
JoinType
JoinType
Definition nodes.h:296
JOIN_SEMI
@ JOIN_SEMI
Definition nodes.h:315
JOIN_FULL
@ JOIN_FULL
Definition nodes.h:303
JOIN_INNER
@ JOIN_INNER
Definition nodes.h:301
JOIN_RIGHT
@ JOIN_RIGHT
Definition nodes.h:304
JOIN_LEFT
@ JOIN_LEFT
Definition nodes.h:302
JOIN_ANTI
@ JOIN_ANTI
Definition nodes.h:316
parse_relation.h
SETOP_UNION
@ SETOP_UNION
Definition parsenodes.h:2323
RTE_JOIN
@ RTE_JOIN
Definition parsenodes.h:1126
RTE_CTE
@ RTE_CTE
Definition parsenodes.h:1130
RTE_NAMEDTUPLESTORE
@ RTE_NAMEDTUPLESTORE
Definition parsenodes.h:1131
RTE_VALUES
@ RTE_VALUES
Definition parsenodes.h:1129
RTE_SUBQUERY
@ RTE_SUBQUERY
Definition parsenodes.h:1125
RTE_RESULT
@ RTE_RESULT
Definition parsenodes.h:1133
RTE_FUNCTION
@ RTE_FUNCTION
Definition parsenodes.h:1127
RTE_TABLEFUNC
@ RTE_TABLEFUNC
Definition parsenodes.h:1128
RTE_GROUP
@ RTE_GROUP
Definition parsenodes.h:1136
RTE_GRAPH_TABLE
@ RTE_GRAPH_TABLE
Definition parsenodes.h:1132
RTE_RELATION
@ RTE_RELATION
Definition parsenodes.h:1124
rt_fetch
#define rt_fetch(rangetable_index, rangetable)
Definition parsetree.h:31
Form_pg_attribute
FormData_pg_attribute * Form_pg_attribute
Definition pg_attribute.h:206
lfirst
#define lfirst(lc)
Definition pg_list.h:172
list_length
static int list_length(const List *l)
Definition pg_list.h:152
linitial_node
#define linitial_node(type, l)
Definition pg_list.h:181
NIL
#define NIL
Definition pg_list.h:68
forboth
#define forboth(cell1, list1, cell2, list2)
Definition pg_list.h:550
foreach_delete_current
#define foreach_delete_current(lst, var_or_cell)
Definition pg_list.h:423
list_make1
#define list_make1(x1)
Definition pg_list.h:244
linitial
#define linitial(l)
Definition pg_list.h:178
lsecond
#define lsecond(l)
Definition pg_list.h:183
foreach_node
#define foreach_node(type, var, lst)
Definition pg_list.h:528
list_make2
#define list_make2(x1, x2)
Definition pg_list.h:246
source
static rewind_source * source
Definition pg_rewind.c:89
pg_type.h
make_placeholder_expr
PlaceHolderVar * make_placeholder_expr(PlannerInfo *root, Expr *expr, Relids phrels)
Definition placeholder.c:56
get_relation_notnullatts
void get_relation_notnullatts(PlannerInfo *root, Relation relation)
Definition plancat.c:690
find_relation_notnullatts
Bitmapset * find_relation_notnullatts(PlannerInfo *root, Oid relid)
Definition plancat.c:763
InvalidOid
#define InvalidOid
Definition postgres_ext.h:37
Oid
unsigned int Oid
Definition postgres_ext.h:32
pull_up_subqueries_recurse
static Node * pull_up_subqueries_recurse(PlannerInfo *root, Node *jtnode, JoinExpr *lowest_outer_join, AppendRelInfo *containing_appendrel)
Definition prepjointree.c:1266
get_nullingrels
static nullingrel_info * get_nullingrels(Query *parse)
Definition prepjointree.c:4703
remove_result_refs
static void remove_result_refs(PlannerInfo *root, int varno, Node *newjtloc)
Definition prepjointree.c:4283
pull_up_constant_function
static Node * pull_up_constant_function(PlannerInfo *root, Node *jtnode, RangeTblEntry *rte, AppendRelInfo *containing_appendrel)
Definition prepjointree.c:2252
preprocess_function_rtes
void preprocess_function_rtes(PlannerInfo *root)
Definition prepjointree.c:1175
find_dependent_phvs_walker
static bool find_dependent_phvs_walker(Node *node, find_dependent_phvs_context *context)
Definition prepjointree.c:4333
pullup_replace_vars_callback
static Node * pullup_replace_vars_callback(const Var *var, replace_rte_variables_context *context)
Definition prepjointree.c:2786
find_jointree_node_for_rel
static Node * find_jointree_node_for_rel(Node *jtnode, int relid)
Definition prepjointree.c:4654
pull_up_simple_union_all
static Node * pull_up_simple_union_all(PlannerInfo *root, Node *jtnode, RangeTblEntry *rte)
Definition prepjointree.c:1766
reduce_outer_joins_pass2
static void reduce_outer_joins_pass2(Node *jtnode, reduce_outer_joins_pass1_state *state1, reduce_outer_joins_pass2_state *state2, PlannerInfo *root, Relids nonnullable_rels, List *forced_null_vars)
Definition prepjointree.c:3443
pull_up_union_leaf_queries
static void pull_up_union_leaf_queries(Node *setOp, PlannerInfo *root, int parentRTindex, Query *setOpQuery, int childRToffset)
Definition prepjointree.c:1848
is_simple_values
static bool is_simple_values(PlannerInfo *root, RangeTblEntry *rte)
Definition prepjointree.c:2193
make_setop_translation_list
static void make_setop_translation_list(Query *query, int newvarno, AppendRelInfo *appinfo)
Definition prepjointree.c:1918
flatten_simple_union_all
void flatten_simple_union_all(PlannerInfo *root)
Definition prepjointree.c:3136
transform_MERGE_to_join
void transform_MERGE_to_join(Query *parse)
Definition prepjointree.c:193
report_reduced_full_join
static void report_reduced_full_join(reduce_outer_joins_pass2_state *state2, int rtindex, Relids relids)
Definition prepjointree.c:3722
perform_pullup_replace_vars
static void perform_pullup_replace_vars(PlannerInfo *root, pullup_replace_vars_context *rvcontext, AppendRelInfo *containing_appendrel)
Definition prepjointree.c:2558
find_dependent_phvs_in_jointree
static bool find_dependent_phvs_in_jointree(PlannerInfo *root, Node *node, int varno, Relids baserels)
Definition prepjointree.c:4398
remove_useless_result_rtes
void remove_useless_result_rtes(PlannerInfo *root)
Definition prepjointree.c:3889
pull_up_sublinks_jointree_recurse
static Node * pull_up_sublinks_jointree_recurse(PlannerInfo *root, Node *jtnode, Relids *relids)
Definition prepjointree.c:699
get_nullingrels_recurse
static void get_nullingrels_recurse(Node *jtnode, Relids upper_nullingrels, nullingrel_info *info)
Definition prepjointree.c:4723
ReplaceWrapOption
ReplaceWrapOption
Definition prepjointree.c:63
REPLACE_WRAP_VARFREE
@ REPLACE_WRAP_VARFREE
Definition prepjointree.c:66
REPLACE_WRAP_ALL
@ REPLACE_WRAP_ALL
Definition prepjointree.c:65
REPLACE_WRAP_NONE
@ REPLACE_WRAP_NONE
Definition prepjointree.c:64
reduce_outer_joins_pass1
static reduce_outer_joins_pass1_state * reduce_outer_joins_pass1(Node *jtnode)
Definition prepjointree.c:3332
replace_vars_in_jointree
static void replace_vars_in_jointree(Node *jtnode, pullup_replace_vars_context *context)
Definition prepjointree.c:2665
is_simple_subquery
static bool is_simple_subquery(PlannerInfo *root, Query *subquery, RangeTblEntry *rte, JoinExpr *lowest_outer_join)
Definition prepjointree.c:1956
remove_useless_results_recurse
static Node * remove_useless_results_recurse(PlannerInfo *root, Node *jtnode, Relids baserels, Node **parent_quals, Relids *dropped_outer_joins)
Definition prepjointree.c:3976
substitute_phv_relids
static void substitute_phv_relids(Node *node, int varno, Relids subrelids)
Definition prepjointree.c:4504
pull_up_sublinks
void pull_up_sublinks(PlannerInfo *root)
Definition prepjointree.c:672
pull_up_simple_subquery
static Node * pull_up_simple_subquery(PlannerInfo *root, Node *jtnode, RangeTblEntry *rte, JoinExpr *lowest_outer_join, AppendRelInfo *containing_appendrel)
Definition prepjointree.c:1411
replace_empty_jointree
void replace_empty_jointree(Query *parse)
Definition prepjointree.c:614
is_simple_union_all_recurse
static bool is_simple_union_all_recurse(Node *setOp, Query *setOpQuery, List *colTypes)
Definition prepjointree.c:2392
find_dependent_phvs
static bool find_dependent_phvs(PlannerInfo *root, int varno, Relids baserels)
Definition prepjointree.c:4375
substitute_phv_relids_walker
static bool substitute_phv_relids_walker(Node *node, substitute_phv_relids_context *context)
Definition prepjointree.c:4461
fix_append_rel_relids
static void fix_append_rel_relids(PlannerInfo *root, int varno, Relids subrelids)
Definition prepjointree.c:4532
has_notnull_forced_var
static bool has_notnull_forced_var(PlannerInfo *root, List *forced_null_vars, reduce_outer_joins_pass1_state *right_state)
Definition prepjointree.c:3745
pullup_replace_vars_subquery
static Query * pullup_replace_vars_subquery(Query *query, pullup_replace_vars_context *context)
Definition prepjointree.c:3109
get_relids_for_join
Relids get_relids_for_join(Query *query, int joinrelid)
Definition prepjointree.c:4637
pull_up_subqueries
void pull_up_subqueries(PlannerInfo *root)
Definition prepjointree.c:1222
get_relids_in_jointree
Relids get_relids_in_jointree(Node *jtnode, bool include_outer_joins, bool include_inner_joins)
Definition prepjointree.c:4576
get_result_relid
static int get_result_relid(PlannerInfo *root, Node *jtnode)
Definition prepjointree.c:4253
preprocess_relation_rtes
Query * preprocess_relation_rtes(PlannerInfo *root)
Definition prepjointree.c:423
pull_up_simple_values
static Node * pull_up_simple_values(PlannerInfo *root, Node *jtnode, RangeTblEntry *rte)
Definition prepjointree.c:2096
is_safe_append_member
static bool is_safe_append_member(Query *subquery)
Definition prepjointree.c:2435
pull_up_sublinks_qual_recurse
static Node * pull_up_sublinks_qual_recurse(PlannerInfo *root, Node *node, Node **jtlink1, Relids available_rels1, Node **jtlink2, Relids available_rels2)
Definition prepjointree.c:856
reduce_outer_joins
void reduce_outer_joins(PlannerInfo *root)
Definition prepjointree.c:3258
expand_virtual_generated_columns
static Query * expand_virtual_generated_columns(PlannerInfo *root, Query *parse, RangeTblEntry *rte, int rt_index, Relation relation)
Definition prepjointree.c:492
jointree_contains_lateral_outer_refs
static bool jointree_contains_lateral_outer_refs(PlannerInfo *root, Node *jtnode, bool restricted, Relids safe_upper_varnos)
Definition prepjointree.c:2483
pullup_replace_vars
static Node * pullup_replace_vars(Node *expr, pullup_replace_vars_context *context)
Definition prepjointree.c:2776
is_simple_union_all
static bool is_simple_union_all(Query *subquery)
Definition prepjointree.c:2364
fb
static int fb(int x)
Definition preproc-init.c:92
ANY_SUBLINK
@ ANY_SUBLINK
Definition primnodes.h:1013
EXISTS_SUBLINK
@ EXISTS_SUBLINK
Definition primnodes.h:1011
NUM_MERGE_MATCH_KINDS
#define NUM_MERGE_MATCH_KINDS
Definition primnodes.h:2024
IS_NOT_NULL
@ IS_NOT_NULL
Definition primnodes.h:1975
MERGE_WHEN_NOT_MATCHED_BY_TARGET
@ MERGE_WHEN_NOT_MATCHED_BY_TARGET
Definition primnodes.h:2021
MERGE_WHEN_NOT_MATCHED_BY_SOURCE
@ MERGE_WHEN_NOT_MATCHED_BY_SOURCE
Definition primnodes.h:2020
MERGE_WHEN_MATCHED
@ MERGE_WHEN_MATCHED
Definition primnodes.h:2019
root
tree ctl root
Definition radixtree.h:1857
RelationGetDescr
#define RelationGetDescr(relation)
Definition rel.h:542
build_generation_expression
Node * build_generation_expression(Relation rel, int attrno)
Definition rewriteHandler.c:4740
IncrementVarSublevelsUp_rtable
void IncrementVarSublevelsUp_rtable(List *rtable, int delta_sublevels_up, int min_sublevels_up)
Definition rewriteManip.c:903
ChangeVarNodes
void ChangeVarNodes(Node *node, int rt_index, int new_index, int sublevels_up)
Definition rewriteManip.c:721
OffsetVarNodes
void OffsetVarNodes(Node *node, int offset, int sublevels_up)
Definition rewriteManip.c:476
CombineRangeTables
void CombineRangeTables(List **dst_rtable, List **dst_perminfos, List *src_rtable, List *src_perminfos)
Definition rewriteManip.c:347
add_nulling_relids
Node * add_nulling_relids(Node *node, const Bitmapset *target_relids, const Bitmapset *added_relids)
Definition rewriteManip.c:1239
remove_nulling_relids
Node * remove_nulling_relids(Node *node, const Bitmapset *removable_relids, const Bitmapset *except_relids)
Definition rewriteManip.c:1327
replace_rte_variables
Node * replace_rte_variables(Node *node, int target_varno, int sublevels_up, replace_rte_variables_callback callback, void *callback_arg, bool *outer_hasSubLinks)
Definition rewriteManip.c:1434
IncrementVarSublevelsUp
void IncrementVarSublevelsUp(Node *node, int delta_sublevels_up, int min_sublevels_up)
Definition rewriteManip.c:880
ReplaceVarFromTargetList
Node * ReplaceVarFromTargetList(const Var *var, RangeTblEntry *target_rte, List *targetlist, int result_relation, ReplaceVarsNoMatchOption nomatch_option, int nomatch_varno)
Definition rewriteManip.c:1772
REPLACEVARS_REPORT_ERROR
@ REPLACEVARS_REPORT_ERROR
Definition rewriteManip.h:39
check_stack_depth
void check_stack_depth(void)
Definition stack_depth.c:96
AppendRelInfo::translated_vars
List * translated_vars
Definition pathnodes.h:3329
FromExpr::quals
Node * quals
Definition primnodes.h:2380
FromExpr::fromlist
List * fromlist
Definition primnodes.h:2379
List
Definition pg_list.h:54
Node
Definition nodes.h:133
PlannerInfo::minmax_aggs
List * minmax_aggs
Definition pathnodes.h:609
PlannerInfo::processed_tlist
List * processed_tlist
Definition pathnodes.h:593
PlannerInfo::hasRecursion
bool hasRecursion
Definition pathnodes.h:641
PlannerInfo::cte_plan_ids
List * cte_plan_ids
Definition pathnodes.h:427
PlannerInfo::last_rinfo_serial
int last_rinfo_serial
Definition pathnodes.h:465
PlannerInfo::qual_security_level
Index qual_security_level
Definition pathnodes.h:626
PlannerInfo::init_plans
List * init_plans
Definition pathnodes.h:421
PlannerInfo::assumeReplanning
bool assumeReplanning
Definition pathnodes.h:643
PlannerInfo::multiexpr_params
List * multiexpr_params
Definition pathnodes.h:430
PlannerInfo::row_identity_vars
List * row_identity_vars
Definition pathnodes.h:490
PlannerInfo::ec_merging_done
bool ec_merging_done
Definition pathnodes.h:439
PlannerInfo::outer_params
Bitmapset * outer_params
Definition pathnodes.h:343
PlannerInfo::query_level
Index query_level
Definition pathnodes.h:315
PlannerInfo::append_rel_list
List * append_rel_list
Definition pathnodes.h:487
PlannerInfo::alternative_plan_name
char * alternative_plan_name
Definition pathnodes.h:333
PlannerInfo::non_recursive_path
struct Path * non_recursive_path
Definition pathnodes.h:671
PlannerInfo::placeholder_list
List * placeholder_list
Definition pathnodes.h:496
PlannerInfo::glob
PlannerGlobal * glob
Definition pathnodes.h:312
PlannerInfo::join_domains
List * join_domains
Definition pathnodes.h:433
PlannerInfo::eq_classes
List * eq_classes
Definition pathnodes.h:436
PlannerInfo::wt_param_id
int wt_param_id
Definition pathnodes.h:669
PlannerInfo::plan_params
List * plan_params
Definition pathnodes.h:342
PlannerInfo::processed_groupClause
List * processed_groupClause
Definition pathnodes.h:570
PlannerInfo::processed_distinctClause
List * processed_distinctClause
Definition pathnodes.h:582
PlannerInfo::parse
Query * parse
Definition pathnodes.h:309
PlannerInfo::rowMarks
List * rowMarks
Definition pathnodes.h:493
PlannerInfo::update_colnos
List * update_colnos
Definition pathnodes.h:601
PlannerInfo::placeholdersFrozen
bool placeholdersFrozen
Definition pathnodes.h:639
PlannerInfo::join_info_list
List * join_info_list
Definition pathnodes.h:462
PlannerInfo::plan_name
char * plan_name
Definition pathnodes.h:321
PlannerInfo::all_result_relids
Relids all_result_relids
Definition pathnodes.h:476
PlannerInfo::leaf_result_relids
Relids leaf_result_relids
Definition pathnodes.h:478
Query::rowMarks
List * rowMarks
Definition parsenodes.h:238
Query::limitCount
Node * limitCount
Definition parsenodes.h:235
Query::jointree
FromExpr * jointree
Definition parsenodes.h:187
Query::setOperations
Node * setOperations
Definition parsenodes.h:240
Query::cteList
List * cteList
Definition parsenodes.h:178
Query::groupClause
List * groupClause
Definition parsenodes.h:221
Query::havingQual
Node * havingQual
Definition parsenodes.h:226
Query::rtable
List * rtable
Definition parsenodes.h:180
Query::limitOffset
Node * limitOffset
Definition parsenodes.h:234
Query::commandType
CmdType commandType
Definition parsenodes.h:124
Query::targetList
List * targetList
Definition parsenodes.h:203
Query::groupingSets
List * groupingSets
Definition parsenodes.h:224
Query::distinctClause
List * distinctClause
Definition parsenodes.h:230
Query::sortClause
List * sortClause
Definition parsenodes.h:232
RelationData::rd_rel
Form_pg_class rd_rel
Definition rel.h:111
SetOperationStmt::op
SetOperation op
Definition parsenodes.h:2400
TupleConstr::has_generated_virtual
bool has_generated_virtual
Definition tupdesc.h:47
TupleDescData::constr
TupleConstr * constr
Definition tupdesc.h:159
Var::location
ParseLoc location
Definition primnodes.h:311
Var::varattno
AttrNumber varattno
Definition primnodes.h:275
Var::varlevelsup
Index varlevelsup
Definition primnodes.h:295
find_dependent_phvs_context
Definition prepjointree.c:4326
find_dependent_phvs_context::relids
Relids relids
Definition prepjointree.c:4327
find_dependent_phvs_context::baserels
Relids baserels
Definition prepjointree.c:4328
find_dependent_phvs_context::sublevels_up
int sublevels_up
Definition prepjointree.c:4329
nullingrel_info
Definition prepjointree.c:51
nullingrel_info::rtlength
int rtlength
Definition prepjointree.c:58
nullingrel_info::nullingrels
Relids * nullingrels
Definition prepjointree.c:56
pullup_replace_vars_context
Definition prepjointree.c:71
pullup_replace_vars_context::outer_hasSubLinks
bool * outer_hasSubLinks
Definition prepjointree.c:81
pullup_replace_vars_context::nullinfo
nullingrel_info * nullinfo
Definition prepjointree.c:79
pullup_replace_vars_context::targetlist
List * targetlist
Definition prepjointree.c:73
pullup_replace_vars_context::relids
Relids relids
Definition prepjointree.c:77
pullup_replace_vars_context::wrap_option
ReplaceWrapOption wrap_option
Definition prepjointree.c:83
pullup_replace_vars_context::target_rte
RangeTblEntry * target_rte
Definition prepjointree.c:74
pullup_replace_vars_context::rv_cache
Node ** rv_cache
Definition prepjointree.c:84
pullup_replace_vars_context::root
PlannerInfo * root
Definition prepjointree.c:72
pullup_replace_vars_context::varno
int varno
Definition prepjointree.c:82
pullup_replace_vars_context::result_relation
int result_relation
Definition prepjointree.c:75
reduce_outer_joins_partial_state
Definition prepjointree.c:103
reduce_outer_joins_partial_state::full_join_rti
int full_join_rti
Definition prepjointree.c:104
reduce_outer_joins_partial_state::unreduced_side
Relids unreduced_side
Definition prepjointree.c:105
reduce_outer_joins_pass1_state
Definition prepjointree.c:88
reduce_outer_joins_pass1_state::relids
Relids relids
Definition prepjointree.c:89
reduce_outer_joins_pass1_state::contains_outer
bool contains_outer
Definition prepjointree.c:90
reduce_outer_joins_pass1_state::sub_states
List * sub_states
Definition prepjointree.c:93
reduce_outer_joins_pass1_state::nullable_rels
Relids nullable_rels
Definition prepjointree.c:91
reduce_outer_joins_pass2_state
Definition prepjointree.c:97
reduce_outer_joins_pass2_state::partial_reduced
List * partial_reduced
Definition prepjointree.c:99
reduce_outer_joins_pass2_state::inner_reduced
Relids inner_reduced
Definition prepjointree.c:98
replace_rte_variables_context
Definition rewriteManip.h:29
replace_rte_variables_context::callback_arg
void * callback_arg
Definition rewriteManip.h:31
substitute_phv_relids_context
Definition prepjointree.c:4454
substitute_phv_relids_context::sublevels_up
int sublevels_up
Definition prepjointree.c:4456
substitute_phv_relids_context::varno
int varno
Definition prepjointree.c:4455
substitute_phv_relids_context::subrelids
Relids subrelids
Definition prepjointree.c:4457
convert_ANY_sublink_to_join
JoinExpr * convert_ANY_sublink_to_join(PlannerInfo *root, SubLink *sublink, bool under_not, Relids available_rels)
Definition subselect.c:1341
convert_VALUES_to_ANY
ScalarArrayOpExpr * convert_VALUES_to_ANY(PlannerInfo *root, Node *testexpr, Query *values)
Definition subselect.c:1232
convert_EXISTS_sublink_to_join
JoinExpr * convert_EXISTS_sublink_to_join(PlannerInfo *root, SubLink *sublink, bool under_not, Relids available_rels)
Definition subselect.c:1593
FirstLowInvalidHeapAttributeNumber
#define FirstLowInvalidHeapAttributeNumber
Definition sysattr.h:27
table_close
void table_close(Relation relation, LOCKMODE lockmode)
Definition table.c:126
table_open
Relation table_open(Oid relationId, LOCKMODE lockmode)
Definition table.c:40
tlist_same_datatypes
bool tlist_same_datatypes(List *tlist, List *colTypes, bool junkOK)
Definition tlist.c:257
TupleDescAttr
static FormData_pg_attribute * TupleDescAttr(TupleDesc tupdesc, int i)
Definition tupdesc.h:178
contain_vars_of_level
bool contain_vars_of_level(Node *node, int levelsup)
Definition var.c:444
pull_varnos_of_level
Relids pull_varnos_of_level(PlannerInfo *root, Node *node, int levelsup)
Definition var.c:140
pull_varnos
Relids pull_varnos(PlannerInfo *root, Node *node)
Definition var.c:114
flatten_join_alias_vars
Node * flatten_join_alias_vars(PlannerInfo *root, Query *query, Node *node)
Definition var.c:781