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