Line data Source code
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 : * replace_empty_jointree
8 : * pull_up_sublinks
9 : * inline_set_returning_functions
10 : * pull_up_subqueries
11 : * flatten_simple_union_all
12 : * do expression preprocessing (including flattening JOIN alias vars)
13 : * reduce_outer_joins
14 : * remove_useless_result_rtes
15 : *
16 : *
17 : * Portions Copyright (c) 1996-2019, PostgreSQL Global Development Group
18 : * Portions Copyright (c) 1994, Regents of the University of California
19 : *
20 : *
21 : * IDENTIFICATION
22 : * src/backend/optimizer/prep/prepjointree.c
23 : *
24 : *-------------------------------------------------------------------------
25 : */
26 : #include "postgres.h"
27 :
28 : #include "catalog/pg_type.h"
29 : #include "nodes/makefuncs.h"
30 : #include "nodes/nodeFuncs.h"
31 : #include "optimizer/clauses.h"
32 : #include "optimizer/optimizer.h"
33 : #include "optimizer/placeholder.h"
34 : #include "optimizer/prep.h"
35 : #include "optimizer/subselect.h"
36 : #include "optimizer/tlist.h"
37 : #include "parser/parse_relation.h"
38 : #include "parser/parsetree.h"
39 : #include "rewrite/rewriteManip.h"
40 :
41 :
42 : typedef struct pullup_replace_vars_context
43 : {
44 : PlannerInfo *root;
45 : List *targetlist; /* tlist of subquery being pulled up */
46 : RangeTblEntry *target_rte; /* RTE of subquery */
47 : Relids relids; /* relids within subquery, as numbered after
48 : * pullup (set only if target_rte->lateral) */
49 : bool *outer_hasSubLinks; /* -> outer query's hasSubLinks */
50 : int varno; /* varno of subquery */
51 : bool need_phvs; /* do we need PlaceHolderVars? */
52 : bool wrap_non_vars; /* do we need 'em on *all* non-Vars? */
53 : Node **rv_cache; /* cache for results with PHVs */
54 : } pullup_replace_vars_context;
55 :
56 : typedef struct reduce_outer_joins_state
57 : {
58 : Relids relids; /* base relids within this subtree */
59 : bool contains_outer; /* does subtree contain outer join(s)? */
60 : List *sub_states; /* List of states for subtree components */
61 : } reduce_outer_joins_state;
62 :
63 : static Node *pull_up_sublinks_jointree_recurse(PlannerInfo *root, Node *jtnode,
64 : Relids *relids);
65 : static Node *pull_up_sublinks_qual_recurse(PlannerInfo *root, Node *node,
66 : Node **jtlink1, Relids available_rels1,
67 : Node **jtlink2, Relids available_rels2);
68 : static Node *pull_up_subqueries_recurse(PlannerInfo *root, Node *jtnode,
69 : JoinExpr *lowest_outer_join,
70 : JoinExpr *lowest_nulling_outer_join,
71 : AppendRelInfo *containing_appendrel);
72 : static Node *pull_up_simple_subquery(PlannerInfo *root, Node *jtnode,
73 : RangeTblEntry *rte,
74 : JoinExpr *lowest_outer_join,
75 : JoinExpr *lowest_nulling_outer_join,
76 : AppendRelInfo *containing_appendrel);
77 : static Node *pull_up_simple_union_all(PlannerInfo *root, Node *jtnode,
78 : RangeTblEntry *rte);
79 : static void pull_up_union_leaf_queries(Node *setOp, PlannerInfo *root,
80 : int parentRTindex, Query *setOpQuery,
81 : int childRToffset);
82 : static void make_setop_translation_list(Query *query, Index newvarno,
83 : List **translated_vars);
84 : static bool is_simple_subquery(Query *subquery, RangeTblEntry *rte,
85 : JoinExpr *lowest_outer_join);
86 : static Node *pull_up_simple_values(PlannerInfo *root, Node *jtnode,
87 : RangeTblEntry *rte);
88 : static bool is_simple_values(PlannerInfo *root, RangeTblEntry *rte);
89 : static bool is_simple_union_all(Query *subquery);
90 : static bool is_simple_union_all_recurse(Node *setOp, Query *setOpQuery,
91 : List *colTypes);
92 : static bool is_safe_append_member(Query *subquery);
93 : static bool jointree_contains_lateral_outer_refs(Node *jtnode, bool restricted,
94 : Relids safe_upper_varnos);
95 : static void replace_vars_in_jointree(Node *jtnode,
96 : pullup_replace_vars_context *context,
97 : JoinExpr *lowest_nulling_outer_join);
98 : static Node *pullup_replace_vars(Node *expr,
99 : pullup_replace_vars_context *context);
100 : static Node *pullup_replace_vars_callback(Var *var,
101 : replace_rte_variables_context *context);
102 : static Query *pullup_replace_vars_subquery(Query *query,
103 : pullup_replace_vars_context *context);
104 : static reduce_outer_joins_state *reduce_outer_joins_pass1(Node *jtnode);
105 : static void reduce_outer_joins_pass2(Node *jtnode,
106 : reduce_outer_joins_state *state,
107 : PlannerInfo *root,
108 : Relids nonnullable_rels,
109 : List *nonnullable_vars,
110 : List *forced_null_vars);
111 : static Node *remove_useless_results_recurse(PlannerInfo *root, Node *jtnode);
112 : static int get_result_relid(PlannerInfo *root, Node *jtnode);
113 : static void remove_result_refs(PlannerInfo *root, int varno, Node *newjtloc);
114 : static bool find_dependent_phvs(Node *node, int varno);
115 : static void substitute_phv_relids(Node *node,
116 : int varno, Relids subrelids);
117 : static void fix_append_rel_relids(List *append_rel_list, int varno,
118 : Relids subrelids);
119 : static Node *find_jointree_node_for_rel(Node *jtnode, int relid);
120 :
121 :
122 : /*
123 : * replace_empty_jointree
124 : * If the Query's jointree is empty, replace it with a dummy RTE_RESULT
125 : * relation.
126 : *
127 : * By doing this, we can avoid a bunch of corner cases that formerly existed
128 : * for SELECTs with omitted FROM clauses. An example is that a subquery
129 : * with empty jointree previously could not be pulled up, because that would
130 : * have resulted in an empty relid set, making the subquery not uniquely
131 : * identifiable for join or PlaceHolderVar processing.
132 : *
133 : * Unlike most other functions in this file, this function doesn't recurse;
134 : * we rely on other processing to invoke it on sub-queries at suitable times.
135 : */
136 : void
137 342216 : replace_empty_jointree(Query *parse)
138 : {
139 : RangeTblEntry *rte;
140 : Index rti;
141 : RangeTblRef *rtr;
142 :
143 : /* Nothing to do if jointree is already nonempty */
144 342216 : if (parse->jointree->fromlist != NIL)
145 228202 : return;
146 :
147 : /* We mustn't change it in the top level of a setop tree, either */
148 114014 : if (parse->setOperations)
149 2268 : return;
150 :
151 : /* Create suitable RTE */
152 111746 : rte = makeNode(RangeTblEntry);
153 111746 : rte->rtekind = RTE_RESULT;
154 111746 : rte->eref = makeAlias("*RESULT*", NIL);
155 :
156 : /* Add it to rangetable */
157 111746 : parse->rtable = lappend(parse->rtable, rte);
158 111746 : rti = list_length(parse->rtable);
159 :
160 : /* And jam a reference into the jointree */
161 111746 : rtr = makeNode(RangeTblRef);
162 111746 : rtr->rtindex = rti;
163 111746 : parse->jointree->fromlist = list_make1(rtr);
164 : }
165 :
166 : /*
167 : * pull_up_sublinks
168 : * Attempt to pull up ANY and EXISTS SubLinks to be treated as
169 : * semijoins or anti-semijoins.
170 : *
171 : * A clause "foo op ANY (sub-SELECT)" can be processed by pulling the
172 : * sub-SELECT up to become a rangetable entry and treating the implied
173 : * comparisons as quals of a semijoin. However, this optimization *only*
174 : * works at the top level of WHERE or a JOIN/ON clause, because we cannot
175 : * distinguish whether the ANY ought to return FALSE or NULL in cases
176 : * involving NULL inputs. Also, in an outer join's ON clause we can only
177 : * do this if the sublink is degenerate (ie, references only the nullable
178 : * side of the join). In that case it is legal to push the semijoin
179 : * down into the nullable side of the join. If the sublink references any
180 : * nonnullable-side variables then it would have to be evaluated as part
181 : * of the outer join, which makes things way too complicated.
182 : *
183 : * Under similar conditions, EXISTS and NOT EXISTS clauses can be handled
184 : * by pulling up the sub-SELECT and creating a semijoin or anti-semijoin.
185 : *
186 : * This routine searches for such clauses and does the necessary parsetree
187 : * transformations if any are found.
188 : *
189 : * This routine has to run before preprocess_expression(), so the quals
190 : * clauses are not yet reduced to implicit-AND format, and are not guaranteed
191 : * to be AND/OR-flat either. That means we need to recursively search through
192 : * explicit AND clauses. We stop as soon as we hit a non-AND item.
193 : */
194 : void
195 39140 : pull_up_sublinks(PlannerInfo *root)
196 : {
197 : Node *jtnode;
198 : Relids relids;
199 :
200 : /* Begin recursion through the jointree */
201 39140 : jtnode = pull_up_sublinks_jointree_recurse(root,
202 39140 : (Node *) root->parse->jointree,
203 : &relids);
204 :
205 : /*
206 : * root->parse->jointree must always be a FromExpr, so insert a dummy one
207 : * if we got a bare RangeTblRef or JoinExpr out of the recursion.
208 : */
209 39140 : if (IsA(jtnode, FromExpr))
210 31152 : root->parse->jointree = (FromExpr *) jtnode;
211 : else
212 7988 : root->parse->jointree = makeFromExpr(list_make1(jtnode), NULL);
213 39140 : }
214 :
215 : /*
216 : * Recurse through jointree nodes for pull_up_sublinks()
217 : *
218 : * In addition to returning the possibly-modified jointree node, we return
219 : * a relids set of the contained rels into *relids.
220 : */
221 : static Node *
222 120060 : pull_up_sublinks_jointree_recurse(PlannerInfo *root, Node *jtnode,
223 : Relids *relids)
224 : {
225 120060 : if (jtnode == NULL)
226 : {
227 0 : *relids = NULL;
228 : }
229 120060 : else if (IsA(jtnode, RangeTblRef))
230 : {
231 64822 : int varno = ((RangeTblRef *) jtnode)->rtindex;
232 :
233 64822 : *relids = bms_make_singleton(varno);
234 : /* jtnode is returned unmodified */
235 : }
236 55238 : else if (IsA(jtnode, FromExpr))
237 : {
238 39144 : FromExpr *f = (FromExpr *) jtnode;
239 39144 : List *newfromlist = NIL;
240 39144 : Relids frelids = NULL;
241 : FromExpr *newf;
242 : Node *jtlink;
243 : ListCell *l;
244 :
245 : /* First, recurse to process children and collect their relids */
246 79542 : foreach(l, f->fromlist)
247 : {
248 : Node *newchild;
249 : Relids childrelids;
250 :
251 40398 : newchild = pull_up_sublinks_jointree_recurse(root,
252 40398 : lfirst(l),
253 : &childrelids);
254 40398 : newfromlist = lappend(newfromlist, newchild);
255 40398 : frelids = bms_join(frelids, childrelids);
256 : }
257 : /* Build the replacement FromExpr; no quals yet */
258 39144 : newf = makeFromExpr(newfromlist, NULL);
259 : /* Set up a link representing the rebuilt jointree */
260 39144 : jtlink = (Node *) newf;
261 : /* Now process qual --- all children are available for use */
262 39144 : newf->quals = pull_up_sublinks_qual_recurse(root, f->quals,
263 : &jtlink, frelids,
264 : NULL, NULL);
265 :
266 : /*
267 : * Note that the result will be either newf, or a stack of JoinExprs
268 : * with newf at the base. We rely on subsequent optimization steps to
269 : * flatten this and rearrange the joins as needed.
270 : *
271 : * Although we could include the pulled-up subqueries in the returned
272 : * relids, there's no need since upper quals couldn't refer to their
273 : * outputs anyway.
274 : */
275 39144 : *relids = frelids;
276 39144 : jtnode = jtlink;
277 : }
278 16094 : else if (IsA(jtnode, JoinExpr))
279 : {
280 : JoinExpr *j;
281 : Relids leftrelids;
282 : Relids rightrelids;
283 : Node *jtlink;
284 :
285 : /*
286 : * Make a modifiable copy of join node, but don't bother copying its
287 : * subnodes (yet).
288 : */
289 16094 : j = (JoinExpr *) palloc(sizeof(JoinExpr));
290 16094 : memcpy(j, jtnode, sizeof(JoinExpr));
291 16094 : jtlink = (Node *) j;
292 :
293 : /* Recurse to process children and collect their relids */
294 16094 : j->larg = pull_up_sublinks_jointree_recurse(root, j->larg,
295 : &leftrelids);
296 16094 : j->rarg = pull_up_sublinks_jointree_recurse(root, j->rarg,
297 : &rightrelids);
298 :
299 : /*
300 : * Now process qual, showing appropriate child relids as available,
301 : * and attach any pulled-up jointree items at the right place. In the
302 : * inner-join case we put new JoinExprs above the existing one (much
303 : * as for a FromExpr-style join). In outer-join cases the new
304 : * JoinExprs must go into the nullable side of the outer join. The
305 : * point of the available_rels machinations is to ensure that we only
306 : * pull up quals for which that's okay.
307 : *
308 : * We don't expect to see any pre-existing JOIN_SEMI or JOIN_ANTI
309 : * nodes here.
310 : */
311 16094 : switch (j->jointype)
312 : {
313 : case JOIN_INNER:
314 3930 : j->quals = pull_up_sublinks_qual_recurse(root, j->quals,
315 : &jtlink,
316 : bms_union(leftrelids,
317 : rightrelids),
318 : NULL, NULL);
319 3930 : break;
320 : case JOIN_LEFT:
321 12164 : j->quals = pull_up_sublinks_qual_recurse(root, j->quals,
322 : &j->rarg,
323 : rightrelids,
324 : NULL, NULL);
325 12164 : break;
326 : case JOIN_FULL:
327 : /* can't do anything with full-join quals */
328 0 : break;
329 : case JOIN_RIGHT:
330 0 : j->quals = pull_up_sublinks_qual_recurse(root, j->quals,
331 : &j->larg,
332 : leftrelids,
333 : NULL, NULL);
334 0 : break;
335 : default:
336 0 : elog(ERROR, "unrecognized join type: %d",
337 : (int) j->jointype);
338 : break;
339 : }
340 :
341 : /*
342 : * Although we could include the pulled-up subqueries in the returned
343 : * relids, there's no need since upper quals couldn't refer to their
344 : * outputs anyway. But we *do* need to include the join's own rtindex
345 : * because we haven't yet collapsed join alias variables, so upper
346 : * levels would mistakenly think they couldn't use references to this
347 : * join.
348 : */
349 16094 : *relids = bms_join(leftrelids, rightrelids);
350 16094 : if (j->rtindex)
351 16094 : *relids = bms_add_member(*relids, j->rtindex);
352 16094 : jtnode = jtlink;
353 : }
354 : else
355 0 : elog(ERROR, "unrecognized node type: %d",
356 : (int) nodeTag(jtnode));
357 120060 : return jtnode;
358 : }
359 :
360 : /*
361 : * Recurse through top-level qual nodes for pull_up_sublinks()
362 : *
363 : * jtlink1 points to the link in the jointree where any new JoinExprs should
364 : * be inserted if they reference available_rels1 (i.e., available_rels1
365 : * denotes the relations present underneath jtlink1). Optionally, jtlink2 can
366 : * point to a second link where new JoinExprs should be inserted if they
367 : * reference available_rels2 (pass NULL for both those arguments if not used).
368 : * Note that SubLinks referencing both sets of variables cannot be optimized.
369 : * If we find multiple pull-up-able SubLinks, they'll get stacked onto jtlink1
370 : * and/or jtlink2 in the order we encounter them. We rely on subsequent
371 : * optimization to rearrange the stack if appropriate.
372 : *
373 : * Returns the replacement qual node, or NULL if the qual should be removed.
374 : */
375 : static Node *
376 108850 : pull_up_sublinks_qual_recurse(PlannerInfo *root, Node *node,
377 : Node **jtlink1, Relids available_rels1,
378 : Node **jtlink2, Relids available_rels2)
379 : {
380 108850 : if (node == NULL)
381 6358 : return NULL;
382 102492 : if (IsA(node, SubLink))
383 : {
384 762 : SubLink *sublink = (SubLink *) node;
385 : JoinExpr *j;
386 : Relids child_rels;
387 :
388 : /* Is it a convertible ANY or EXISTS clause? */
389 762 : if (sublink->subLinkType == ANY_SUBLINK)
390 : {
391 584 : if ((j = convert_ANY_sublink_to_join(root, sublink,
392 : available_rels1)) != NULL)
393 : {
394 : /* Yes; insert the new join node into the join tree */
395 536 : j->larg = *jtlink1;
396 536 : *jtlink1 = (Node *) j;
397 : /* Recursively process pulled-up jointree nodes */
398 536 : j->rarg = pull_up_sublinks_jointree_recurse(root,
399 : j->rarg,
400 : &child_rels);
401 :
402 : /*
403 : * Now recursively process the pulled-up quals. Any inserted
404 : * joins can get stacked onto either j->larg or j->rarg,
405 : * depending on which rels they reference.
406 : */
407 536 : j->quals = pull_up_sublinks_qual_recurse(root,
408 : j->quals,
409 : &j->larg,
410 : available_rels1,
411 : &j->rarg,
412 : child_rels);
413 : /* Return NULL representing constant TRUE */
414 536 : return NULL;
415 : }
416 48 : if (available_rels2 != NULL &&
417 : (j = convert_ANY_sublink_to_join(root, sublink,
418 : available_rels2)) != NULL)
419 : {
420 : /* Yes; insert the new join node into the join tree */
421 0 : j->larg = *jtlink2;
422 0 : *jtlink2 = (Node *) j;
423 : /* Recursively process pulled-up jointree nodes */
424 0 : j->rarg = pull_up_sublinks_jointree_recurse(root,
425 : j->rarg,
426 : &child_rels);
427 :
428 : /*
429 : * Now recursively process the pulled-up quals. Any inserted
430 : * joins can get stacked onto either j->larg or j->rarg,
431 : * depending on which rels they reference.
432 : */
433 0 : j->quals = pull_up_sublinks_qual_recurse(root,
434 : j->quals,
435 : &j->larg,
436 : available_rels2,
437 : &j->rarg,
438 : child_rels);
439 : /* Return NULL representing constant TRUE */
440 0 : return NULL;
441 : }
442 : }
443 178 : else if (sublink->subLinkType == EXISTS_SUBLINK)
444 : {
445 150 : if ((j = convert_EXISTS_sublink_to_join(root, sublink, false,
446 : available_rels1)) != NULL)
447 : {
448 : /* Yes; insert the new join node into the join tree */
449 118 : j->larg = *jtlink1;
450 118 : *jtlink1 = (Node *) j;
451 : /* Recursively process pulled-up jointree nodes */
452 118 : j->rarg = pull_up_sublinks_jointree_recurse(root,
453 : j->rarg,
454 : &child_rels);
455 :
456 : /*
457 : * Now recursively process the pulled-up quals. Any inserted
458 : * joins can get stacked onto either j->larg or j->rarg,
459 : * depending on which rels they reference.
460 : */
461 118 : j->quals = pull_up_sublinks_qual_recurse(root,
462 : j->quals,
463 : &j->larg,
464 : available_rels1,
465 : &j->rarg,
466 : child_rels);
467 : /* Return NULL representing constant TRUE */
468 118 : return NULL;
469 : }
470 32 : if (available_rels2 != NULL &&
471 : (j = convert_EXISTS_sublink_to_join(root, sublink, false,
472 : available_rels2)) != NULL)
473 : {
474 : /* Yes; insert the new join node into the join tree */
475 0 : j->larg = *jtlink2;
476 0 : *jtlink2 = (Node *) j;
477 : /* Recursively process pulled-up jointree nodes */
478 0 : j->rarg = pull_up_sublinks_jointree_recurse(root,
479 : j->rarg,
480 : &child_rels);
481 :
482 : /*
483 : * Now recursively process the pulled-up quals. Any inserted
484 : * joins can get stacked onto either j->larg or j->rarg,
485 : * depending on which rels they reference.
486 : */
487 0 : j->quals = pull_up_sublinks_qual_recurse(root,
488 : j->quals,
489 : &j->larg,
490 : available_rels2,
491 : &j->rarg,
492 : child_rels);
493 : /* Return NULL representing constant TRUE */
494 0 : return NULL;
495 : }
496 : }
497 : /* Else return it unmodified */
498 108 : return node;
499 : }
500 101730 : if (is_notclause(node))
501 : {
502 : /* If the immediate argument of NOT is EXISTS, try to convert */
503 9796 : SubLink *sublink = (SubLink *) get_notclausearg((Expr *) node);
504 : JoinExpr *j;
505 : Relids child_rels;
506 :
507 9796 : if (sublink && IsA(sublink, SubLink))
508 : {
509 7740 : if (sublink->subLinkType == EXISTS_SUBLINK)
510 : {
511 7692 : if ((j = convert_EXISTS_sublink_to_join(root, sublink, true,
512 : available_rels1)) != NULL)
513 : {
514 : /* Yes; insert the new join node into the join tree */
515 7680 : j->larg = *jtlink1;
516 7680 : *jtlink1 = (Node *) j;
517 : /* Recursively process pulled-up jointree nodes */
518 7680 : j->rarg = pull_up_sublinks_jointree_recurse(root,
519 : j->rarg,
520 : &child_rels);
521 :
522 : /*
523 : * Now recursively process the pulled-up quals. Because
524 : * we are underneath a NOT, we can't pull up sublinks that
525 : * reference the left-hand stuff, but it's still okay to
526 : * pull up sublinks referencing j->rarg.
527 : */
528 7680 : j->quals = pull_up_sublinks_qual_recurse(root,
529 : j->quals,
530 : &j->rarg,
531 : child_rels,
532 : NULL, NULL);
533 : /* Return NULL representing constant TRUE */
534 7680 : return NULL;
535 : }
536 12 : if (available_rels2 != NULL &&
537 : (j = convert_EXISTS_sublink_to_join(root, sublink, true,
538 : available_rels2)) != NULL)
539 : {
540 : /* Yes; insert the new join node into the join tree */
541 0 : j->larg = *jtlink2;
542 0 : *jtlink2 = (Node *) j;
543 : /* Recursively process pulled-up jointree nodes */
544 0 : j->rarg = pull_up_sublinks_jointree_recurse(root,
545 : j->rarg,
546 : &child_rels);
547 :
548 : /*
549 : * Now recursively process the pulled-up quals. Because
550 : * we are underneath a NOT, we can't pull up sublinks that
551 : * reference the left-hand stuff, but it's still okay to
552 : * pull up sublinks referencing j->rarg.
553 : */
554 0 : j->quals = pull_up_sublinks_qual_recurse(root,
555 : j->quals,
556 : &j->rarg,
557 : child_rels,
558 : NULL, NULL);
559 : /* Return NULL representing constant TRUE */
560 0 : return NULL;
561 : }
562 : }
563 : }
564 : /* Else return it unmodified */
565 2116 : return node;
566 : }
567 91934 : if (is_andclause(node))
568 : {
569 : /* Recurse into AND clause */
570 17630 : List *newclauses = NIL;
571 : ListCell *l;
572 :
573 62908 : foreach(l, ((BoolExpr *) node)->args)
574 : {
575 45278 : Node *oldclause = (Node *) lfirst(l);
576 : Node *newclause;
577 :
578 45278 : newclause = pull_up_sublinks_qual_recurse(root,
579 : oldclause,
580 : jtlink1,
581 : available_rels1,
582 : jtlink2,
583 : available_rels2);
584 45278 : if (newclause)
585 43304 : newclauses = lappend(newclauses, newclause);
586 : }
587 : /* We might have got back fewer clauses than we started with */
588 17630 : if (newclauses == NIL)
589 318 : return NULL;
590 17312 : else if (list_length(newclauses) == 1)
591 862 : return (Node *) linitial(newclauses);
592 : else
593 16450 : return (Node *) make_andclause(newclauses);
594 : }
595 : /* Stop if not an AND */
596 74304 : return node;
597 : }
598 :
599 : /*
600 : * inline_set_returning_functions
601 : * Attempt to "inline" set-returning functions in the FROM clause.
602 : *
603 : * If an RTE_FUNCTION rtable entry invokes a set-returning function that
604 : * contains just a simple SELECT, we can convert the rtable entry to an
605 : * RTE_SUBQUERY entry exposing the SELECT directly. This is especially
606 : * useful if the subquery can then be "pulled up" for further optimization,
607 : * but we do it even if not, to reduce executor overhead.
608 : *
609 : * This has to be done before we have started to do any optimization of
610 : * subqueries, else any such steps wouldn't get applied to subqueries
611 : * obtained via inlining. However, we do it after pull_up_sublinks
612 : * so that we can inline any functions used in SubLink subselects.
613 : *
614 : * Like most of the planner, this feels free to scribble on its input data
615 : * structure.
616 : */
617 : void
618 334418 : inline_set_returning_functions(PlannerInfo *root)
619 : {
620 : ListCell *rt;
621 :
622 884614 : foreach(rt, root->parse->rtable)
623 : {
624 550196 : RangeTblEntry *rte = (RangeTblEntry *) lfirst(rt);
625 :
626 550196 : if (rte->rtekind == RTE_FUNCTION)
627 : {
628 : Query *funcquery;
629 :
630 : /* Check safety of expansion, and expand if possible */
631 28796 : funcquery = inline_set_returning_function(root, rte);
632 28796 : if (funcquery)
633 : {
634 : /* Successful expansion, convert the RTE to a subquery */
635 32 : rte->rtekind = RTE_SUBQUERY;
636 32 : rte->subquery = funcquery;
637 32 : rte->security_barrier = false;
638 : /* Clear fields that should not be set in a subquery RTE */
639 32 : rte->functions = NIL;
640 32 : rte->funcordinality = false;
641 : }
642 : }
643 : }
644 334418 : }
645 :
646 : /*
647 : * pull_up_subqueries
648 : * Look for subqueries in the rangetable that can be pulled up into
649 : * the parent query. If the subquery has no special features like
650 : * grouping/aggregation then we can merge it into the parent's jointree.
651 : * Also, subqueries that are simple UNION ALL structures can be
652 : * converted into "append relations".
653 : */
654 : void
655 334418 : pull_up_subqueries(PlannerInfo *root)
656 : {
657 : /* Top level of jointree must always be a FromExpr */
658 : Assert(IsA(root->parse->jointree, FromExpr));
659 : /* Recursion starts with no containing join nor appendrel */
660 668832 : root->parse->jointree = (FromExpr *)
661 334418 : pull_up_subqueries_recurse(root, (Node *) root->parse->jointree,
662 : NULL, NULL, NULL);
663 : /* We should still have a FromExpr */
664 : Assert(IsA(root->parse->jointree, FromExpr));
665 334414 : }
666 :
667 : /*
668 : * pull_up_subqueries_recurse
669 : * Recursive guts of pull_up_subqueries.
670 : *
671 : * This recursively processes the jointree and returns a modified jointree.
672 : *
673 : * If this jointree node is within either side of an outer join, then
674 : * lowest_outer_join references the lowest such JoinExpr node; otherwise
675 : * it is NULL. We use this to constrain the effects of LATERAL subqueries.
676 : *
677 : * If this jointree node is within the nullable side of an outer join, then
678 : * lowest_nulling_outer_join references the lowest such JoinExpr node;
679 : * otherwise it is NULL. This forces use of the PlaceHolderVar mechanism for
680 : * references to non-nullable targetlist items, but only for references above
681 : * that join.
682 : *
683 : * If we are looking at a member subquery of an append relation,
684 : * containing_appendrel describes that relation; else it is NULL.
685 : * This forces use of the PlaceHolderVar mechanism for all non-Var targetlist
686 : * items, and puts some additional restrictions on what can be pulled up.
687 : *
688 : * A tricky aspect of this code is that if we pull up a subquery we have
689 : * to replace Vars that reference the subquery's outputs throughout the
690 : * parent query, including quals attached to jointree nodes above the one
691 : * we are currently processing! We handle this by being careful to maintain
692 : * validity of the jointree structure while recursing, in the following sense:
693 : * whenever we recurse, all qual expressions in the tree must be reachable
694 : * from the top level, in case the recursive call needs to modify them.
695 : *
696 : * Notice also that we can't turn pullup_replace_vars loose on the whole
697 : * jointree, because it'd return a mutated copy of the tree; we have to
698 : * invoke it just on the quals, instead. This behavior is what makes it
699 : * reasonable to pass lowest_outer_join and lowest_nulling_outer_join as
700 : * pointers rather than some more-indirect way of identifying the lowest
701 : * OJs. Likewise, we don't replace append_rel_list members but only their
702 : * substructure, so the containing_appendrel reference is safe to use.
703 : */
704 : static Node *
705 806914 : pull_up_subqueries_recurse(PlannerInfo *root, Node *jtnode,
706 : JoinExpr *lowest_outer_join,
707 : JoinExpr *lowest_nulling_outer_join,
708 : AppendRelInfo *containing_appendrel)
709 : {
710 : Assert(jtnode != NULL);
711 806914 : if (IsA(jtnode, RangeTblRef))
712 : {
713 407462 : int varno = ((RangeTblRef *) jtnode)->rtindex;
714 407462 : RangeTblEntry *rte = rt_fetch(varno, root->parse->rtable);
715 :
716 : /*
717 : * Is this a subquery RTE, and if so, is the subquery simple enough to
718 : * pull up?
719 : *
720 : * If we are looking at an append-relation member, we can't pull it up
721 : * unless is_safe_append_member says so.
722 : */
723 451458 : if (rte->rtekind == RTE_SUBQUERY &&
724 84164 : is_simple_subquery(rte->subquery, rte, lowest_outer_join) &&
725 3620 : (containing_appendrel == NULL ||
726 3620 : is_safe_append_member(rte->subquery)))
727 37930 : return pull_up_simple_subquery(root, jtnode, rte,
728 : lowest_outer_join,
729 : lowest_nulling_outer_join,
730 : containing_appendrel);
731 :
732 : /*
733 : * Alternatively, is it a simple UNION ALL subquery? If so, flatten
734 : * into an "append relation".
735 : *
736 : * It's safe to do this regardless of whether this query is itself an
737 : * appendrel member. (If you're thinking we should try to flatten the
738 : * two levels of appendrel together, you're right; but we handle that
739 : * in set_append_rel_pathlist, not here.)
740 : */
741 375598 : if (rte->rtekind == RTE_SUBQUERY &&
742 6066 : is_simple_union_all(rte->subquery))
743 666 : return pull_up_simple_union_all(root, jtnode, rte);
744 :
745 : /*
746 : * Or perhaps it's a simple VALUES RTE?
747 : *
748 : * We don't allow VALUES pullup below an outer join nor into an
749 : * appendrel (such cases are impossible anyway at the moment).
750 : */
751 368866 : if (rte->rtekind == RTE_VALUES &&
752 4284 : lowest_outer_join == NULL &&
753 4284 : containing_appendrel == NULL &&
754 4284 : is_simple_values(root, rte))
755 518 : return pull_up_simple_values(root, jtnode, rte);
756 :
757 : /* Otherwise, do nothing at this node. */
758 : }
759 399452 : else if (IsA(jtnode, FromExpr))
760 : {
761 342410 : FromExpr *f = (FromExpr *) jtnode;
762 : ListCell *l;
763 :
764 : Assert(containing_appendrel == NULL);
765 : /* Recursively transform all the child nodes */
766 696930 : foreach(l, f->fromlist)
767 : {
768 354524 : lfirst(l) = pull_up_subqueries_recurse(root, lfirst(l),
769 : lowest_outer_join,
770 : lowest_nulling_outer_join,
771 : NULL);
772 : }
773 : }
774 57042 : else if (IsA(jtnode, JoinExpr))
775 : {
776 57042 : JoinExpr *j = (JoinExpr *) jtnode;
777 :
778 : Assert(containing_appendrel == NULL);
779 : /* Recurse, being careful to tell myself when inside outer join */
780 57042 : switch (j->jointype)
781 : {
782 : case JOIN_INNER:
783 13708 : j->larg = pull_up_subqueries_recurse(root, j->larg,
784 : lowest_outer_join,
785 : lowest_nulling_outer_join,
786 : NULL);
787 13708 : j->rarg = pull_up_subqueries_recurse(root, j->rarg,
788 : lowest_outer_join,
789 : lowest_nulling_outer_join,
790 : NULL);
791 13708 : break;
792 : case JOIN_LEFT:
793 : case JOIN_SEMI:
794 : case JOIN_ANTI:
795 42696 : j->larg = pull_up_subqueries_recurse(root, j->larg,
796 : j,
797 : lowest_nulling_outer_join,
798 : NULL);
799 42696 : j->rarg = pull_up_subqueries_recurse(root, j->rarg,
800 : j,
801 : j,
802 : NULL);
803 42696 : break;
804 : case JOIN_FULL:
805 470 : j->larg = pull_up_subqueries_recurse(root, j->larg,
806 : j,
807 : j,
808 : NULL);
809 470 : j->rarg = pull_up_subqueries_recurse(root, j->rarg,
810 : j,
811 : j,
812 : NULL);
813 470 : break;
814 : case JOIN_RIGHT:
815 168 : j->larg = pull_up_subqueries_recurse(root, j->larg,
816 : j,
817 : j,
818 : NULL);
819 168 : j->rarg = pull_up_subqueries_recurse(root, j->rarg,
820 : j,
821 : lowest_nulling_outer_join,
822 : NULL);
823 168 : break;
824 : default:
825 0 : elog(ERROR, "unrecognized join type: %d",
826 : (int) j->jointype);
827 : break;
828 : }
829 : }
830 : else
831 0 : elog(ERROR, "unrecognized node type: %d",
832 : (int) nodeTag(jtnode));
833 767796 : return jtnode;
834 : }
835 :
836 : /*
837 : * pull_up_simple_subquery
838 : * Attempt to pull up a single simple subquery.
839 : *
840 : * jtnode is a RangeTblRef that has been tentatively identified as a simple
841 : * subquery by pull_up_subqueries. We return the replacement jointree node,
842 : * or jtnode itself if we determine that the subquery can't be pulled up
843 : * after all.
844 : *
845 : * rte is the RangeTblEntry referenced by jtnode. Remaining parameters are
846 : * as for pull_up_subqueries_recurse.
847 : */
848 : static Node *
849 37930 : pull_up_simple_subquery(PlannerInfo *root, Node *jtnode, RangeTblEntry *rte,
850 : JoinExpr *lowest_outer_join,
851 : JoinExpr *lowest_nulling_outer_join,
852 : AppendRelInfo *containing_appendrel)
853 : {
854 37930 : Query *parse = root->parse;
855 37930 : int varno = ((RangeTblRef *) jtnode)->rtindex;
856 : Query *subquery;
857 : PlannerInfo *subroot;
858 : int rtoffset;
859 : pullup_replace_vars_context rvcontext;
860 : ListCell *lc;
861 :
862 : /*
863 : * Need a modifiable copy of the subquery to hack on. Even if we didn't
864 : * sometimes choose not to pull up below, we must do this to avoid
865 : * problems if the same subquery is referenced from multiple jointree
866 : * items (which can't happen normally, but might after rule rewriting).
867 : */
868 37930 : subquery = copyObject(rte->subquery);
869 :
870 : /*
871 : * Create a PlannerInfo data structure for this subquery.
872 : *
873 : * NOTE: the next few steps should match the first processing in
874 : * subquery_planner(). Can we refactor to avoid code duplication, or
875 : * would that just make things uglier?
876 : */
877 37930 : subroot = makeNode(PlannerInfo);
878 37930 : subroot->parse = subquery;
879 37930 : subroot->glob = root->glob;
880 37930 : subroot->query_level = root->query_level;
881 37930 : subroot->parent_root = root->parent_root;
882 37930 : subroot->plan_params = NIL;
883 37930 : subroot->outer_params = NULL;
884 37930 : subroot->planner_cxt = CurrentMemoryContext;
885 37930 : subroot->init_plans = NIL;
886 37930 : subroot->cte_plan_ids = NIL;
887 37930 : subroot->multiexpr_params = NIL;
888 37930 : subroot->eq_classes = NIL;
889 37930 : subroot->append_rel_list = NIL;
890 37930 : subroot->rowMarks = NIL;
891 37930 : memset(subroot->upper_rels, 0, sizeof(subroot->upper_rels));
892 37930 : memset(subroot->upper_targets, 0, sizeof(subroot->upper_targets));
893 37930 : subroot->processed_tlist = NIL;
894 37930 : subroot->grouping_map = NULL;
895 37930 : subroot->minmax_aggs = NIL;
896 37930 : subroot->qual_security_level = 0;
897 37930 : subroot->inhTargetKind = INHKIND_NONE;
898 37930 : subroot->hasRecursion = false;
899 37930 : subroot->wt_param_id = -1;
900 37930 : subroot->non_recursive_path = NULL;
901 :
902 : /* No CTEs to worry about */
903 : Assert(subquery->cteList == NIL);
904 :
905 : /*
906 : * If the FROM clause is empty, replace it with a dummy RTE_RESULT RTE, so
907 : * that we don't need so many special cases to deal with that situation.
908 : */
909 37930 : replace_empty_jointree(subquery);
910 :
911 : /*
912 : * Pull up any SubLinks within the subquery's quals, so that we don't
913 : * leave unoptimized SubLinks behind.
914 : */
915 37930 : if (subquery->hasSubLinks)
916 9690 : pull_up_sublinks(subroot);
917 :
918 : /*
919 : * Similarly, inline any set-returning functions in its rangetable.
920 : */
921 37930 : inline_set_returning_functions(subroot);
922 :
923 : /*
924 : * Recursively pull up the subquery's subqueries, so that
925 : * pull_up_subqueries' processing is complete for its jointree and
926 : * rangetable.
927 : *
928 : * Note: it's okay that the subquery's recursion starts with NULL for
929 : * containing-join info, even if we are within an outer join in the upper
930 : * query; the lower query starts with a clean slate for outer-join
931 : * semantics. Likewise, we needn't pass down appendrel state.
932 : */
933 37930 : pull_up_subqueries(subroot);
934 :
935 : /*
936 : * Now we must recheck whether the subquery is still simple enough to pull
937 : * up. If not, abandon processing it.
938 : *
939 : * We don't really need to recheck all the conditions involved, but it's
940 : * easier just to keep this "if" looking the same as the one in
941 : * pull_up_subqueries_recurse.
942 : */
943 75824 : if (is_simple_subquery(subquery, rte, lowest_outer_join) &&
944 1382 : (containing_appendrel == NULL || is_safe_append_member(subquery)))
945 : {
946 : /* good to go */
947 : }
948 : else
949 : {
950 : /*
951 : * Give up, return unmodified RangeTblRef.
952 : *
953 : * Note: The work we just did will be redone when the subquery gets
954 : * planned on its own. Perhaps we could avoid that by storing the
955 : * modified subquery back into the rangetable, but I'm not gonna risk
956 : * it now.
957 : */
958 36 : return jtnode;
959 : }
960 :
961 : /*
962 : * We must flatten any join alias Vars in the subquery's targetlist,
963 : * because pulling up the subquery's subqueries might have changed their
964 : * expansions into arbitrary expressions, which could affect
965 : * pullup_replace_vars' decisions about whether PlaceHolderVar wrappers
966 : * are needed for tlist entries. (Likely it'd be better to do
967 : * flatten_join_alias_vars on the whole query tree at some earlier stage,
968 : * maybe even in the rewriter; but for now let's just fix this case here.)
969 : */
970 37894 : subquery->targetList = (List *)
971 37894 : flatten_join_alias_vars(subroot->parse, (Node *) subquery->targetList);
972 :
973 : /*
974 : * Adjust level-0 varnos in subquery so that we can append its rangetable
975 : * to upper query's. We have to fix the subquery's append_rel_list as
976 : * well.
977 : */
978 37894 : rtoffset = list_length(parse->rtable);
979 37894 : OffsetVarNodes((Node *) subquery, rtoffset, 0);
980 37894 : OffsetVarNodes((Node *) subroot->append_rel_list, rtoffset, 0);
981 :
982 : /*
983 : * Upper-level vars in subquery are now one level closer to their parent
984 : * than before.
985 : */
986 37894 : IncrementVarSublevelsUp((Node *) subquery, -1, 1);
987 37894 : IncrementVarSublevelsUp((Node *) subroot->append_rel_list, -1, 1);
988 :
989 : /*
990 : * The subquery's targetlist items are now in the appropriate form to
991 : * insert into the top query, except that we may need to wrap them in
992 : * PlaceHolderVars. Set up required context data for pullup_replace_vars.
993 : */
994 37894 : rvcontext.root = root;
995 37894 : rvcontext.targetlist = subquery->targetList;
996 37894 : rvcontext.target_rte = rte;
997 37894 : if (rte->lateral)
998 280 : rvcontext.relids = get_relids_in_jointree((Node *) subquery->jointree,
999 : true);
1000 : else /* won't need relids */
1001 37614 : rvcontext.relids = NULL;
1002 37894 : rvcontext.outer_hasSubLinks = &parse->hasSubLinks;
1003 37894 : rvcontext.varno = varno;
1004 : /* these flags will be set below, if needed */
1005 37894 : rvcontext.need_phvs = false;
1006 37894 : rvcontext.wrap_non_vars = false;
1007 : /* initialize cache array with indexes 0 .. length(tlist) */
1008 37894 : rvcontext.rv_cache = palloc0((list_length(subquery->targetList) + 1) *
1009 : sizeof(Node *));
1010 :
1011 : /*
1012 : * If we are under an outer join then non-nullable items and lateral
1013 : * references may have to be turned into PlaceHolderVars.
1014 : */
1015 37894 : if (lowest_nulling_outer_join != NULL)
1016 1190 : rvcontext.need_phvs = true;
1017 :
1018 : /*
1019 : * If we are dealing with an appendrel member then anything that's not a
1020 : * simple Var has to be turned into a PlaceHolderVar. We force this to
1021 : * ensure that what we pull up doesn't get merged into a surrounding
1022 : * expression during later processing and then fail to match the
1023 : * expression actually available from the appendrel.
1024 : */
1025 37894 : if (containing_appendrel != NULL)
1026 : {
1027 1346 : rvcontext.need_phvs = true;
1028 1346 : rvcontext.wrap_non_vars = true;
1029 : }
1030 :
1031 : /*
1032 : * If the parent query uses grouping sets, we need a PlaceHolderVar for
1033 : * anything that's not a simple Var. Again, this ensures that expressions
1034 : * retain their separate identity so that they will match grouping set
1035 : * columns when appropriate. (It'd be sufficient to wrap values used in
1036 : * grouping set columns, and do so only in non-aggregated portions of the
1037 : * tlist and havingQual, but that would require a lot of infrastructure
1038 : * that pullup_replace_vars hasn't currently got.)
1039 : */
1040 37894 : if (parse->groupingSets)
1041 : {
1042 132 : rvcontext.need_phvs = true;
1043 132 : rvcontext.wrap_non_vars = true;
1044 : }
1045 :
1046 : /*
1047 : * Replace all of the top query's references to the subquery's outputs
1048 : * with copies of the adjusted subtlist items, being careful not to
1049 : * replace any of the jointree structure. (This'd be a lot cleaner if we
1050 : * could use query_tree_mutator.) We have to use PHVs in the targetList,
1051 : * returningList, and havingQual, since those are certainly above any
1052 : * outer join. replace_vars_in_jointree tracks its location in the
1053 : * jointree and uses PHVs or not appropriately.
1054 : */
1055 37894 : parse->targetList = (List *)
1056 37894 : pullup_replace_vars((Node *) parse->targetList, &rvcontext);
1057 37894 : parse->returningList = (List *)
1058 37894 : pullup_replace_vars((Node *) parse->returningList, &rvcontext);
1059 37894 : if (parse->onConflict)
1060 : {
1061 32 : parse->onConflict->onConflictSet = (List *)
1062 16 : pullup_replace_vars((Node *) parse->onConflict->onConflictSet,
1063 : &rvcontext);
1064 32 : parse->onConflict->onConflictWhere =
1065 16 : pullup_replace_vars(parse->onConflict->onConflictWhere,
1066 : &rvcontext);
1067 :
1068 : /*
1069 : * We assume ON CONFLICT's arbiterElems, arbiterWhere, exclRelTlist
1070 : * can't contain any references to a subquery
1071 : */
1072 : }
1073 37894 : replace_vars_in_jointree((Node *) parse->jointree, &rvcontext,
1074 : lowest_nulling_outer_join);
1075 : Assert(parse->setOperations == NULL);
1076 37890 : parse->havingQual = pullup_replace_vars(parse->havingQual, &rvcontext);
1077 :
1078 : /*
1079 : * Replace references in the translated_vars lists of appendrels. When
1080 : * pulling up an appendrel member, we do not need PHVs in the list of the
1081 : * parent appendrel --- there isn't any outer join between. Elsewhere, use
1082 : * PHVs for safety. (This analysis could be made tighter but it seems
1083 : * unlikely to be worth much trouble.)
1084 : */
1085 40324 : foreach(lc, root->append_rel_list)
1086 : {
1087 2434 : AppendRelInfo *appinfo = (AppendRelInfo *) lfirst(lc);
1088 2434 : bool save_need_phvs = rvcontext.need_phvs;
1089 :
1090 2434 : if (appinfo == containing_appendrel)
1091 1346 : rvcontext.need_phvs = false;
1092 2434 : appinfo->translated_vars = (List *)
1093 2434 : pullup_replace_vars((Node *) appinfo->translated_vars, &rvcontext);
1094 2434 : rvcontext.need_phvs = save_need_phvs;
1095 : }
1096 :
1097 : /*
1098 : * Replace references in the joinaliasvars lists of join RTEs.
1099 : *
1100 : * You might think that we could avoid using PHVs for alias vars of joins
1101 : * below lowest_nulling_outer_join, but that doesn't work because the
1102 : * alias vars could be referenced above that join; we need the PHVs to be
1103 : * present in such references after the alias vars get flattened. (It
1104 : * might be worth trying to be smarter here, someday.)
1105 : */
1106 104196 : foreach(lc, parse->rtable)
1107 : {
1108 66306 : RangeTblEntry *otherrte = (RangeTblEntry *) lfirst(lc);
1109 :
1110 66306 : if (otherrte->rtekind == RTE_JOIN)
1111 2520 : otherrte->joinaliasvars = (List *)
1112 2520 : pullup_replace_vars((Node *) otherrte->joinaliasvars,
1113 : &rvcontext);
1114 : }
1115 :
1116 : /*
1117 : * If the subquery had a LATERAL marker, propagate that to any of its
1118 : * child RTEs that could possibly now contain lateral cross-references.
1119 : * The children might or might not contain any actual lateral
1120 : * cross-references, but we have to mark the pulled-up child RTEs so that
1121 : * later planner stages will check for such.
1122 : */
1123 37890 : if (rte->lateral)
1124 : {
1125 732 : foreach(lc, subquery->rtable)
1126 : {
1127 452 : RangeTblEntry *child_rte = (RangeTblEntry *) lfirst(lc);
1128 :
1129 452 : switch (child_rte->rtekind)
1130 : {
1131 : case RTE_RELATION:
1132 216 : if (child_rte->tablesample)
1133 12 : child_rte->lateral = true;
1134 216 : break;
1135 : case RTE_SUBQUERY:
1136 : case RTE_FUNCTION:
1137 : case RTE_VALUES:
1138 : case RTE_TABLEFUNC:
1139 92 : child_rte->lateral = true;
1140 92 : break;
1141 : case RTE_JOIN:
1142 : case RTE_CTE:
1143 : case RTE_NAMEDTUPLESTORE:
1144 : case RTE_RESULT:
1145 : /* these can't contain any lateral references */
1146 144 : break;
1147 : }
1148 : }
1149 : }
1150 :
1151 : /*
1152 : * Now append the adjusted rtable entries to upper query. (We hold off
1153 : * until after fixing the upper rtable entries; no point in running that
1154 : * code on the subquery ones too.)
1155 : */
1156 37890 : parse->rtable = list_concat(parse->rtable, subquery->rtable);
1157 :
1158 : /*
1159 : * Pull up any FOR UPDATE/SHARE markers, too. (OffsetVarNodes already
1160 : * adjusted the marker rtindexes, so just concat the lists.)
1161 : */
1162 37890 : parse->rowMarks = list_concat(parse->rowMarks, subquery->rowMarks);
1163 :
1164 : /*
1165 : * We also have to fix the relid sets of any PlaceHolderVar nodes in the
1166 : * parent query. (This could perhaps be done by pullup_replace_vars(),
1167 : * but it seems cleaner to use two passes.) Note in particular that any
1168 : * PlaceHolderVar nodes just created by pullup_replace_vars() will be
1169 : * adjusted, so having created them with the subquery's varno is correct.
1170 : *
1171 : * Likewise, relids appearing in AppendRelInfo nodes have to be fixed. We
1172 : * already checked that this won't require introducing multiple subrelids
1173 : * into the single-slot AppendRelInfo structs.
1174 : */
1175 70922 : if (parse->hasSubLinks || root->glob->lastPHId != 0 ||
1176 33032 : root->append_rel_list)
1177 : {
1178 : Relids subrelids;
1179 :
1180 5816 : subrelids = get_relids_in_jointree((Node *) subquery->jointree, false);
1181 5816 : substitute_phv_relids((Node *) parse, varno, subrelids);
1182 5816 : fix_append_rel_relids(root->append_rel_list, varno, subrelids);
1183 : }
1184 :
1185 : /*
1186 : * And now add subquery's AppendRelInfos to our list.
1187 : */
1188 37890 : root->append_rel_list = list_concat(root->append_rel_list,
1189 : subroot->append_rel_list);
1190 :
1191 : /*
1192 : * We don't have to do the equivalent bookkeeping for outer-join info,
1193 : * because that hasn't been set up yet. placeholder_list likewise.
1194 : */
1195 : Assert(root->join_info_list == NIL);
1196 : Assert(subroot->join_info_list == NIL);
1197 : Assert(root->placeholder_list == NIL);
1198 : Assert(subroot->placeholder_list == NIL);
1199 :
1200 : /*
1201 : * Miscellaneous housekeeping.
1202 : *
1203 : * Although replace_rte_variables() faithfully updated parse->hasSubLinks
1204 : * if it copied any SubLinks out of the subquery's targetlist, we still
1205 : * could have SubLinks added to the query in the expressions of FUNCTION
1206 : * and VALUES RTEs copied up from the subquery. So it's necessary to copy
1207 : * subquery->hasSubLinks anyway. Perhaps this can be improved someday.
1208 : */
1209 37890 : parse->hasSubLinks |= subquery->hasSubLinks;
1210 :
1211 : /* If subquery had any RLS conditions, now main query does too */
1212 37890 : parse->hasRowSecurity |= subquery->hasRowSecurity;
1213 :
1214 : /*
1215 : * subquery won't be pulled up if it hasAggs, hasWindowFuncs, or
1216 : * hasTargetSRFs, so no work needed on those flags
1217 : */
1218 :
1219 : /*
1220 : * Return the adjusted subquery jointree to replace the RangeTblRef entry
1221 : * in parent's jointree; or, if the FromExpr is degenerate, just return
1222 : * its single member.
1223 : */
1224 : Assert(IsA(subquery->jointree, FromExpr));
1225 : Assert(subquery->jointree->fromlist != NIL);
1226 70166 : if (subquery->jointree->quals == NULL &&
1227 32276 : list_length(subquery->jointree->fromlist) == 1)
1228 32156 : return (Node *) linitial(subquery->jointree->fromlist);
1229 :
1230 5734 : return (Node *) subquery->jointree;
1231 : }
1232 :
1233 : /*
1234 : * pull_up_simple_union_all
1235 : * Pull up a single simple UNION ALL subquery.
1236 : *
1237 : * jtnode is a RangeTblRef that has been identified as a simple UNION ALL
1238 : * subquery by pull_up_subqueries. We pull up the leaf subqueries and
1239 : * build an "append relation" for the union set. The result value is just
1240 : * jtnode, since we don't actually need to change the query jointree.
1241 : */
1242 : static Node *
1243 666 : pull_up_simple_union_all(PlannerInfo *root, Node *jtnode, RangeTblEntry *rte)
1244 : {
1245 666 : int varno = ((RangeTblRef *) jtnode)->rtindex;
1246 666 : Query *subquery = rte->subquery;
1247 666 : int rtoffset = list_length(root->parse->rtable);
1248 : List *rtable;
1249 :
1250 : /*
1251 : * Make a modifiable copy of the subquery's rtable, so we can adjust
1252 : * upper-level Vars in it. There are no such Vars in the setOperations
1253 : * tree proper, so fixing the rtable should be sufficient.
1254 : */
1255 666 : rtable = copyObject(subquery->rtable);
1256 :
1257 : /*
1258 : * Upper-level vars in subquery are now one level closer to their parent
1259 : * than before. We don't have to worry about offsetting varnos, though,
1260 : * because the UNION leaf queries can't cross-reference each other.
1261 : */
1262 666 : IncrementVarSublevelsUp_rtable(rtable, -1, 1);
1263 :
1264 : /*
1265 : * If the UNION ALL subquery had a LATERAL marker, propagate that to all
1266 : * its children. The individual children might or might not contain any
1267 : * actual lateral cross-references, but we have to mark the pulled-up
1268 : * child RTEs so that later planner stages will check for such.
1269 : */
1270 666 : if (rte->lateral)
1271 : {
1272 : ListCell *rt;
1273 :
1274 72 : foreach(rt, rtable)
1275 : {
1276 48 : RangeTblEntry *child_rte = (RangeTblEntry *) lfirst(rt);
1277 :
1278 : Assert(child_rte->rtekind == RTE_SUBQUERY);
1279 48 : child_rte->lateral = true;
1280 : }
1281 : }
1282 :
1283 : /*
1284 : * Append child RTEs to parent rtable.
1285 : */
1286 666 : root->parse->rtable = list_concat(root->parse->rtable, rtable);
1287 :
1288 : /*
1289 : * Recursively scan the subquery's setOperations tree and add
1290 : * AppendRelInfo nodes for leaf subqueries to the parent's
1291 : * append_rel_list. Also apply pull_up_subqueries to the leaf subqueries.
1292 : */
1293 : Assert(subquery->setOperations);
1294 666 : pull_up_union_leaf_queries(subquery->setOperations, root, varno, subquery,
1295 : rtoffset);
1296 :
1297 : /*
1298 : * Mark the parent as an append relation.
1299 : */
1300 666 : rte->inh = true;
1301 :
1302 666 : return jtnode;
1303 : }
1304 :
1305 : /*
1306 : * pull_up_union_leaf_queries -- recursive guts of pull_up_simple_union_all
1307 : *
1308 : * Build an AppendRelInfo for each leaf query in the setop tree, and then
1309 : * apply pull_up_subqueries to the leaf query.
1310 : *
1311 : * Note that setOpQuery is the Query containing the setOp node, whose tlist
1312 : * contains references to all the setop output columns. When called from
1313 : * pull_up_simple_union_all, this is *not* the same as root->parse, which is
1314 : * the parent Query we are pulling up into.
1315 : *
1316 : * parentRTindex is the appendrel parent's index in root->parse->rtable.
1317 : *
1318 : * The child RTEs have already been copied to the parent. childRToffset
1319 : * tells us where in the parent's range table they were copied. When called
1320 : * from flatten_simple_union_all, childRToffset is 0 since the child RTEs
1321 : * were already in root->parse->rtable and no RT index adjustment is needed.
1322 : */
1323 : static void
1324 5936 : pull_up_union_leaf_queries(Node *setOp, PlannerInfo *root, int parentRTindex,
1325 : Query *setOpQuery, int childRToffset)
1326 : {
1327 5936 : if (IsA(setOp, RangeTblRef))
1328 : {
1329 3888 : RangeTblRef *rtr = (RangeTblRef *) setOp;
1330 : int childRTindex;
1331 : AppendRelInfo *appinfo;
1332 :
1333 : /*
1334 : * Calculate the index in the parent's range table
1335 : */
1336 3888 : childRTindex = childRToffset + rtr->rtindex;
1337 :
1338 : /*
1339 : * Build a suitable AppendRelInfo, and attach to parent's list.
1340 : */
1341 3888 : appinfo = makeNode(AppendRelInfo);
1342 3888 : appinfo->parent_relid = parentRTindex;
1343 3888 : appinfo->child_relid = childRTindex;
1344 3888 : appinfo->parent_reltype = InvalidOid;
1345 3888 : appinfo->child_reltype = InvalidOid;
1346 3888 : make_setop_translation_list(setOpQuery, childRTindex,
1347 : &appinfo->translated_vars);
1348 3888 : appinfo->parent_reloid = InvalidOid;
1349 3888 : root->append_rel_list = lappend(root->append_rel_list, appinfo);
1350 :
1351 : /*
1352 : * Recursively apply pull_up_subqueries to the new child RTE. (We
1353 : * must build the AppendRelInfo first, because this will modify it.)
1354 : * Note that we can pass NULL for containing-join info even if we're
1355 : * actually under an outer join, because the child's expressions
1356 : * aren't going to propagate up to the join. Also, we ignore the
1357 : * possibility that pull_up_subqueries_recurse() returns a different
1358 : * jointree node than what we pass it; if it does, the important thing
1359 : * is that it replaced the child relid in the AppendRelInfo node.
1360 : */
1361 3888 : rtr = makeNode(RangeTblRef);
1362 3888 : rtr->rtindex = childRTindex;
1363 3888 : (void) pull_up_subqueries_recurse(root, (Node *) rtr,
1364 : NULL, NULL, appinfo);
1365 : }
1366 2048 : else if (IsA(setOp, SetOperationStmt))
1367 : {
1368 2048 : SetOperationStmt *op = (SetOperationStmt *) setOp;
1369 :
1370 : /* Recurse to reach leaf queries */
1371 2048 : pull_up_union_leaf_queries(op->larg, root, parentRTindex, setOpQuery,
1372 : childRToffset);
1373 2048 : pull_up_union_leaf_queries(op->rarg, root, parentRTindex, setOpQuery,
1374 : childRToffset);
1375 : }
1376 : else
1377 : {
1378 0 : elog(ERROR, "unrecognized node type: %d",
1379 : (int) nodeTag(setOp));
1380 : }
1381 5936 : }
1382 :
1383 : /*
1384 : * make_setop_translation_list
1385 : * Build the list of translations from parent Vars to child Vars for
1386 : * a UNION ALL member. (At this point it's just a simple list of
1387 : * referencing Vars, but if we succeed in pulling up the member
1388 : * subquery, the Vars will get replaced by pulled-up expressions.)
1389 : */
1390 : static void
1391 3888 : make_setop_translation_list(Query *query, Index newvarno,
1392 : List **translated_vars)
1393 : {
1394 3888 : List *vars = NIL;
1395 : ListCell *l;
1396 :
1397 9630 : foreach(l, query->targetList)
1398 : {
1399 5742 : TargetEntry *tle = (TargetEntry *) lfirst(l);
1400 :
1401 5742 : if (tle->resjunk)
1402 0 : continue;
1403 :
1404 5742 : vars = lappend(vars, makeVarFromTargetEntry(newvarno, tle));
1405 : }
1406 :
1407 3888 : *translated_vars = vars;
1408 3888 : }
1409 :
1410 : /*
1411 : * is_simple_subquery
1412 : * Check a subquery in the range table to see if it's simple enough
1413 : * to pull up into the parent query.
1414 : *
1415 : * rte is the RTE_SUBQUERY RangeTblEntry that contained the subquery.
1416 : * (Note subquery is not necessarily equal to rte->subquery; it could be a
1417 : * processed copy of that.)
1418 : * lowest_outer_join is the lowest outer join above the subquery, or NULL.
1419 : */
1420 : static bool
1421 81926 : is_simple_subquery(Query *subquery, RangeTblEntry *rte,
1422 : JoinExpr *lowest_outer_join)
1423 : {
1424 : /*
1425 : * Let's just make sure it's a valid subselect ...
1426 : */
1427 163852 : if (!IsA(subquery, Query) ||
1428 81926 : subquery->commandType != CMD_SELECT)
1429 0 : elog(ERROR, "subquery is bogus");
1430 :
1431 : /*
1432 : * Can't currently pull up a query with setops (unless it's simple UNION
1433 : * ALL, which is handled by a different code path). Maybe after querytree
1434 : * redesign...
1435 : */
1436 81926 : if (subquery->setOperations)
1437 1072 : return false;
1438 :
1439 : /*
1440 : * Can't pull up a subquery involving grouping, aggregation, SRFs,
1441 : * sorting, limiting, or WITH. (XXX WITH could possibly be allowed later)
1442 : *
1443 : * We also don't pull up a subquery that has explicit FOR UPDATE/SHARE
1444 : * clauses, because pullup would cause the locking to occur semantically
1445 : * higher than it should. Implicit FOR UPDATE/SHARE is okay because in
1446 : * that case the locking was originally declared in the upper query
1447 : * anyway.
1448 : */
1449 161234 : if (subquery->hasAggs ||
1450 160680 : subquery->hasWindowFuncs ||
1451 159648 : subquery->hasTargetSRFs ||
1452 158660 : subquery->groupClause ||
1453 158624 : subquery->groupingSets ||
1454 158624 : subquery->havingQual ||
1455 158160 : subquery->sortClause ||
1456 157592 : subquery->distinctClause ||
1457 157304 : subquery->limitOffset ||
1458 156968 : subquery->limitCount ||
1459 156804 : subquery->hasForUpdate ||
1460 78396 : subquery->cteList)
1461 2494 : return false;
1462 :
1463 : /*
1464 : * Don't pull up if the RTE represents a security-barrier view; we
1465 : * couldn't prevent information leakage once the RTE's Vars are scattered
1466 : * about in the upper query.
1467 : */
1468 78360 : if (rte->security_barrier)
1469 176 : return false;
1470 :
1471 : /*
1472 : * If the subquery is LATERAL, check for pullup restrictions from that.
1473 : */
1474 78184 : if (rte->lateral)
1475 : {
1476 : bool restricted;
1477 : Relids safe_upper_varnos;
1478 :
1479 : /*
1480 : * The subquery's WHERE and JOIN/ON quals mustn't contain any lateral
1481 : * references to rels outside a higher outer join (including the case
1482 : * where the outer join is within the subquery itself). In such a
1483 : * case, pulling up would result in a situation where we need to
1484 : * postpone quals from below an outer join to above it, which is
1485 : * probably completely wrong and in any case is a complication that
1486 : * doesn't seem worth addressing at the moment.
1487 : */
1488 596 : if (lowest_outer_join != NULL)
1489 : {
1490 224 : restricted = true;
1491 224 : safe_upper_varnos = get_relids_in_jointree((Node *) lowest_outer_join,
1492 : true);
1493 : }
1494 : else
1495 : {
1496 372 : restricted = false;
1497 372 : safe_upper_varnos = NULL; /* doesn't matter */
1498 : }
1499 :
1500 596 : if (jointree_contains_lateral_outer_refs((Node *) subquery->jointree,
1501 : restricted, safe_upper_varnos))
1502 8 : return false;
1503 :
1504 : /*
1505 : * If there's an outer join above the LATERAL subquery, also disallow
1506 : * pullup if the subquery's targetlist has any references to rels
1507 : * outside the outer join, since these might get pulled into quals
1508 : * above the subquery (but in or below the outer join) and then lead
1509 : * to qual-postponement issues similar to the case checked for above.
1510 : * (We wouldn't need to prevent pullup if no such references appear in
1511 : * outer-query quals, but we don't have enough info here to check
1512 : * that. Also, maybe this restriction could be removed if we forced
1513 : * such refs to be wrapped in PlaceHolderVars, even when they're below
1514 : * the nearest outer join? But it's a pretty hokey usage, so not
1515 : * clear this is worth sweating over.)
1516 : */
1517 588 : if (lowest_outer_join != NULL)
1518 : {
1519 224 : Relids lvarnos = pull_varnos_of_level((Node *) subquery->targetList, 1);
1520 :
1521 224 : if (!bms_is_subset(lvarnos, safe_upper_varnos))
1522 8 : return false;
1523 : }
1524 : }
1525 :
1526 : /*
1527 : * Don't pull up a subquery that has any volatile functions in its
1528 : * targetlist. Otherwise we might introduce multiple evaluations of these
1529 : * functions, if they get copied to multiple places in the upper query,
1530 : * leading to surprising results. (Note: the PlaceHolderVar mechanism
1531 : * doesn't quite guarantee single evaluation; else we could pull up anyway
1532 : * and just wrap such items in PlaceHolderVars ...)
1533 : */
1534 78168 : if (contain_volatile_functions((Node *) subquery->targetList))
1535 70 : return false;
1536 :
1537 78098 : return true;
1538 : }
1539 :
1540 : /*
1541 : * pull_up_simple_values
1542 : * Pull up a single simple VALUES RTE.
1543 : *
1544 : * jtnode is a RangeTblRef that has been identified as a simple VALUES RTE
1545 : * by pull_up_subqueries. We always return a RangeTblRef representing a
1546 : * RESULT RTE to replace it (all failure cases should have been detected by
1547 : * is_simple_values()). Actually, what we return is just jtnode, because
1548 : * we replace the VALUES RTE in the rangetable with the RESULT RTE.
1549 : *
1550 : * rte is the RangeTblEntry referenced by jtnode. Because of the limited
1551 : * possible usage of VALUES RTEs, we do not need the remaining parameters
1552 : * of pull_up_subqueries_recurse.
1553 : */
1554 : static Node *
1555 518 : pull_up_simple_values(PlannerInfo *root, Node *jtnode, RangeTblEntry *rte)
1556 : {
1557 518 : Query *parse = root->parse;
1558 518 : int varno = ((RangeTblRef *) jtnode)->rtindex;
1559 : List *values_list;
1560 : List *tlist;
1561 : AttrNumber attrno;
1562 : pullup_replace_vars_context rvcontext;
1563 : ListCell *lc;
1564 :
1565 : Assert(rte->rtekind == RTE_VALUES);
1566 : Assert(list_length(rte->values_lists) == 1);
1567 :
1568 : /*
1569 : * Need a modifiable copy of the VALUES list to hack on, just in case it's
1570 : * multiply referenced.
1571 : */
1572 518 : values_list = copyObject(linitial(rte->values_lists));
1573 :
1574 : /*
1575 : * The VALUES RTE can't contain any Vars of level zero, let alone any that
1576 : * are join aliases, so no need to flatten join alias Vars.
1577 : */
1578 : Assert(!contain_vars_of_level((Node *) values_list, 0));
1579 :
1580 : /*
1581 : * Set up required context data for pullup_replace_vars. In particular,
1582 : * we have to make the VALUES list look like a subquery targetlist.
1583 : */
1584 518 : tlist = NIL;
1585 518 : attrno = 1;
1586 1184 : foreach(lc, values_list)
1587 : {
1588 666 : tlist = lappend(tlist,
1589 666 : makeTargetEntry((Expr *) lfirst(lc),
1590 : attrno,
1591 : NULL,
1592 : false));
1593 666 : attrno++;
1594 : }
1595 518 : rvcontext.root = root;
1596 518 : rvcontext.targetlist = tlist;
1597 518 : rvcontext.target_rte = rte;
1598 518 : rvcontext.relids = NULL;
1599 518 : rvcontext.outer_hasSubLinks = &parse->hasSubLinks;
1600 518 : rvcontext.varno = varno;
1601 518 : rvcontext.need_phvs = false;
1602 518 : rvcontext.wrap_non_vars = false;
1603 : /* initialize cache array with indexes 0 .. length(tlist) */
1604 518 : rvcontext.rv_cache = palloc0((list_length(tlist) + 1) *
1605 : sizeof(Node *));
1606 :
1607 : /*
1608 : * Replace all of the top query's references to the RTE's outputs with
1609 : * copies of the adjusted VALUES expressions, being careful not to replace
1610 : * any of the jointree structure. (This'd be a lot cleaner if we could use
1611 : * query_tree_mutator.) Much of this should be no-ops in the dummy Query
1612 : * that surrounds a VALUES RTE, but it's not enough code to be worth
1613 : * removing.
1614 : */
1615 518 : parse->targetList = (List *)
1616 518 : pullup_replace_vars((Node *) parse->targetList, &rvcontext);
1617 518 : parse->returningList = (List *)
1618 518 : pullup_replace_vars((Node *) parse->returningList, &rvcontext);
1619 518 : if (parse->onConflict)
1620 : {
1621 0 : parse->onConflict->onConflictSet = (List *)
1622 0 : pullup_replace_vars((Node *) parse->onConflict->onConflictSet,
1623 : &rvcontext);
1624 0 : parse->onConflict->onConflictWhere =
1625 0 : pullup_replace_vars(parse->onConflict->onConflictWhere,
1626 : &rvcontext);
1627 :
1628 : /*
1629 : * We assume ON CONFLICT's arbiterElems, arbiterWhere, exclRelTlist
1630 : * can't contain any references to a subquery
1631 : */
1632 : }
1633 518 : replace_vars_in_jointree((Node *) parse->jointree, &rvcontext, NULL);
1634 : Assert(parse->setOperations == NULL);
1635 518 : parse->havingQual = pullup_replace_vars(parse->havingQual, &rvcontext);
1636 :
1637 : /*
1638 : * There should be no appendrels to fix, nor any join alias Vars, nor any
1639 : * outer joins and hence no PlaceHolderVars.
1640 : */
1641 : Assert(root->append_rel_list == NIL);
1642 : Assert(list_length(parse->rtable) == 1);
1643 : Assert(root->join_info_list == NIL);
1644 : Assert(root->placeholder_list == NIL);
1645 :
1646 : /*
1647 : * Replace the VALUES RTE with a RESULT RTE. The VALUES RTE is the only
1648 : * rtable entry in the current query level, so this is easy.
1649 : */
1650 : Assert(list_length(parse->rtable) == 1);
1651 :
1652 : /* Create suitable RTE */
1653 518 : rte = makeNode(RangeTblEntry);
1654 518 : rte->rtekind = RTE_RESULT;
1655 518 : rte->eref = makeAlias("*RESULT*", NIL);
1656 :
1657 : /* Replace rangetable */
1658 518 : parse->rtable = list_make1(rte);
1659 :
1660 : /* We could manufacture a new RangeTblRef, but the one we have is fine */
1661 : Assert(varno == 1);
1662 :
1663 518 : return jtnode;
1664 : }
1665 :
1666 : /*
1667 : * is_simple_values
1668 : * Check a VALUES RTE in the range table to see if it's simple enough
1669 : * to pull up into the parent query.
1670 : *
1671 : * rte is the RTE_VALUES RangeTblEntry to check.
1672 : */
1673 : static bool
1674 4284 : is_simple_values(PlannerInfo *root, RangeTblEntry *rte)
1675 : {
1676 : Assert(rte->rtekind == RTE_VALUES);
1677 :
1678 : /*
1679 : * There must be exactly one VALUES list, else it's not semantically
1680 : * correct to replace the VALUES RTE with a RESULT RTE, nor would we have
1681 : * a unique set of expressions to substitute into the parent query.
1682 : */
1683 4284 : if (list_length(rte->values_lists) != 1)
1684 3766 : return false;
1685 :
1686 : /*
1687 : * Because VALUES can't appear under an outer join (or at least, we won't
1688 : * try to pull it up if it does), we need not worry about LATERAL, nor
1689 : * about validity of PHVs for the VALUES' outputs.
1690 : */
1691 :
1692 : /*
1693 : * Don't pull up a VALUES that contains any set-returning or volatile
1694 : * functions. The considerations here are basically identical to the
1695 : * restrictions on a pull-able subquery's targetlist.
1696 : */
1697 1036 : if (expression_returns_set((Node *) rte->values_lists) ||
1698 518 : contain_volatile_functions((Node *) rte->values_lists))
1699 0 : return false;
1700 :
1701 : /*
1702 : * Do not pull up a VALUES that's not the only RTE in its parent query.
1703 : * This is actually the only case that the parser will generate at the
1704 : * moment, and assuming this is true greatly simplifies
1705 : * pull_up_simple_values().
1706 : */
1707 1036 : if (list_length(root->parse->rtable) != 1 ||
1708 518 : rte != (RangeTblEntry *) linitial(root->parse->rtable))
1709 0 : return false;
1710 :
1711 518 : return true;
1712 : }
1713 :
1714 : /*
1715 : * is_simple_union_all
1716 : * Check a subquery to see if it's a simple UNION ALL.
1717 : *
1718 : * We require all the setops to be UNION ALL (no mixing) and there can't be
1719 : * any datatype coercions involved, ie, all the leaf queries must emit the
1720 : * same datatypes.
1721 : */
1722 : static bool
1723 6066 : is_simple_union_all(Query *subquery)
1724 : {
1725 : SetOperationStmt *topop;
1726 :
1727 : /* Let's just make sure it's a valid subselect ... */
1728 12132 : if (!IsA(subquery, Query) ||
1729 6066 : subquery->commandType != CMD_SELECT)
1730 0 : elog(ERROR, "subquery is bogus");
1731 :
1732 : /* Is it a set-operation query at all? */
1733 6066 : topop = castNode(SetOperationStmt, subquery->setOperations);
1734 6066 : if (!topop)
1735 4994 : return false;
1736 :
1737 : /* Can't handle ORDER BY, LIMIT/OFFSET, locking, or WITH */
1738 2128 : if (subquery->sortClause ||
1739 2112 : subquery->limitOffset ||
1740 2112 : subquery->limitCount ||
1741 2112 : subquery->rowMarks ||
1742 1056 : subquery->cteList)
1743 20 : return false;
1744 :
1745 : /* Recursively check the tree of set operations */
1746 1052 : return is_simple_union_all_recurse((Node *) topop, subquery,
1747 : topop->colTypes);
1748 : }
1749 :
1750 : static bool
1751 7150 : is_simple_union_all_recurse(Node *setOp, Query *setOpQuery, List *colTypes)
1752 : {
1753 7150 : if (IsA(setOp, RangeTblRef))
1754 : {
1755 3932 : RangeTblRef *rtr = (RangeTblRef *) setOp;
1756 3932 : RangeTblEntry *rte = rt_fetch(rtr->rtindex, setOpQuery->rtable);
1757 3932 : Query *subquery = rte->subquery;
1758 :
1759 : Assert(subquery != NULL);
1760 :
1761 : /* Leaf nodes are OK if they match the toplevel column types */
1762 : /* We don't have to compare typmods or collations here */
1763 3932 : return tlist_same_datatypes(subquery->targetList, colTypes, true);
1764 : }
1765 3218 : else if (IsA(setOp, SetOperationStmt))
1766 : {
1767 3218 : SetOperationStmt *op = (SetOperationStmt *) setOp;
1768 :
1769 : /* Must be UNION ALL */
1770 3218 : if (op->op != SETOP_UNION || !op->all)
1771 1126 : return false;
1772 :
1773 : /* Recurse to check inputs */
1774 4156 : return is_simple_union_all_recurse(op->larg, setOpQuery, colTypes) &&
1775 2064 : is_simple_union_all_recurse(op->rarg, setOpQuery, colTypes);
1776 : }
1777 : else
1778 : {
1779 0 : elog(ERROR, "unrecognized node type: %d",
1780 : (int) nodeTag(setOp));
1781 : return false; /* keep compiler quiet */
1782 : }
1783 : }
1784 :
1785 : /*
1786 : * is_safe_append_member
1787 : * Check a subquery that is a leaf of a UNION ALL appendrel to see if it's
1788 : * safe to pull up.
1789 : */
1790 : static bool
1791 5002 : is_safe_append_member(Query *subquery)
1792 : {
1793 : FromExpr *jtnode;
1794 :
1795 : /*
1796 : * It's only safe to pull up the child if its jointree contains exactly
1797 : * one RTE, else the AppendRelInfo data structure breaks. The one base RTE
1798 : * could be buried in several levels of FromExpr, however. Also, if the
1799 : * child's jointree is completely empty, we can pull up because
1800 : * pull_up_simple_subquery will insert a single RTE_RESULT RTE instead.
1801 : *
1802 : * Also, the child can't have any WHERE quals because there's no place to
1803 : * put them in an appendrel. (This is a bit annoying...) If we didn't
1804 : * need to check this, we'd just test whether get_relids_in_jointree()
1805 : * yields a singleton set, to be more consistent with the coding of
1806 : * fix_append_rel_relids().
1807 : */
1808 5002 : jtnode = subquery->jointree;
1809 : Assert(IsA(jtnode, FromExpr));
1810 : /* Check the completely-empty case */
1811 5002 : if (jtnode->fromlist == NIL && jtnode->quals == NULL)
1812 284 : return true;
1813 : /* Check the more general case */
1814 11924 : while (IsA(jtnode, FromExpr))
1815 : {
1816 4726 : if (jtnode->quals != NULL)
1817 2238 : return false;
1818 2488 : if (list_length(jtnode->fromlist) != 1)
1819 0 : return false;
1820 2488 : jtnode = linitial(jtnode->fromlist);
1821 : }
1822 2480 : if (!IsA(jtnode, RangeTblRef))
1823 36 : return false;
1824 :
1825 2444 : return true;
1826 : }
1827 :
1828 : /*
1829 : * jointree_contains_lateral_outer_refs
1830 : * Check for disallowed lateral references in a jointree's quals
1831 : *
1832 : * If restricted is false, all level-1 Vars are allowed (but we still must
1833 : * search the jointree, since it might contain outer joins below which there
1834 : * will be restrictions). If restricted is true, return true when any qual
1835 : * in the jointree contains level-1 Vars coming from outside the rels listed
1836 : * in safe_upper_varnos.
1837 : */
1838 : static bool
1839 1436 : jointree_contains_lateral_outer_refs(Node *jtnode, bool restricted,
1840 : Relids safe_upper_varnos)
1841 : {
1842 1436 : if (jtnode == NULL)
1843 0 : return false;
1844 1436 : if (IsA(jtnode, RangeTblRef))
1845 700 : return false;
1846 736 : else if (IsA(jtnode, FromExpr))
1847 : {
1848 604 : FromExpr *f = (FromExpr *) jtnode;
1849 : ListCell *l;
1850 :
1851 : /* First, recurse to check child joins */
1852 1172 : foreach(l, f->fromlist)
1853 : {
1854 576 : if (jointree_contains_lateral_outer_refs(lfirst(l),
1855 : restricted,
1856 : safe_upper_varnos))
1857 8 : return true;
1858 : }
1859 :
1860 : /* Then check the top-level quals */
1861 828 : if (restricted &&
1862 232 : !bms_is_subset(pull_varnos_of_level(f->quals, 1),
1863 : safe_upper_varnos))
1864 0 : return true;
1865 : }
1866 132 : else if (IsA(jtnode, JoinExpr))
1867 : {
1868 132 : JoinExpr *j = (JoinExpr *) jtnode;
1869 :
1870 : /*
1871 : * If this is an outer join, we mustn't allow any upper lateral
1872 : * references in or below it.
1873 : */
1874 132 : if (j->jointype != JOIN_INNER)
1875 : {
1876 52 : restricted = true;
1877 52 : safe_upper_varnos = NULL;
1878 : }
1879 :
1880 : /* Check the child joins */
1881 132 : if (jointree_contains_lateral_outer_refs(j->larg,
1882 : restricted,
1883 : safe_upper_varnos))
1884 0 : return true;
1885 132 : if (jointree_contains_lateral_outer_refs(j->rarg,
1886 : restricted,
1887 : safe_upper_varnos))
1888 0 : return true;
1889 :
1890 : /* Check the JOIN's qual clauses */
1891 264 : if (restricted &&
1892 132 : !bms_is_subset(pull_varnos_of_level(j->quals, 1),
1893 : safe_upper_varnos))
1894 8 : return true;
1895 : }
1896 : else
1897 0 : elog(ERROR, "unrecognized node type: %d",
1898 : (int) nodeTag(jtnode));
1899 720 : return false;
1900 : }
1901 :
1902 : /*
1903 : * Helper routine for pull_up_subqueries: do pullup_replace_vars on every
1904 : * expression in the jointree, without changing the jointree structure itself.
1905 : * Ugly, but there's no other way...
1906 : *
1907 : * If we are at or below lowest_nulling_outer_join, we can suppress use of
1908 : * PlaceHolderVars wrapped around the replacement expressions.
1909 : */
1910 : static void
1911 87166 : replace_vars_in_jointree(Node *jtnode,
1912 : pullup_replace_vars_context *context,
1913 : JoinExpr *lowest_nulling_outer_join)
1914 : {
1915 87166 : if (jtnode == NULL)
1916 0 : return;
1917 87166 : if (IsA(jtnode, RangeTblRef))
1918 : {
1919 : /*
1920 : * If the RangeTblRef refers to a LATERAL subquery (that isn't the
1921 : * same subquery we're pulling up), it might contain references to the
1922 : * target subquery, which we must replace. We drive this from the
1923 : * jointree scan, rather than a scan of the rtable, for a couple of
1924 : * reasons: we can avoid processing no-longer-referenced RTEs, and we
1925 : * can use the appropriate setting of need_phvs depending on whether
1926 : * the RTE is above possibly-nulling outer joins or not.
1927 : */
1928 43824 : int varno = ((RangeTblRef *) jtnode)->rtindex;
1929 :
1930 43824 : if (varno != context->varno) /* ignore target subquery itself */
1931 : {
1932 6758 : RangeTblEntry *rte = rt_fetch(varno, context->root->parse->rtable);
1933 :
1934 : Assert(rte != context->target_rte);
1935 6758 : if (rte->lateral)
1936 : {
1937 412 : switch (rte->rtekind)
1938 : {
1939 : case RTE_RELATION:
1940 : /* shouldn't be marked LATERAL unless tablesample */
1941 : Assert(rte->tablesample);
1942 0 : rte->tablesample = (TableSampleClause *)
1943 0 : pullup_replace_vars((Node *) rte->tablesample,
1944 : context);
1945 0 : break;
1946 : case RTE_SUBQUERY:
1947 208 : rte->subquery =
1948 208 : pullup_replace_vars_subquery(rte->subquery,
1949 : context);
1950 208 : break;
1951 : case RTE_FUNCTION:
1952 160 : rte->functions = (List *)
1953 160 : pullup_replace_vars((Node *) rte->functions,
1954 : context);
1955 160 : break;
1956 : case RTE_TABLEFUNC:
1957 44 : rte->tablefunc = (TableFunc *)
1958 44 : pullup_replace_vars((Node *) rte->tablefunc,
1959 : context);
1960 44 : break;
1961 : case RTE_VALUES:
1962 0 : rte->values_lists = (List *)
1963 0 : pullup_replace_vars((Node *) rte->values_lists,
1964 : context);
1965 0 : break;
1966 : case RTE_JOIN:
1967 : case RTE_CTE:
1968 : case RTE_NAMEDTUPLESTORE:
1969 : case RTE_RESULT:
1970 : /* these shouldn't be marked LATERAL */
1971 : Assert(false);
1972 0 : break;
1973 : }
1974 : }
1975 : }
1976 : }
1977 43342 : else if (IsA(jtnode, FromExpr))
1978 : {
1979 39566 : FromExpr *f = (FromExpr *) jtnode;
1980 : ListCell *l;
1981 :
1982 80768 : foreach(l, f->fromlist)
1983 41202 : replace_vars_in_jointree(lfirst(l), context,
1984 : lowest_nulling_outer_join);
1985 39566 : f->quals = pullup_replace_vars(f->quals, context);
1986 : }
1987 3776 : else if (IsA(jtnode, JoinExpr))
1988 : {
1989 3776 : JoinExpr *j = (JoinExpr *) jtnode;
1990 3776 : bool save_need_phvs = context->need_phvs;
1991 :
1992 3776 : if (j == lowest_nulling_outer_join)
1993 : {
1994 : /* no more PHVs in or below this join */
1995 1190 : context->need_phvs = false;
1996 1190 : lowest_nulling_outer_join = NULL;
1997 : }
1998 3776 : replace_vars_in_jointree(j->larg, context, lowest_nulling_outer_join);
1999 3776 : replace_vars_in_jointree(j->rarg, context, lowest_nulling_outer_join);
2000 :
2001 : /*
2002 : * Use PHVs within the join quals of a full join, even when it's the
2003 : * lowest nulling outer join. Otherwise, we cannot identify which
2004 : * side of the join a pulled-up var-free expression came from, which
2005 : * can lead to failure to make a plan at all because none of the quals
2006 : * appear to be mergeable or hashable conditions. For this purpose we
2007 : * don't care about the state of wrap_non_vars, so leave it alone.
2008 : */
2009 3776 : if (j->jointype == JOIN_FULL)
2010 348 : context->need_phvs = true;
2011 :
2012 3776 : j->quals = pullup_replace_vars(j->quals, context);
2013 :
2014 : /*
2015 : * We don't bother to update the colvars list, since it won't be used
2016 : * again ...
2017 : */
2018 3776 : context->need_phvs = save_need_phvs;
2019 : }
2020 : else
2021 0 : elog(ERROR, "unrecognized node type: %d",
2022 : (int) nodeTag(jtnode));
2023 : }
2024 :
2025 : /*
2026 : * Apply pullup variable replacement throughout an expression tree
2027 : *
2028 : * Returns a modified copy of the tree, so this can't be used where we
2029 : * need to do in-place replacement.
2030 : */
2031 : static Node *
2032 163764 : pullup_replace_vars(Node *expr, pullup_replace_vars_context *context)
2033 : {
2034 163764 : return replace_rte_variables(expr,
2035 : context->varno, 0,
2036 : pullup_replace_vars_callback,
2037 : (void *) context,
2038 : context->outer_hasSubLinks);
2039 : }
2040 :
2041 : static Node *
2042 125122 : pullup_replace_vars_callback(Var *var,
2043 : replace_rte_variables_context *context)
2044 : {
2045 125122 : pullup_replace_vars_context *rcon = (pullup_replace_vars_context *) context->callback_arg;
2046 125122 : int varattno = var->varattno;
2047 : Node *newnode;
2048 :
2049 : /*
2050 : * If PlaceHolderVars are needed, we cache the modified expressions in
2051 : * rcon->rv_cache[]. This is not in hopes of any material speed gain
2052 : * within this function, but to avoid generating identical PHVs with
2053 : * different IDs. That would result in duplicate evaluations at runtime,
2054 : * and possibly prevent optimizations that rely on recognizing different
2055 : * references to the same subquery output as being equal(). So it's worth
2056 : * a bit of extra effort to avoid it.
2057 : */
2058 125122 : if (rcon->need_phvs &&
2059 5206 : varattno >= InvalidAttrNumber &&
2060 10412 : varattno <= list_length(rcon->targetlist) &&
2061 5206 : rcon->rv_cache[varattno] != NULL)
2062 : {
2063 : /* Just copy the entry and fall through to adjust its varlevelsup */
2064 1798 : newnode = copyObject(rcon->rv_cache[varattno]);
2065 : }
2066 123324 : else if (varattno == InvalidAttrNumber)
2067 : {
2068 : /* Must expand whole-tuple reference into RowExpr */
2069 : RowExpr *rowexpr;
2070 : List *colnames;
2071 : List *fields;
2072 264 : bool save_need_phvs = rcon->need_phvs;
2073 264 : int save_sublevelsup = context->sublevels_up;
2074 :
2075 : /*
2076 : * If generating an expansion for a var of a named rowtype (ie, this
2077 : * is a plain relation RTE), then we must include dummy items for
2078 : * dropped columns. If the var is RECORD (ie, this is a JOIN), then
2079 : * omit dropped columns. Either way, attach column names to the
2080 : * RowExpr for use of ruleutils.c.
2081 : *
2082 : * In order to be able to cache the results, we always generate the
2083 : * expansion with varlevelsup = 0, and then adjust if needed.
2084 : */
2085 528 : expandRTE(rcon->target_rte,
2086 264 : var->varno, 0 /* not varlevelsup */ , var->location,
2087 264 : (var->vartype != RECORDOID),
2088 : &colnames, &fields);
2089 : /* Adjust the generated per-field Vars, but don't insert PHVs */
2090 264 : rcon->need_phvs = false;
2091 264 : context->sublevels_up = 0; /* to match the expandRTE output */
2092 264 : fields = (List *) replace_rte_variables_mutator((Node *) fields,
2093 : context);
2094 264 : rcon->need_phvs = save_need_phvs;
2095 264 : context->sublevels_up = save_sublevelsup;
2096 :
2097 264 : rowexpr = makeNode(RowExpr);
2098 264 : rowexpr->args = fields;
2099 264 : rowexpr->row_typeid = var->vartype;
2100 264 : rowexpr->row_format = COERCE_IMPLICIT_CAST;
2101 264 : rowexpr->colnames = colnames;
2102 264 : rowexpr->location = var->location;
2103 264 : newnode = (Node *) rowexpr;
2104 :
2105 : /*
2106 : * Insert PlaceHolderVar if needed. Notice that we are wrapping one
2107 : * PlaceHolderVar around the whole RowExpr, rather than putting one
2108 : * around each element of the row. This is because we need the
2109 : * expression to yield NULL, not ROW(NULL,NULL,...) when it is forced
2110 : * to null by an outer join.
2111 : */
2112 264 : if (rcon->need_phvs)
2113 : {
2114 : /* RowExpr is certainly not strict, so always need PHV */
2115 8 : newnode = (Node *)
2116 8 : make_placeholder_expr(rcon->root,
2117 : (Expr *) newnode,
2118 : bms_make_singleton(rcon->varno));
2119 : /* cache it with the PHV, and with varlevelsup still zero */
2120 8 : rcon->rv_cache[InvalidAttrNumber] = copyObject(newnode);
2121 : }
2122 : }
2123 : else
2124 : {
2125 : /* Normal case referencing one targetlist element */
2126 123060 : TargetEntry *tle = get_tle_by_resno(rcon->targetlist, varattno);
2127 :
2128 123060 : if (tle == NULL) /* shouldn't happen */
2129 0 : elog(ERROR, "could not find attribute %d in subquery targetlist",
2130 : varattno);
2131 :
2132 : /* Make a copy of the tlist item to return */
2133 123060 : newnode = (Node *) copyObject(tle->expr);
2134 :
2135 : /* Insert PlaceHolderVar if needed */
2136 123060 : if (rcon->need_phvs)
2137 : {
2138 : bool wrap;
2139 :
2140 6136 : if (newnode && IsA(newnode, Var) &&
2141 2736 : ((Var *) newnode)->varlevelsup == 0)
2142 : {
2143 : /*
2144 : * Simple Vars always escape being wrapped, unless they are
2145 : * lateral references to something outside the subquery being
2146 : * pulled up. (Even then, we could omit the PlaceHolderVar if
2147 : * the referenced rel is under the same lowest outer join, but
2148 : * it doesn't seem worth the trouble to check that.)
2149 : */
2150 5696 : if (rcon->target_rte->lateral &&
2151 232 : !bms_is_member(((Var *) newnode)->varno, rcon->relids))
2152 16 : wrap = true;
2153 : else
2154 2716 : wrap = false;
2155 : }
2156 696 : else if (newnode && IsA(newnode, PlaceHolderVar) &&
2157 28 : ((PlaceHolderVar *) newnode)->phlevelsup == 0)
2158 : {
2159 : /* No need to wrap a PlaceHolderVar with another one, either */
2160 28 : wrap = false;
2161 : }
2162 640 : else if (rcon->wrap_non_vars)
2163 : {
2164 : /* Wrap all non-Vars in a PlaceHolderVar */
2165 64 : wrap = true;
2166 : }
2167 : else
2168 : {
2169 : /*
2170 : * If it contains a Var of the subquery being pulled up, and
2171 : * does not contain any non-strict constructs, then it's
2172 : * certainly nullable so we don't need to insert a
2173 : * PlaceHolderVar.
2174 : *
2175 : * This analysis could be tighter: in particular, a non-strict
2176 : * construct hidden within a lower-level PlaceHolderVar is not
2177 : * reason to add another PHV. But for now it doesn't seem
2178 : * worth the code to be more exact.
2179 : *
2180 : * Note: in future maybe we should insert a PlaceHolderVar
2181 : * anyway, if the tlist item is expensive to evaluate?
2182 : *
2183 : * For a LATERAL subquery, we have to check the actual var
2184 : * membership of the node, but if it's non-lateral then any
2185 : * level-zero var must belong to the subquery.
2186 : */
2187 640 : if ((rcon->target_rte->lateral ?
2188 64 : bms_overlap(pull_varnos((Node *) newnode), rcon->relids) :
2189 684 : contain_vars_of_level((Node *) newnode, 0)) &&
2190 172 : !contain_nonstrict_functions((Node *) newnode))
2191 : {
2192 : /* No wrap needed */
2193 0 : wrap = false;
2194 : }
2195 : else
2196 : {
2197 : /* Else wrap it in a PlaceHolderVar */
2198 576 : wrap = true;
2199 : }
2200 : }
2201 :
2202 3400 : if (wrap)
2203 656 : newnode = (Node *)
2204 656 : make_placeholder_expr(rcon->root,
2205 : (Expr *) newnode,
2206 : bms_make_singleton(rcon->varno));
2207 :
2208 : /*
2209 : * Cache it if possible (ie, if the attno is in range, which it
2210 : * probably always should be). We can cache the value even if we
2211 : * decided we didn't need a PHV, since this result will be
2212 : * suitable for any request that has need_phvs.
2213 : */
2214 6800 : if (varattno > InvalidAttrNumber &&
2215 3400 : varattno <= list_length(rcon->targetlist))
2216 3400 : rcon->rv_cache[varattno] = copyObject(newnode);
2217 : }
2218 : }
2219 :
2220 : /* Must adjust varlevelsup if tlist item is from higher query */
2221 125122 : if (var->varlevelsup > 0)
2222 384 : IncrementVarSublevelsUp(newnode, var->varlevelsup, 0);
2223 :
2224 125122 : return newnode;
2225 : }
2226 :
2227 : /*
2228 : * Apply pullup variable replacement to a subquery
2229 : *
2230 : * This needs to be different from pullup_replace_vars() because
2231 : * replace_rte_variables will think that it shouldn't increment sublevels_up
2232 : * before entering the Query; so we need to call it with sublevels_up == 1.
2233 : */
2234 : static Query *
2235 208 : pullup_replace_vars_subquery(Query *query,
2236 : pullup_replace_vars_context *context)
2237 : {
2238 : Assert(IsA(query, Query));
2239 208 : return (Query *) replace_rte_variables((Node *) query,
2240 : context->varno, 1,
2241 : pullup_replace_vars_callback,
2242 : (void *) context,
2243 : NULL);
2244 : }
2245 :
2246 :
2247 : /*
2248 : * flatten_simple_union_all
2249 : * Try to optimize top-level UNION ALL structure into an appendrel
2250 : *
2251 : * If a query's setOperations tree consists entirely of simple UNION ALL
2252 : * operations, flatten it into an append relation, which we can process more
2253 : * intelligently than the general setops case. Otherwise, do nothing.
2254 : *
2255 : * In most cases, this can succeed only for a top-level query, because for a
2256 : * subquery in FROM, the parent query's invocation of pull_up_subqueries would
2257 : * already have flattened the UNION via pull_up_simple_union_all. But there
2258 : * are a few cases we can support here but not in that code path, for example
2259 : * when the subquery also contains ORDER BY.
2260 : */
2261 : void
2262 2268 : flatten_simple_union_all(PlannerInfo *root)
2263 : {
2264 2268 : Query *parse = root->parse;
2265 : SetOperationStmt *topop;
2266 : Node *leftmostjtnode;
2267 : int leftmostRTI;
2268 : RangeTblEntry *leftmostRTE;
2269 : int childRTI;
2270 : RangeTblEntry *childRTE;
2271 : RangeTblRef *rtr;
2272 :
2273 : /* Shouldn't be called unless query has setops */
2274 2268 : topop = castNode(SetOperationStmt, parse->setOperations);
2275 : Assert(topop);
2276 :
2277 : /* Can't optimize away a recursive UNION */
2278 2268 : if (root->hasRecursion)
2279 326 : return;
2280 :
2281 : /*
2282 : * Recursively check the tree of set operations. If not all UNION ALL
2283 : * with identical column types, punt.
2284 : */
2285 1942 : if (!is_simple_union_all_recurse((Node *) topop, parse, topop->colTypes))
2286 768 : return;
2287 :
2288 : /*
2289 : * Locate the leftmost leaf query in the setops tree. The upper query's
2290 : * Vars all refer to this RTE (see transformSetOperationStmt).
2291 : */
2292 1174 : leftmostjtnode = topop->larg;
2293 2398 : while (leftmostjtnode && IsA(leftmostjtnode, SetOperationStmt))
2294 50 : leftmostjtnode = ((SetOperationStmt *) leftmostjtnode)->larg;
2295 : Assert(leftmostjtnode && IsA(leftmostjtnode, RangeTblRef));
2296 1174 : leftmostRTI = ((RangeTblRef *) leftmostjtnode)->rtindex;
2297 1174 : leftmostRTE = rt_fetch(leftmostRTI, parse->rtable);
2298 : Assert(leftmostRTE->rtekind == RTE_SUBQUERY);
2299 :
2300 : /*
2301 : * Make a copy of the leftmost RTE and add it to the rtable. This copy
2302 : * will represent the leftmost leaf query in its capacity as a member of
2303 : * the appendrel. The original will represent the appendrel as a whole.
2304 : * (We must do things this way because the upper query's Vars have to be
2305 : * seen as referring to the whole appendrel.)
2306 : */
2307 1174 : childRTE = copyObject(leftmostRTE);
2308 1174 : parse->rtable = lappend(parse->rtable, childRTE);
2309 1174 : childRTI = list_length(parse->rtable);
2310 :
2311 : /* Modify the setops tree to reference the child copy */
2312 1174 : ((RangeTblRef *) leftmostjtnode)->rtindex = childRTI;
2313 :
2314 : /* Modify the formerly-leftmost RTE to mark it as an appendrel parent */
2315 1174 : leftmostRTE->inh = true;
2316 :
2317 : /*
2318 : * Form a RangeTblRef for the appendrel, and insert it into FROM. The top
2319 : * Query of a setops tree should have had an empty FromClause initially.
2320 : */
2321 1174 : rtr = makeNode(RangeTblRef);
2322 1174 : rtr->rtindex = leftmostRTI;
2323 : Assert(parse->jointree->fromlist == NIL);
2324 1174 : parse->jointree->fromlist = list_make1(rtr);
2325 :
2326 : /*
2327 : * Now pretend the query has no setops. We must do this before trying to
2328 : * do subquery pullup, because of Assert in pull_up_simple_subquery.
2329 : */
2330 1174 : parse->setOperations = NULL;
2331 :
2332 : /*
2333 : * Build AppendRelInfo information, and apply pull_up_subqueries to the
2334 : * leaf queries of the UNION ALL. (We must do that now because they
2335 : * weren't previously referenced by the jointree, and so were missed by
2336 : * the main invocation of pull_up_subqueries.)
2337 : */
2338 1174 : pull_up_union_leaf_queries((Node *) topop, root, leftmostRTI, parse, 0);
2339 : }
2340 :
2341 :
2342 : /*
2343 : * reduce_outer_joins
2344 : * Attempt to reduce outer joins to plain inner joins.
2345 : *
2346 : * The idea here is that given a query like
2347 : * SELECT ... FROM a LEFT JOIN b ON (...) WHERE b.y = 42;
2348 : * we can reduce the LEFT JOIN to a plain JOIN if the "=" operator in WHERE
2349 : * is strict. The strict operator will always return NULL, causing the outer
2350 : * WHERE to fail, on any row where the LEFT JOIN filled in NULLs for b's
2351 : * columns. Therefore, there's no need for the join to produce null-extended
2352 : * rows in the first place --- which makes it a plain join not an outer join.
2353 : * (This scenario may not be very likely in a query written out by hand, but
2354 : * it's reasonably likely when pushing quals down into complex views.)
2355 : *
2356 : * More generally, an outer join can be reduced in strength if there is a
2357 : * strict qual above it in the qual tree that constrains a Var from the
2358 : * nullable side of the join to be non-null. (For FULL joins this applies
2359 : * to each side separately.)
2360 : *
2361 : * Another transformation we apply here is to recognize cases like
2362 : * SELECT ... FROM a LEFT JOIN b ON (a.x = b.y) WHERE b.y IS NULL;
2363 : * If the join clause is strict for b.y, then only null-extended rows could
2364 : * pass the upper WHERE, and we can conclude that what the query is really
2365 : * specifying is an anti-semijoin. We change the join type from JOIN_LEFT
2366 : * to JOIN_ANTI. The IS NULL clause then becomes redundant, and must be
2367 : * removed to prevent bogus selectivity calculations, but we leave it to
2368 : * distribute_qual_to_rels to get rid of such clauses.
2369 : *
2370 : * Also, we get rid of JOIN_RIGHT cases by flipping them around to become
2371 : * JOIN_LEFT. This saves some code here and in some later planner routines,
2372 : * but the main reason to do it is to not need to invent a JOIN_REVERSE_ANTI
2373 : * join type.
2374 : *
2375 : * To ease recognition of strict qual clauses, we require this routine to be
2376 : * run after expression preprocessing (i.e., qual canonicalization and JOIN
2377 : * alias-var expansion).
2378 : */
2379 : void
2380 29932 : reduce_outer_joins(PlannerInfo *root)
2381 : {
2382 : reduce_outer_joins_state *state;
2383 :
2384 : /*
2385 : * To avoid doing strictness checks on more quals than necessary, we want
2386 : * to stop descending the jointree as soon as there are no outer joins
2387 : * below our current point. This consideration forces a two-pass process.
2388 : * The first pass gathers information about which base rels appear below
2389 : * each side of each join clause, and about whether there are outer
2390 : * join(s) below each side of each join clause. The second pass examines
2391 : * qual clauses and changes join types as it descends the tree.
2392 : */
2393 29932 : state = reduce_outer_joins_pass1((Node *) root->parse->jointree);
2394 :
2395 : /* planner.c shouldn't have called me if no outer joins */
2396 29932 : if (state == NULL || !state->contains_outer)
2397 0 : elog(ERROR, "so where are the outer joins?");
2398 :
2399 29932 : reduce_outer_joins_pass2((Node *) root->parse->jointree,
2400 : state, root, NULL, NIL, NIL);
2401 29932 : }
2402 :
2403 : /*
2404 : * reduce_outer_joins_pass1 - phase 1 data collection
2405 : *
2406 : * Returns a state node describing the given jointree node.
2407 : */
2408 : static reduce_outer_joins_state *
2409 143900 : reduce_outer_joins_pass1(Node *jtnode)
2410 : {
2411 : reduce_outer_joins_state *result;
2412 :
2413 143900 : result = (reduce_outer_joins_state *)
2414 : palloc(sizeof(reduce_outer_joins_state));
2415 143900 : result->relids = NULL;
2416 143900 : result->contains_outer = false;
2417 143900 : result->sub_states = NIL;
2418 :
2419 143900 : if (jtnode == NULL)
2420 0 : return result;
2421 143900 : if (IsA(jtnode, RangeTblRef))
2422 : {
2423 71904 : int varno = ((RangeTblRef *) jtnode)->rtindex;
2424 :
2425 71904 : result->relids = bms_make_singleton(varno);
2426 : }
2427 71996 : else if (IsA(jtnode, FromExpr))
2428 : {
2429 30958 : FromExpr *f = (FromExpr *) jtnode;
2430 : ListCell *l;
2431 :
2432 62850 : foreach(l, f->fromlist)
2433 : {
2434 : reduce_outer_joins_state *sub_state;
2435 :
2436 31892 : sub_state = reduce_outer_joins_pass1(lfirst(l));
2437 31892 : result->relids = bms_add_members(result->relids,
2438 31892 : sub_state->relids);
2439 31892 : result->contains_outer |= sub_state->contains_outer;
2440 31892 : result->sub_states = lappend(result->sub_states, sub_state);
2441 : }
2442 : }
2443 41038 : else if (IsA(jtnode, JoinExpr))
2444 : {
2445 41038 : JoinExpr *j = (JoinExpr *) jtnode;
2446 : reduce_outer_joins_state *sub_state;
2447 :
2448 : /* join's own RT index is not wanted in result->relids */
2449 41038 : if (IS_OUTER_JOIN(j->jointype))
2450 35184 : result->contains_outer = true;
2451 :
2452 41038 : sub_state = reduce_outer_joins_pass1(j->larg);
2453 41038 : result->relids = bms_add_members(result->relids,
2454 41038 : sub_state->relids);
2455 41038 : result->contains_outer |= sub_state->contains_outer;
2456 41038 : result->sub_states = lappend(result->sub_states, sub_state);
2457 :
2458 41038 : sub_state = reduce_outer_joins_pass1(j->rarg);
2459 41038 : result->relids = bms_add_members(result->relids,
2460 41038 : sub_state->relids);
2461 41038 : result->contains_outer |= sub_state->contains_outer;
2462 41038 : result->sub_states = lappend(result->sub_states, sub_state);
2463 : }
2464 : else
2465 0 : elog(ERROR, "unrecognized node type: %d",
2466 : (int) nodeTag(jtnode));
2467 143900 : return result;
2468 : }
2469 :
2470 : /*
2471 : * reduce_outer_joins_pass2 - phase 2 processing
2472 : *
2473 : * jtnode: current jointree node
2474 : * state: state data collected by phase 1 for this node
2475 : * root: toplevel planner state
2476 : * nonnullable_rels: set of base relids forced non-null by upper quals
2477 : * nonnullable_vars: list of Vars forced non-null by upper quals
2478 : * forced_null_vars: list of Vars forced null by upper quals
2479 : */
2480 : static void
2481 66104 : reduce_outer_joins_pass2(Node *jtnode,
2482 : reduce_outer_joins_state *state,
2483 : PlannerInfo *root,
2484 : Relids nonnullable_rels,
2485 : List *nonnullable_vars,
2486 : List *forced_null_vars)
2487 : {
2488 : /*
2489 : * pass 2 should never descend as far as an empty subnode or base rel,
2490 : * because it's only called on subtrees marked as contains_outer.
2491 : */
2492 66104 : if (jtnode == NULL)
2493 0 : elog(ERROR, "reached empty jointree");
2494 66104 : if (IsA(jtnode, RangeTblRef))
2495 0 : elog(ERROR, "reached base rel");
2496 66104 : else if (IsA(jtnode, FromExpr))
2497 : {
2498 30546 : FromExpr *f = (FromExpr *) jtnode;
2499 : ListCell *l;
2500 : ListCell *s;
2501 : Relids pass_nonnullable_rels;
2502 : List *pass_nonnullable_vars;
2503 : List *pass_forced_null_vars;
2504 :
2505 : /* Scan quals to see if we can add any constraints */
2506 30546 : pass_nonnullable_rels = find_nonnullable_rels(f->quals);
2507 30546 : pass_nonnullable_rels = bms_add_members(pass_nonnullable_rels,
2508 : nonnullable_rels);
2509 : /* NB: we rely on list_concat to not damage its second argument */
2510 30546 : pass_nonnullable_vars = find_nonnullable_vars(f->quals);
2511 30546 : pass_nonnullable_vars = list_concat(pass_nonnullable_vars,
2512 : nonnullable_vars);
2513 30546 : pass_forced_null_vars = find_forced_null_vars(f->quals);
2514 30546 : pass_forced_null_vars = list_concat(pass_forced_null_vars,
2515 : forced_null_vars);
2516 : /* And recurse --- but only into interesting subtrees */
2517 : Assert(list_length(f->fromlist) == list_length(state->sub_states));
2518 61950 : forboth(l, f->fromlist, s, state->sub_states)
2519 : {
2520 31404 : reduce_outer_joins_state *sub_state = lfirst(s);
2521 :
2522 31404 : if (sub_state->contains_outer)
2523 30566 : reduce_outer_joins_pass2(lfirst(l), sub_state, root,
2524 : pass_nonnullable_rels,
2525 : pass_nonnullable_vars,
2526 : pass_forced_null_vars);
2527 : }
2528 30546 : bms_free(pass_nonnullable_rels);
2529 : /* can't so easily clean up var lists, unfortunately */
2530 : }
2531 35558 : else if (IsA(jtnode, JoinExpr))
2532 : {
2533 35558 : JoinExpr *j = (JoinExpr *) jtnode;
2534 35558 : int rtindex = j->rtindex;
2535 35558 : JoinType jointype = j->jointype;
2536 35558 : reduce_outer_joins_state *left_state = linitial(state->sub_states);
2537 35558 : reduce_outer_joins_state *right_state = lsecond(state->sub_states);
2538 35558 : List *local_nonnullable_vars = NIL;
2539 35558 : bool computed_local_nonnullable_vars = false;
2540 :
2541 : /* Can we simplify this join? */
2542 35558 : switch (jointype)
2543 : {
2544 : case JOIN_INNER:
2545 370 : break;
2546 : case JOIN_LEFT:
2547 34362 : if (bms_overlap(nonnullable_rels, right_state->relids))
2548 608 : jointype = JOIN_INNER;
2549 34362 : break;
2550 : case JOIN_RIGHT:
2551 168 : if (bms_overlap(nonnullable_rels, left_state->relids))
2552 12 : jointype = JOIN_INNER;
2553 168 : break;
2554 : case JOIN_FULL:
2555 470 : if (bms_overlap(nonnullable_rels, left_state->relids))
2556 : {
2557 0 : if (bms_overlap(nonnullable_rels, right_state->relids))
2558 0 : jointype = JOIN_INNER;
2559 : else
2560 0 : jointype = JOIN_LEFT;
2561 : }
2562 : else
2563 : {
2564 470 : if (bms_overlap(nonnullable_rels, right_state->relids))
2565 12 : jointype = JOIN_RIGHT;
2566 : }
2567 470 : break;
2568 : case JOIN_SEMI:
2569 : case JOIN_ANTI:
2570 :
2571 : /*
2572 : * These could only have been introduced by pull_up_sublinks,
2573 : * so there's no way that upper quals could refer to their
2574 : * righthand sides, and no point in checking.
2575 : */
2576 188 : break;
2577 : default:
2578 0 : elog(ERROR, "unrecognized join type: %d",
2579 : (int) jointype);
2580 : break;
2581 : }
2582 :
2583 : /*
2584 : * Convert JOIN_RIGHT to JOIN_LEFT. Note that in the case where we
2585 : * reduced JOIN_FULL to JOIN_RIGHT, this will mean the JoinExpr no
2586 : * longer matches the internal ordering of any CoalesceExpr's built to
2587 : * represent merged join variables. We don't care about that at
2588 : * present, but be wary of it ...
2589 : */
2590 35558 : if (jointype == JOIN_RIGHT)
2591 : {
2592 : Node *tmparg;
2593 :
2594 168 : tmparg = j->larg;
2595 168 : j->larg = j->rarg;
2596 168 : j->rarg = tmparg;
2597 168 : jointype = JOIN_LEFT;
2598 168 : right_state = linitial(state->sub_states);
2599 168 : left_state = lsecond(state->sub_states);
2600 : }
2601 :
2602 : /*
2603 : * See if we can reduce JOIN_LEFT to JOIN_ANTI. This is the case if
2604 : * the join's own quals are strict for any var that was forced null by
2605 : * higher qual levels. NOTE: there are other ways that we could
2606 : * detect an anti-join, in particular if we were to check whether Vars
2607 : * coming from the RHS must be non-null because of table constraints.
2608 : * That seems complicated and expensive though (in particular, one
2609 : * would have to be wary of lower outer joins). For the moment this
2610 : * seems sufficient.
2611 : */
2612 35558 : if (jointype == JOIN_LEFT)
2613 : {
2614 : List *overlap;
2615 :
2616 33922 : local_nonnullable_vars = find_nonnullable_vars(j->quals);
2617 33922 : computed_local_nonnullable_vars = true;
2618 :
2619 : /*
2620 : * It's not sufficient to check whether local_nonnullable_vars and
2621 : * forced_null_vars overlap: we need to know if the overlap
2622 : * includes any RHS variables.
2623 : */
2624 33922 : overlap = list_intersection(local_nonnullable_vars,
2625 : forced_null_vars);
2626 34578 : if (overlap != NIL &&
2627 656 : bms_overlap(pull_varnos((Node *) overlap),
2628 656 : right_state->relids))
2629 656 : jointype = JOIN_ANTI;
2630 : }
2631 :
2632 : /* Apply the jointype change, if any, to both jointree node and RTE */
2633 35558 : if (rtindex && jointype != j->jointype)
2634 : {
2635 1444 : RangeTblEntry *rte = rt_fetch(rtindex, root->parse->rtable);
2636 :
2637 : Assert(rte->rtekind == RTE_JOIN);
2638 : Assert(rte->jointype == j->jointype);
2639 1444 : rte->jointype = jointype;
2640 : }
2641 35558 : j->jointype = jointype;
2642 :
2643 : /* Only recurse if there's more to do below here */
2644 35558 : if (left_state->contains_outer || right_state->contains_outer)
2645 : {
2646 : Relids local_nonnullable_rels;
2647 : List *local_forced_null_vars;
2648 : Relids pass_nonnullable_rels;
2649 : List *pass_nonnullable_vars;
2650 : List *pass_forced_null_vars;
2651 :
2652 : /*
2653 : * If this join is (now) inner, we can add any constraints its
2654 : * quals provide to those we got from above. But if it is outer,
2655 : * we can pass down the local constraints only into the nullable
2656 : * side, because an outer join never eliminates any rows from its
2657 : * non-nullable side. Also, there is no point in passing upper
2658 : * constraints into the nullable side, since if there were any
2659 : * we'd have been able to reduce the join. (In the case of upper
2660 : * forced-null constraints, we *must not* pass them into the
2661 : * nullable side --- they either applied here, or not.) The upshot
2662 : * is that we pass either the local or the upper constraints,
2663 : * never both, to the children of an outer join.
2664 : *
2665 : * Note that a SEMI join works like an inner join here: it's okay
2666 : * to pass down both local and upper constraints. (There can't be
2667 : * any upper constraints affecting its inner side, but it's not
2668 : * worth having a separate code path to avoid passing them.)
2669 : *
2670 : * At a FULL join we just punt and pass nothing down --- is it
2671 : * possible to be smarter?
2672 : */
2673 5596 : if (jointype != JOIN_FULL)
2674 : {
2675 5522 : local_nonnullable_rels = find_nonnullable_rels(j->quals);
2676 5522 : if (!computed_local_nonnullable_vars)
2677 688 : local_nonnullable_vars = find_nonnullable_vars(j->quals);
2678 5522 : local_forced_null_vars = find_forced_null_vars(j->quals);
2679 5522 : if (jointype == JOIN_INNER || jointype == JOIN_SEMI)
2680 : {
2681 : /* OK to merge upper and local constraints */
2682 504 : local_nonnullable_rels = bms_add_members(local_nonnullable_rels,
2683 : nonnullable_rels);
2684 504 : local_nonnullable_vars = list_concat(local_nonnullable_vars,
2685 : nonnullable_vars);
2686 504 : local_forced_null_vars = list_concat(local_forced_null_vars,
2687 : forced_null_vars);
2688 : }
2689 : }
2690 : else
2691 : {
2692 : /* no use in calculating these */
2693 74 : local_nonnullable_rels = NULL;
2694 74 : local_forced_null_vars = NIL;
2695 : }
2696 :
2697 5596 : if (left_state->contains_outer)
2698 : {
2699 5248 : if (jointype == JOIN_INNER || jointype == JOIN_SEMI)
2700 : {
2701 : /* pass union of local and upper constraints */
2702 388 : pass_nonnullable_rels = local_nonnullable_rels;
2703 388 : pass_nonnullable_vars = local_nonnullable_vars;
2704 388 : pass_forced_null_vars = local_forced_null_vars;
2705 : }
2706 4860 : else if (jointype != JOIN_FULL) /* ie, LEFT or ANTI */
2707 : {
2708 : /* can't pass local constraints to non-nullable side */
2709 4810 : pass_nonnullable_rels = nonnullable_rels;
2710 4810 : pass_nonnullable_vars = nonnullable_vars;
2711 4810 : pass_forced_null_vars = forced_null_vars;
2712 : }
2713 : else
2714 : {
2715 : /* no constraints pass through JOIN_FULL */
2716 50 : pass_nonnullable_rels = NULL;
2717 50 : pass_nonnullable_vars = NIL;
2718 50 : pass_forced_null_vars = NIL;
2719 : }
2720 5248 : reduce_outer_joins_pass2(j->larg, left_state, root,
2721 : pass_nonnullable_rels,
2722 : pass_nonnullable_vars,
2723 : pass_forced_null_vars);
2724 : }
2725 :
2726 5596 : if (right_state->contains_outer)
2727 : {
2728 358 : if (jointype != JOIN_FULL) /* ie, INNER/LEFT/SEMI/ANTI */
2729 : {
2730 : /* pass appropriate constraints, per comment above */
2731 334 : pass_nonnullable_rels = local_nonnullable_rels;
2732 334 : pass_nonnullable_vars = local_nonnullable_vars;
2733 334 : pass_forced_null_vars = local_forced_null_vars;
2734 : }
2735 : else
2736 : {
2737 : /* no constraints pass through JOIN_FULL */
2738 24 : pass_nonnullable_rels = NULL;
2739 24 : pass_nonnullable_vars = NIL;
2740 24 : pass_forced_null_vars = NIL;
2741 : }
2742 358 : reduce_outer_joins_pass2(j->rarg, right_state, root,
2743 : pass_nonnullable_rels,
2744 : pass_nonnullable_vars,
2745 : pass_forced_null_vars);
2746 : }
2747 5596 : bms_free(local_nonnullable_rels);
2748 : }
2749 : }
2750 : else
2751 0 : elog(ERROR, "unrecognized node type: %d",
2752 : (int) nodeTag(jtnode));
2753 66104 : }
2754 :
2755 :
2756 : /*
2757 : * remove_useless_result_rtes
2758 : * Attempt to remove RTE_RESULT RTEs from the join tree.
2759 : *
2760 : * We can remove RTE_RESULT entries from the join tree using the knowledge
2761 : * that RTE_RESULT returns exactly one row and has no output columns. Hence,
2762 : * if one is inner-joined to anything else, we can delete it. Optimizations
2763 : * are also possible for some outer-join cases, as detailed below.
2764 : *
2765 : * Some of these optimizations depend on recognizing empty (constant-true)
2766 : * quals for FromExprs and JoinExprs. That makes it useful to apply this
2767 : * optimization pass after expression preprocessing, since that will have
2768 : * eliminated constant-true quals, allowing more cases to be recognized as
2769 : * optimizable. What's more, the usual reason for an RTE_RESULT to be present
2770 : * is that we pulled up a subquery or VALUES clause, thus very possibly
2771 : * replacing Vars with constants, making it more likely that a qual can be
2772 : * reduced to constant true. Also, because some optimizations depend on
2773 : * the outer-join type, it's best to have done reduce_outer_joins() first.
2774 : *
2775 : * A PlaceHolderVar referencing an RTE_RESULT RTE poses an obstacle to this
2776 : * process: we must remove the RTE_RESULT's relid from the PHV's phrels, but
2777 : * we must not reduce the phrels set to empty. If that would happen, and
2778 : * the RTE_RESULT is an immediate child of an outer join, we have to give up
2779 : * and not remove the RTE_RESULT: there is noplace else to evaluate the
2780 : * PlaceHolderVar. (That is, in such cases the RTE_RESULT *does* have output
2781 : * columns.) But if the RTE_RESULT is an immediate child of an inner join,
2782 : * we can change the PlaceHolderVar's phrels so as to evaluate it at the
2783 : * inner join instead. This is OK because we really only care that PHVs are
2784 : * evaluated above or below the correct outer joins.
2785 : *
2786 : * We used to try to do this work as part of pull_up_subqueries() where the
2787 : * potentially-optimizable cases get introduced; but it's way simpler, and
2788 : * more effective, to do it separately.
2789 : */
2790 : void
2791 110716 : remove_useless_result_rtes(PlannerInfo *root)
2792 : {
2793 : ListCell *cell;
2794 : ListCell *prev;
2795 : ListCell *next;
2796 :
2797 : /* Top level of jointree must always be a FromExpr */
2798 : Assert(IsA(root->parse->jointree, FromExpr));
2799 : /* Recurse ... */
2800 221432 : root->parse->jointree = (FromExpr *)
2801 110716 : remove_useless_results_recurse(root, (Node *) root->parse->jointree);
2802 : /* We should still have a FromExpr */
2803 : Assert(IsA(root->parse->jointree, FromExpr));
2804 :
2805 : /*
2806 : * Remove any PlanRowMark referencing an RTE_RESULT RTE. We obviously
2807 : * must do that for any RTE_RESULT that we just removed. But one for a
2808 : * RTE that we did not remove can be dropped anyway: since the RTE has
2809 : * only one possible output row, there is no need for EPQ to mark and
2810 : * restore that row.
2811 : *
2812 : * It's necessary, not optional, to remove the PlanRowMark for a surviving
2813 : * RTE_RESULT RTE; otherwise we'll generate a whole-row Var for the
2814 : * RTE_RESULT, which the executor has no support for.
2815 : */
2816 110716 : prev = NULL;
2817 110740 : for (cell = list_head(root->rowMarks); cell; cell = next)
2818 : {
2819 24 : PlanRowMark *rc = (PlanRowMark *) lfirst(cell);
2820 :
2821 24 : next = lnext(cell);
2822 24 : if (rt_fetch(rc->rti, root->parse->rtable)->rtekind == RTE_RESULT)
2823 16 : root->rowMarks = list_delete_cell(root->rowMarks, cell, prev);
2824 : else
2825 8 : prev = cell;
2826 : }
2827 110716 : }
2828 :
2829 : /*
2830 : * remove_useless_results_recurse
2831 : * Recursive guts of remove_useless_result_rtes.
2832 : *
2833 : * This recursively processes the jointree and returns a modified jointree.
2834 : */
2835 : static Node *
2836 222770 : remove_useless_results_recurse(PlannerInfo *root, Node *jtnode)
2837 : {
2838 : Assert(jtnode != NULL);
2839 222770 : if (IsA(jtnode, RangeTblRef))
2840 : {
2841 : /* Can't immediately do anything with a RangeTblRef */
2842 : }
2843 111354 : else if (IsA(jtnode, FromExpr))
2844 : {
2845 110928 : FromExpr *f = (FromExpr *) jtnode;
2846 110928 : Relids result_relids = NULL;
2847 : ListCell *cell;
2848 : ListCell *prev;
2849 : ListCell *next;
2850 :
2851 : /*
2852 : * We can drop RTE_RESULT rels from the fromlist so long as at least
2853 : * one child remains, since joining to a one-row table changes
2854 : * nothing. The easiest way to mechanize this rule is to modify the
2855 : * list in-place, using list_delete_cell.
2856 : */
2857 110928 : prev = NULL;
2858 222130 : for (cell = list_head(f->fromlist); cell; cell = next)
2859 : {
2860 111202 : Node *child = (Node *) lfirst(cell);
2861 : int varno;
2862 :
2863 : /* Recursively transform child ... */
2864 111202 : child = remove_useless_results_recurse(root, child);
2865 : /* ... and stick it back into the tree */
2866 111202 : lfirst(cell) = child;
2867 111202 : next = lnext(cell);
2868 :
2869 : /*
2870 : * If it's an RTE_RESULT with at least one sibling, we can drop
2871 : * it. We don't yet know what the inner join's final relid set
2872 : * will be, so postpone cleanup of PHVs etc till after this loop.
2873 : */
2874 111202 : if (list_length(f->fromlist) > 1 &&
2875 : (varno = get_result_relid(root, child)) != 0)
2876 : {
2877 84 : f->fromlist = list_delete_cell(f->fromlist, cell, prev);
2878 84 : result_relids = bms_add_member(result_relids, varno);
2879 : }
2880 : else
2881 111118 : prev = cell;
2882 : }
2883 :
2884 : /*
2885 : * Clean up if we dropped any RTE_RESULT RTEs. This is a bit
2886 : * inefficient if there's more than one, but it seems better to
2887 : * optimize the support code for the single-relid case.
2888 : */
2889 110928 : if (result_relids)
2890 : {
2891 84 : int varno = -1;
2892 :
2893 252 : while ((varno = bms_next_member(result_relids, varno)) >= 0)
2894 84 : remove_result_refs(root, varno, (Node *) f);
2895 : }
2896 :
2897 : /*
2898 : * If we're not at the top of the jointree, it's valid to simplify a
2899 : * degenerate FromExpr into its single child. (At the top, we must
2900 : * keep the FromExpr since Query.jointree is required to point to a
2901 : * FromExpr.)
2902 : */
2903 111140 : if (f != root->parse->jointree &&
2904 220 : f->quals == NULL &&
2905 8 : list_length(f->fromlist) == 1)
2906 8 : return (Node *) linitial(f->fromlist);
2907 : }
2908 426 : else if (IsA(jtnode, JoinExpr))
2909 : {
2910 426 : JoinExpr *j = (JoinExpr *) jtnode;
2911 : int varno;
2912 :
2913 : /* First, recurse */
2914 426 : j->larg = remove_useless_results_recurse(root, j->larg);
2915 426 : j->rarg = remove_useless_results_recurse(root, j->rarg);
2916 :
2917 : /* Apply join-type-specific optimization rules */
2918 426 : switch (j->jointype)
2919 : {
2920 : case JOIN_INNER:
2921 :
2922 : /*
2923 : * An inner join is equivalent to a FromExpr, so if either
2924 : * side was simplified to an RTE_RESULT rel, we can replace
2925 : * the join with a FromExpr with just the other side; and if
2926 : * the qual is empty (JOIN ON TRUE) then we can omit the
2927 : * FromExpr as well.
2928 : */
2929 118 : if ((varno = get_result_relid(root, j->larg)) != 0)
2930 : {
2931 22 : remove_result_refs(root, varno, j->rarg);
2932 22 : if (j->quals)
2933 8 : jtnode = (Node *)
2934 8 : makeFromExpr(list_make1(j->rarg), j->quals);
2935 : else
2936 14 : jtnode = j->rarg;
2937 : }
2938 96 : else if ((varno = get_result_relid(root, j->rarg)) != 0)
2939 : {
2940 42 : remove_result_refs(root, varno, j->larg);
2941 42 : if (j->quals)
2942 42 : jtnode = (Node *)
2943 42 : makeFromExpr(list_make1(j->larg), j->quals);
2944 : else
2945 0 : jtnode = j->larg;
2946 : }
2947 118 : break;
2948 : case JOIN_LEFT:
2949 :
2950 : /*
2951 : * We can simplify this case if the RHS is an RTE_RESULT, with
2952 : * two different possibilities:
2953 : *
2954 : * If the qual is empty (JOIN ON TRUE), then the join can be
2955 : * strength-reduced to a plain inner join, since each LHS row
2956 : * necessarily has exactly one join partner. So we can always
2957 : * discard the RHS, much as in the JOIN_INNER case above.
2958 : *
2959 : * Otherwise, it's still true that each LHS row should be
2960 : * returned exactly once, and since the RHS returns no columns
2961 : * (unless there are PHVs that have to be evaluated there), we
2962 : * don't much care if it's null-extended or not. So in this
2963 : * case also, we can just ignore the qual and discard the left
2964 : * join.
2965 : */
2966 112 : if ((varno = get_result_relid(root, j->rarg)) != 0 &&
2967 16 : (j->quals == NULL ||
2968 8 : !find_dependent_phvs((Node *) root->parse, varno)))
2969 : {
2970 0 : remove_result_refs(root, varno, j->larg);
2971 0 : jtnode = j->larg;
2972 : }
2973 104 : break;
2974 : case JOIN_RIGHT:
2975 : /* Mirror-image of the JOIN_LEFT case */
2976 0 : if ((varno = get_result_relid(root, j->larg)) != 0 &&
2977 0 : (j->quals == NULL ||
2978 0 : !find_dependent_phvs((Node *) root->parse, varno)))
2979 : {
2980 0 : remove_result_refs(root, varno, j->rarg);
2981 0 : jtnode = j->rarg;
2982 : }
2983 0 : break;
2984 : case JOIN_SEMI:
2985 :
2986 : /*
2987 : * We may simplify this case if the RHS is an RTE_RESULT; the
2988 : * join qual becomes effectively just a filter qual for the
2989 : * LHS, since we should either return the LHS row or not. For
2990 : * simplicity we inject the filter qual into a new FromExpr.
2991 : *
2992 : * Unlike the LEFT/RIGHT cases, we just Assert that there are
2993 : * no PHVs that need to be evaluated at the semijoin's RHS,
2994 : * since the rest of the query couldn't reference any outputs
2995 : * of the semijoin's RHS.
2996 : */
2997 196 : if ((varno = get_result_relid(root, j->rarg)) != 0)
2998 : {
2999 : Assert(!find_dependent_phvs((Node *) root->parse, varno));
3000 4 : remove_result_refs(root, varno, j->larg);
3001 4 : if (j->quals)
3002 4 : jtnode = (Node *)
3003 4 : makeFromExpr(list_make1(j->larg), j->quals);
3004 : else
3005 0 : jtnode = j->larg;
3006 : }
3007 196 : break;
3008 : case JOIN_FULL:
3009 : case JOIN_ANTI:
3010 : /* We have no special smarts for these cases */
3011 8 : break;
3012 : default:
3013 0 : elog(ERROR, "unrecognized join type: %d",
3014 : (int) j->jointype);
3015 : break;
3016 : }
3017 : }
3018 : else
3019 0 : elog(ERROR, "unrecognized node type: %d",
3020 : (int) nodeTag(jtnode));
3021 222762 : return jtnode;
3022 : }
3023 :
3024 : /*
3025 : * get_result_relid
3026 : * If jtnode is a RangeTblRef for an RTE_RESULT RTE, return its relid;
3027 : * otherwise return 0.
3028 : */
3029 : static int
3030 934 : get_result_relid(PlannerInfo *root, Node *jtnode)
3031 : {
3032 : int varno;
3033 :
3034 934 : if (!IsA(jtnode, RangeTblRef))
3035 116 : return 0;
3036 818 : varno = ((RangeTblRef *) jtnode)->rtindex;
3037 818 : if (rt_fetch(varno, root->parse->rtable)->rtekind != RTE_RESULT)
3038 658 : return 0;
3039 160 : return varno;
3040 : }
3041 :
3042 : /*
3043 : * remove_result_refs
3044 : * Helper routine for dropping an unneeded RTE_RESULT RTE.
3045 : *
3046 : * This doesn't physically remove the RTE from the jointree, because that's
3047 : * more easily handled in remove_useless_results_recurse. What it does do
3048 : * is the necessary cleanup in the rest of the tree: we must adjust any PHVs
3049 : * that may reference the RTE. Be sure to call this at a point where the
3050 : * jointree is valid (no disconnected nodes).
3051 : *
3052 : * Note that we don't need to process the append_rel_list, since RTEs
3053 : * referenced directly in the jointree won't be appendrel members.
3054 : *
3055 : * varno is the RTE_RESULT's relid.
3056 : * newjtloc is the jointree location at which any PHVs referencing the
3057 : * RTE_RESULT should be evaluated instead.
3058 : */
3059 : static void
3060 152 : remove_result_refs(PlannerInfo *root, int varno, Node *newjtloc)
3061 : {
3062 : /* Fix up PlaceHolderVars as needed */
3063 : /* If there are no PHVs anywhere, we can skip this bit */
3064 152 : if (root->glob->lastPHId != 0)
3065 : {
3066 : Relids subrelids;
3067 :
3068 36 : subrelids = get_relids_in_jointree(newjtloc, false);
3069 : Assert(!bms_is_empty(subrelids));
3070 36 : substitute_phv_relids((Node *) root->parse, varno, subrelids);
3071 : }
3072 :
3073 : /*
3074 : * We also need to remove any PlanRowMark referencing the RTE, but we
3075 : * postpone that work until we return to remove_useless_result_rtes.
3076 : */
3077 152 : }
3078 :
3079 :
3080 : /*
3081 : * find_dependent_phvs - are there any PlaceHolderVars whose relids are
3082 : * exactly the given varno?
3083 : */
3084 :
3085 : typedef struct
3086 : {
3087 : Relids relids;
3088 : int sublevels_up;
3089 : } find_dependent_phvs_context;
3090 :
3091 : static bool
3092 88 : find_dependent_phvs_walker(Node *node,
3093 : find_dependent_phvs_context *context)
3094 : {
3095 88 : if (node == NULL)
3096 0 : return false;
3097 88 : if (IsA(node, PlaceHolderVar))
3098 : {
3099 24 : PlaceHolderVar *phv = (PlaceHolderVar *) node;
3100 :
3101 48 : if (phv->phlevelsup == context->sublevels_up &&
3102 24 : bms_equal(context->relids, phv->phrels))
3103 8 : return true;
3104 : /* fall through to examine children */
3105 : }
3106 80 : if (IsA(node, Query))
3107 : {
3108 : /* Recurse into subselects */
3109 : bool result;
3110 :
3111 0 : context->sublevels_up++;
3112 0 : result = query_tree_walker((Query *) node,
3113 : find_dependent_phvs_walker,
3114 : (void *) context, 0);
3115 0 : context->sublevels_up--;
3116 0 : return result;
3117 : }
3118 : /* Shouldn't need to handle planner auxiliary nodes here */
3119 : Assert(!IsA(node, SpecialJoinInfo));
3120 : Assert(!IsA(node, AppendRelInfo));
3121 : Assert(!IsA(node, PlaceHolderInfo));
3122 : Assert(!IsA(node, MinMaxAggInfo));
3123 :
3124 80 : return expression_tree_walker(node, find_dependent_phvs_walker,
3125 : (void *) context);
3126 : }
3127 :
3128 : static bool
3129 8 : find_dependent_phvs(Node *node, int varno)
3130 : {
3131 : find_dependent_phvs_context context;
3132 :
3133 8 : context.relids = bms_make_singleton(varno);
3134 8 : context.sublevels_up = 0;
3135 :
3136 : /*
3137 : * Must be prepared to start with a Query or a bare expression tree.
3138 : */
3139 8 : return query_or_expression_tree_walker(node,
3140 : find_dependent_phvs_walker,
3141 : (void *) &context,
3142 : 0);
3143 : }
3144 :
3145 : /*
3146 : * substitute_phv_relids - adjust PlaceHolderVar relid sets after pulling up
3147 : * a subquery or removing an RTE_RESULT jointree item
3148 : *
3149 : * Find any PlaceHolderVar nodes in the given tree that reference the
3150 : * pulled-up relid, and change them to reference the replacement relid(s).
3151 : *
3152 : * NOTE: although this has the form of a walker, we cheat and modify the
3153 : * nodes in-place. This should be OK since the tree was copied by
3154 : * pullup_replace_vars earlier. Avoid scribbling on the original values of
3155 : * the bitmapsets, though, because expression_tree_mutator doesn't copy those.
3156 : */
3157 :
3158 : typedef struct
3159 : {
3160 : int varno;
3161 : int sublevels_up;
3162 : Relids subrelids;
3163 : } substitute_phv_relids_context;
3164 :
3165 : static bool
3166 858126 : substitute_phv_relids_walker(Node *node,
3167 : substitute_phv_relids_context *context)
3168 : {
3169 858126 : if (node == NULL)
3170 340310 : return false;
3171 517816 : if (IsA(node, PlaceHolderVar))
3172 : {
3173 1678 : PlaceHolderVar *phv = (PlaceHolderVar *) node;
3174 :
3175 3340 : if (phv->phlevelsup == context->sublevels_up &&
3176 1662 : bms_is_member(context->varno, phv->phrels))
3177 : {
3178 1052 : phv->phrels = bms_union(phv->phrels,
3179 1052 : context->subrelids);
3180 1052 : phv->phrels = bms_del_member(phv->phrels,
3181 : context->varno);
3182 : /* Assert we haven't broken the PHV */
3183 : Assert(!bms_is_empty(phv->phrels));
3184 : }
3185 : /* fall through to examine children */
3186 : }
3187 517816 : if (IsA(node, Query))
3188 : {
3189 : /* Recurse into subselects */
3190 : bool result;
3191 :
3192 22360 : context->sublevels_up++;
3193 22360 : result = query_tree_walker((Query *) node,
3194 : substitute_phv_relids_walker,
3195 : (void *) context, 0);
3196 22360 : context->sublevels_up--;
3197 22360 : return result;
3198 : }
3199 : /* Shouldn't need to handle planner auxiliary nodes here */
3200 : Assert(!IsA(node, SpecialJoinInfo));
3201 : Assert(!IsA(node, AppendRelInfo));
3202 : Assert(!IsA(node, PlaceHolderInfo));
3203 : Assert(!IsA(node, MinMaxAggInfo));
3204 :
3205 495456 : return expression_tree_walker(node, substitute_phv_relids_walker,
3206 : (void *) context);
3207 : }
3208 :
3209 : static void
3210 8286 : substitute_phv_relids(Node *node, int varno, Relids subrelids)
3211 : {
3212 : substitute_phv_relids_context context;
3213 :
3214 8286 : context.varno = varno;
3215 8286 : context.sublevels_up = 0;
3216 8286 : context.subrelids = subrelids;
3217 :
3218 : /*
3219 : * Must be prepared to start with a Query or a bare expression tree.
3220 : */
3221 8286 : query_or_expression_tree_walker(node,
3222 : substitute_phv_relids_walker,
3223 : (void *) &context,
3224 : 0);
3225 8286 : }
3226 :
3227 : /*
3228 : * fix_append_rel_relids: update RT-index fields of AppendRelInfo nodes
3229 : *
3230 : * When we pull up a subquery, any AppendRelInfo references to the subquery's
3231 : * RT index have to be replaced by the substituted relid (and there had better
3232 : * be only one). We also need to apply substitute_phv_relids to their
3233 : * translated_vars lists, since those might contain PlaceHolderVars.
3234 : *
3235 : * We assume we may modify the AppendRelInfo nodes in-place.
3236 : */
3237 : static void
3238 5816 : fix_append_rel_relids(List *append_rel_list, int varno, Relids subrelids)
3239 : {
3240 : ListCell *l;
3241 5816 : int subvarno = -1;
3242 :
3243 : /*
3244 : * We only want to extract the member relid once, but we mustn't fail
3245 : * immediately if there are multiple members; it could be that none of the
3246 : * AppendRelInfo nodes refer to it. So compute it on first use. Note that
3247 : * bms_singleton_member will complain if set is not singleton.
3248 : */
3249 8250 : foreach(l, append_rel_list)
3250 : {
3251 2434 : AppendRelInfo *appinfo = (AppendRelInfo *) lfirst(l);
3252 :
3253 : /* The parent_relid shouldn't ever be a pullup target */
3254 : Assert(appinfo->parent_relid != varno);
3255 :
3256 2434 : if (appinfo->child_relid == varno)
3257 : {
3258 1346 : if (subvarno < 0)
3259 1346 : subvarno = bms_singleton_member(subrelids);
3260 1346 : appinfo->child_relid = subvarno;
3261 : }
3262 :
3263 : /* Also fix up any PHVs in its translated vars */
3264 2434 : substitute_phv_relids((Node *) appinfo->translated_vars,
3265 : varno, subrelids);
3266 : }
3267 5816 : }
3268 :
3269 : /*
3270 : * get_relids_in_jointree: get set of RT indexes present in a jointree
3271 : *
3272 : * If include_joins is true, join RT indexes are included; if false,
3273 : * only base rels are included.
3274 : */
3275 : Relids
3276 56630 : get_relids_in_jointree(Node *jtnode, bool include_joins)
3277 : {
3278 56630 : Relids result = NULL;
3279 :
3280 56630 : if (jtnode == NULL)
3281 0 : return result;
3282 56630 : if (IsA(jtnode, RangeTblRef))
3283 : {
3284 28740 : int varno = ((RangeTblRef *) jtnode)->rtindex;
3285 :
3286 28740 : result = bms_make_singleton(varno);
3287 : }
3288 27890 : else if (IsA(jtnode, FromExpr))
3289 : {
3290 25950 : FromExpr *f = (FromExpr *) jtnode;
3291 : ListCell *l;
3292 :
3293 52826 : foreach(l, f->fromlist)
3294 : {
3295 53752 : result = bms_join(result,
3296 26876 : get_relids_in_jointree(lfirst(l),
3297 : include_joins));
3298 : }
3299 : }
3300 1940 : else if (IsA(jtnode, JoinExpr))
3301 : {
3302 1940 : JoinExpr *j = (JoinExpr *) jtnode;
3303 :
3304 1940 : result = get_relids_in_jointree(j->larg, include_joins);
3305 1940 : result = bms_join(result,
3306 : get_relids_in_jointree(j->rarg, include_joins));
3307 1940 : if (include_joins && j->rtindex)
3308 324 : result = bms_add_member(result, j->rtindex);
3309 : }
3310 : else
3311 0 : elog(ERROR, "unrecognized node type: %d",
3312 : (int) nodeTag(jtnode));
3313 56630 : return result;
3314 : }
3315 :
3316 : /*
3317 : * get_relids_for_join: get set of base RT indexes making up a join
3318 : */
3319 : Relids
3320 0 : get_relids_for_join(Query *query, int joinrelid)
3321 : {
3322 : Node *jtnode;
3323 :
3324 0 : jtnode = find_jointree_node_for_rel((Node *) query->jointree,
3325 : joinrelid);
3326 0 : if (!jtnode)
3327 0 : elog(ERROR, "could not find join node %d", joinrelid);
3328 0 : return get_relids_in_jointree(jtnode, false);
3329 : }
3330 :
3331 : /*
3332 : * find_jointree_node_for_rel: locate jointree node for a base or join RT index
3333 : *
3334 : * Returns NULL if not found
3335 : */
3336 : static Node *
3337 0 : find_jointree_node_for_rel(Node *jtnode, int relid)
3338 : {
3339 0 : if (jtnode == NULL)
3340 0 : return NULL;
3341 0 : if (IsA(jtnode, RangeTblRef))
3342 : {
3343 0 : int varno = ((RangeTblRef *) jtnode)->rtindex;
3344 :
3345 0 : if (relid == varno)
3346 0 : return jtnode;
3347 : }
3348 0 : else if (IsA(jtnode, FromExpr))
3349 : {
3350 0 : FromExpr *f = (FromExpr *) jtnode;
3351 : ListCell *l;
3352 :
3353 0 : foreach(l, f->fromlist)
3354 : {
3355 0 : jtnode = find_jointree_node_for_rel(lfirst(l), relid);
3356 0 : if (jtnode)
3357 0 : return jtnode;
3358 : }
3359 : }
3360 0 : else if (IsA(jtnode, JoinExpr))
3361 : {
3362 0 : JoinExpr *j = (JoinExpr *) jtnode;
3363 :
3364 0 : if (relid == j->rtindex)
3365 0 : return jtnode;
3366 0 : jtnode = find_jointree_node_for_rel(j->larg, relid);
3367 0 : if (jtnode)
3368 0 : return jtnode;
3369 0 : jtnode = find_jointree_node_for_rel(j->rarg, relid);
3370 0 : if (jtnode)
3371 0 : return jtnode;
3372 : }
3373 : else
3374 0 : elog(ERROR, "unrecognized node type: %d",
3375 : (int) nodeTag(jtnode));
3376 0 : return NULL;
3377 : }
|
