| blob | 0bb31fe9ca8989d54e17a4f7054142f4b5c04e93 |
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 * pull_up_sublinks
8 * inline_set_returning_functions
9 * pull_up_subqueries
10 * do expression preprocessing (including flattening JOIN alias vars)
11 * reduce_outer_joins
12 *
13 *
14 * Portions Copyright (c) 1996-2008, PostgreSQL Global Development Group
15 * Portions Copyright (c) 1994, Regents of the University of California
16 *
17 *
18 * IDENTIFICATION
19 * $PostgreSQL$
20 *
21 *-------------------------------------------------------------------------
22 */
38 {
72 Relids nonnullable_rels,
78 Relids subrelids);
82 /*
83 * pull_up_sublinks
84 * Attempt to pull up ANY and EXISTS SubLinks to be treated as
85 * semijoins or anti-semijoins.
86 *
87 * A clause "foo op ANY (sub-SELECT)" can be processed by pulling the
88 * sub-SELECT up to become a rangetable entry and treating the implied
89 * comparisons as quals of a semijoin. However, this optimization *only*
90 * works at the top level of WHERE or a JOIN/ON clause, because we cannot
91 * distinguish whether the ANY ought to return FALSE or NULL in cases
92 * involving NULL inputs. Also, in an outer join's ON clause we can only
93 * do this if the sublink is degenerate (ie, references only the nullable
94 * side of the join). In that case we can effectively push the semijoin
95 * down into the nullable side of the join. If the sublink references any
96 * nonnullable-side variables then it would have to be evaluated as part
97 * of the outer join, which makes things way too complicated.
98 *
99 * Under similar conditions, EXISTS and NOT EXISTS clauses can be handled
100 * by pulling up the sub-SELECT and creating a semijoin or anti-semijoin.
101 *
102 * This routine searches for such clauses and does the necessary parsetree
103 * transformations if any are found.
104 *
105 * This routine has to run before preprocess_expression(), so the quals
106 * clauses are not yet reduced to implicit-AND format. That means we need
107 * to recursively search through explicit AND clauses, which are
108 * probably only binary ANDs. We stop as soon as we hit a non-AND item.
109 */
110 void
112 {
113 Relids relids;
115 /* Begin recursion through the jointree */
120 }
122 /*
123 * Recurse through jointree nodes for pull_up_sublinks()
124 *
125 * In addition to returning the possibly-modified jointree node, we return
126 * a relids set of the contained rels into *relids.
127 */
131 {
133 {
135 }
137 {
141 /* jtnode is returned unmodified */
142 }
144 {
152 /* First, recurse to process children and collect their relids */
154 {
156 Relids childrelids;
163 }
164 /* Now process qual --- all children are available for use */
167 /* Any pulled-up subqueries can just be attached to the fromlist */
170 /*
171 * Although we could include the pulled-up subqueries in the returned
172 * relids, there's no need since upper quals couldn't refer to their
173 * outputs anyway.
174 */
177 }
179 {
181 Relids leftrelids;
182 Relids rightrelids;
185 /*
186 * Make a modifiable copy of join node, but don't bother copying
187 * its subnodes (yet).
188 */
192 /* Recurse to process children and collect their relids */
198 /*
199 * Now process qual, showing appropriate child relids as available,
200 * and then attach any pulled-up jointree items at the right place.
201 * The pulled-up items must go below where the quals that refer to
202 * them will be placed. Since the JoinExpr itself can only handle
203 * two child nodes, we hack up a valid jointree by inserting dummy
204 * FromExprs that have no quals. These should get flattened out
205 * during deconstruct_recurse(), so they won't impose any extra
206 * overhead.
207 */
209 {
213 rightrelids),
215 /* We arbitrarily put pulled-up subqueries into right child */
218 subfromlist),
219 NULL);
223 rightrelids,
225 /* Any pulled-up subqueries must go into right child */
228 subfromlist),
229 NULL);
232 /* can't do anything with full-join quals */
236 leftrelids,
238 /* Any pulled-up subqueries must go into left child */
241 subfromlist),
242 NULL);
248 }
250 /*
251 * Although we could include the pulled-up subqueries in the returned
252 * relids, there's no need since upper quals couldn't refer to their
253 * outputs anyway. But we *do* need to include the join's own rtindex
254 * because we haven't yet collapsed join alias variables, so upper
255 * levels would mistakenly think they couldn't use references to this
256 * join.
257 */
261 }
262 else
266 }
268 /*
269 * Recurse through top-level qual nodes for pull_up_sublinks()
270 *
271 * Caller must have initialized *fromlist to NIL. We append any new
272 * jointree items to that list.
273 */
277 {
281 {
286 /* Is it a convertible ANY or EXISTS clause? */
288 {
290 available_rels,
292 {
295 }
296 }
298 {
300 available_rels,
302 {
305 }
306 }
307 /* Else return it unmodified */
309 }
311 {
312 /* If the immediate argument of NOT is EXISTS, try to convert */
318 {
320 {
322 available_rels,
324 {
327 }
328 }
329 }
330 /* Else return it unmodified */
332 }
334 {
335 /* Recurse into AND clause */
340 {
345 oldclause,
346 available_rels,
347 fromlist));
348 }
350 }
351 /* Stop if not an AND */
353 }
355 /*
356 * inline_set_returning_functions
357 * Attempt to "inline" set-returning functions in the FROM clause.
358 *
359 * If an RTE_FUNCTION rtable entry invokes a set-returning function that
360 * contains just a simple SELECT, we can convert the rtable entry to an
361 * RTE_SUBQUERY entry exposing the SELECT directly. This is especially
362 * useful if the subquery can then be "pulled up" for further optimization,
363 * but we do it even if not, to reduce executor overhead.
364 *
365 * This has to be done before we have started to do any optimization of
366 * subqueries, else any such steps wouldn't get applied to subqueries
367 * obtained via inlining. However, we do it after pull_up_sublinks
368 * so that we can inline any functions used in SubLink subselects.
369 *
370 * Like most of the planner, this feels free to scribble on its input data
371 * structure.
372 */
373 void
375 {
379 {
383 {
386 /* Check safety of expansion, and expand if possible */
389 {
390 /* Successful expansion, replace the rtable entry */
396 }
397 }
398 }
399 }
401 /*
402 * pull_up_subqueries
403 * Look for subqueries in the rangetable that can be pulled up into
404 * the parent query. If the subquery has no special features like
405 * grouping/aggregation then we can merge it into the parent's jointree.
406 * Also, subqueries that are simple UNION ALL structures can be
407 * converted into "append relations".
408 *
409 * below_outer_join is true if this jointree node is within the nullable
410 * side of an outer join. This forces use of the PlaceHolderVar mechanism
411 * for non-nullable targetlist items.
412 *
413 * append_rel_member is true if we are looking at a member subquery of
414 * an append relation. This forces use of the PlaceHolderVar mechanism
415 * for all non-Var targetlist items, and puts some additional restrictions
416 * on what can be pulled up.
417 *
418 * A tricky aspect of this code is that if we pull up a subquery we have
419 * to replace Vars that reference the subquery's outputs throughout the
420 * parent query, including quals attached to jointree nodes above the one
421 * we are currently processing! We handle this by being careful not to
422 * change the jointree structure while recursing: no nodes other than
423 * subquery RangeTblRef entries will be replaced. Also, we can't turn
424 * ResolveNew loose on the whole jointree, because it'll return a mutated
425 * copy of the tree; we have to invoke it just on the quals, instead.
426 */
427 Node *
430 {
434 {
438 /*
439 * Is this a subquery RTE, and if so, is the subquery simple enough to
440 * pull up?
441 *
442 * If we are looking at an append-relation member, we can't pull it up
443 * unless is_safe_append_member says so.
444 */
449 below_outer_join,
450 append_rel_member);
452 /*
453 * Alternatively, is it a simple UNION ALL subquery? If so, flatten
454 * into an "append relation".
455 *
456 * It's safe to do this regardless of whether this query is
457 * itself an appendrel member. (If you're thinking we should try to
458 * flatten the two levels of appendrel together, you're right; but we
459 * handle that in set_append_rel_pathlist, not here.)
460 */
465 /* Otherwise, do nothing at this node. */
466 }
468 {
476 }
478 {
482 /* Recurse, being careful to tell myself when inside outer join */
484 {
513 }
514 }
515 else
519 }
521 /*
522 * pull_up_simple_subquery
523 * Attempt to pull up a single simple subquery.
524 *
525 * jtnode is a RangeTblRef that has been tentatively identified as a simple
526 * subquery by pull_up_subqueries. We return the replacement jointree node,
527 * or jtnode itself if we determine that the subquery can't be pulled up after
528 * all.
529 */
533 {
542 /*
543 * Need a modifiable copy of the subquery to hack on. Even if we didn't
544 * sometimes choose not to pull up below, we must do this to avoid
545 * problems if the same subquery is referenced from multiple jointree
546 * items (which can't happen normally, but might after rule rewriting).
547 */
550 /*
551 * Create a PlannerInfo data structure for this subquery.
552 *
553 * NOTE: the next few steps should match the first processing in
554 * subquery_planner(). Can we refactor to avoid code duplication, or
555 * would that just make things uglier?
556 */
571 /* No CTEs to worry about */
574 /*
575 * Pull up any SubLinks within the subquery's quals, so that we don't
576 * leave unoptimized SubLinks behind.
577 */
581 /*
582 * Similarly, inline any set-returning functions in its rangetable.
583 */
586 /*
587 * Recursively pull up the subquery's subqueries, so that
588 * pull_up_subqueries' processing is complete for its jointree and
589 * rangetable.
590 *
591 * Note: below_outer_join = false is correct here even if we are within an
592 * outer join in the upper query; the lower query starts with a clean
593 * slate for outer-join semantics. Likewise, we say we aren't handling an
594 * appendrel member.
595 */
599 /*
600 * Now we must recheck whether the subquery is still simple enough to pull
601 * up. If not, abandon processing it.
602 *
603 * We don't really need to recheck all the conditions involved, but it's
604 * easier just to keep this "if" looking the same as the one in
605 * pull_up_subqueries.
606 */
609 {
610 /* good to go */
611 }
612 else
613 {
614 /*
615 * Give up, return unmodified RangeTblRef.
616 *
617 * Note: The work we just did will be redone when the subquery gets
618 * planned on its own. Perhaps we could avoid that by storing the
619 * modified subquery back into the rangetable, but I'm not gonna risk
620 * it now.
621 */
623 }
625 /*
626 * Adjust level-0 varnos in subquery so that we can append its rangetable
627 * to upper query's. We have to fix the subquery's append_rel_list
628 * as well.
629 */
634 /*
635 * Upper-level vars in subquery are now one level closer to their parent
636 * than before.
637 */
641 /*
642 * The subquery's targetlist items are now in the appropriate form to
643 * insert into the top query, but if we are under an outer join then
644 * non-nullable items have to be turned into PlaceHolderVars. If we
645 * are dealing with an appendrel member then anything that's not a
646 * simple Var has to be turned into a PlaceHolderVar.
647 */
651 else
654 /*
655 * Replace all of the top query's references to the subquery's outputs
656 * with copies of the adjusted subtlist items, being careful not to
657 * replace any of the jointree structure. (This'd be a lot cleaner if we
658 * could use query_tree_mutator.)
659 */
681 {
689 }
691 /*
692 * Now append the adjusted rtable entries to upper query. (We hold off
693 * until after fixing the upper rtable entries; no point in running that
694 * code on the subquery ones too.)
695 */
698 /*
699 * Pull up any FOR UPDATE/SHARE markers, too. (OffsetVarNodes already
700 * adjusted the marker rtindexes, so just concat the lists.)
701 */
704 /*
705 * We also have to fix the relid sets of any FlattenedSubLink and
706 * PlaceHolderVar nodes in the parent query. (This could perhaps be done
707 * by ResolveNew, but it would clutter that routine's API unreasonably.)
708 * Note in particular that any PlaceHolderVar nodes just created by
709 * insert_targetlist_placeholders() will be adjusted, so having created
710 * them with the subquery's varno is correct.
711 *
712 * Likewise, relids appearing in AppendRelInfo nodes have to be fixed.
713 * We already checked that this won't require introducing multiple
714 * subrelids into the single-slot AppendRelInfo structs.
715 */
718 {
719 Relids subrelids;
724 }
726 /*
727 * And now add subquery's AppendRelInfos to our list.
728 */
732 /*
733 * We don't have to do the equivalent bookkeeping for outer-join info,
734 * because that hasn't been set up yet. placeholder_list likewise.
735 */
741 /*
742 * Miscellaneous housekeeping.
743 */
745 /* subquery won't be pulled up if it hasAggs, so no work there */
747 /*
748 * Return the adjusted subquery jointree to replace the RangeTblRef entry
749 * in parent's jointree.
750 */
752 }
754 /*
755 * pull_up_simple_union_all
756 * Pull up a single simple UNION ALL subquery.
757 *
758 * jtnode is a RangeTblRef that has been identified as a simple UNION ALL
759 * subquery by pull_up_subqueries. We pull up the leaf subqueries and
760 * build an "append relation" for the union set. The result value is just
761 * jtnode, since we don't actually need to change the query jointree.
762 */
765 {
771 /*
772 * Append the subquery rtable entries to upper query.
773 */
776 /*
777 * Append child RTEs to parent rtable.
778 *
779 * Upper-level vars in subquery are now one level closer to their
780 * parent than before. We don't have to worry about offsetting
781 * varnos, though, because any such vars must refer to stuff above the
782 * level of the query we are pulling into.
783 */
788 /*
789 * Recursively scan the subquery's setOperations tree and add
790 * AppendRelInfo nodes for leaf subqueries to the parent's
791 * append_rel_list.
792 */
795 rtoffset);
797 /*
798 * Mark the parent as an append relation.
799 */
803 }
805 /*
806 * pull_up_union_leaf_queries -- recursive guts of pull_up_simple_union_all
807 *
808 * Note that setOpQuery is the Query containing the setOp node, whose rtable
809 * is where to look up the RTE if setOp is a RangeTblRef. This is *not* the
810 * same as root->parse, which is the top-level Query we are pulling up into.
811 *
812 * parentRTindex is the appendrel parent's index in root->parse->rtable.
813 *
814 * The child RTEs have already been copied to the parent. childRToffset
815 * tells us where in the parent's range table they were copied.
816 */
817 static void
820 {
822 {
827 /*
828 * Calculate the index in the parent's range table
829 */
832 /*
833 * Build a suitable AppendRelInfo, and attach to parent's list.
834 */
845 /*
846 * Recursively apply pull_up_subqueries to the new child RTE. (We
847 * must build the AppendRelInfo first, because this will modify it.)
848 * Note that we can pass below_outer_join = false even if we're
849 * actually under an outer join, because the child's expressions
850 * aren't going to propagate up above the join.
851 */
855 }
857 {
860 /* Recurse to reach leaf queries */
862 childRToffset);
864 childRToffset);
865 }
866 else
867 {
870 }
871 }
873 /*
874 * make_setop_translation_list
875 * Build the list of translations from parent Vars to child Vars for
876 * a UNION ALL member. (At this point it's just a simple list of
877 * referencing Vars, but if we succeed in pulling up the member
878 * subquery, the Vars will get replaced by pulled-up expressions.)
879 */
880 static void
883 {
888 {
899 }
902 }
904 /*
905 * is_simple_subquery
906 * Check a subquery in the range table to see if it's simple enough
907 * to pull up into the parent query.
908 */
909 static bool
911 {
912 /*
913 * Let's just make sure it's a valid subselect ...
914 */
921 /*
922 * Can't currently pull up a query with setops (unless it's simple UNION
923 * ALL, which is handled by a different code path). Maybe after querytree
924 * redesign...
925 */
929 /*
930 * Can't pull up a subquery involving grouping, aggregation, sorting,
931 * limiting, or WITH. (XXX WITH could possibly be allowed later)
932 */
943 /*
944 * Don't pull up a subquery that has any set-returning functions in its
945 * targetlist. Otherwise we might well wind up inserting set-returning
946 * functions into places where they mustn't go, such as quals of higher
947 * queries.
948 */
952 /*
953 * Don't pull up a subquery that has any volatile functions in its
954 * targetlist. Otherwise we might introduce multiple evaluations of these
955 * functions, if they get copied to multiple places in the upper query,
956 * leading to surprising results. (Note: the PlaceHolderVar mechanism
957 * doesn't quite guarantee single evaluation; else we could pull up anyway
958 * and just wrap such items in PlaceHolderVars ...)
959 */
963 /*
964 * Hack: don't try to pull up a subquery with an empty jointree.
965 * query_planner() will correctly generate a Result plan for a jointree
966 * that's totally empty, but I don't think the right things happen if an
967 * empty FromExpr appears lower down in a jointree. It would pose a
968 * problem for the PlaceHolderVar mechanism too, since we'd have no
969 * way to identify where to evaluate a PHV coming out of the subquery.
970 * Not worth working hard on this, just to collapse SubqueryScan/Result
971 * into Result; especially since the SubqueryScan can often be optimized
972 * away by setrefs.c anyway.
973 */
978 }
980 /*
981 * is_simple_union_all
982 * Check a subquery to see if it's a simple UNION ALL.
983 *
984 * We require all the setops to be UNION ALL (no mixing) and there can't be
985 * any datatype coercions involved, ie, all the leaf queries must emit the
986 * same datatypes.
987 */
988 static bool
990 {
993 /* Let's just make sure it's a valid subselect ... */
1000 /* Is it a set-operation query at all? */
1006 /* Can't handle ORDER BY, LIMIT/OFFSET, locking, or WITH */
1014 /* Recursively check the tree of set operations */
1017 }
1019 static bool
1021 {
1023 {
1030 /* Leaf nodes are OK if they match the toplevel column types */
1031 /* We don't have to compare typmods here */
1033 }
1035 {
1038 /* Must be UNION ALL */
1042 /* Recurse to check inputs */
1045 }
1046 else
1047 {
1051 }
1052 }
1054 /*
1055 * insert_targetlist_placeholders
1056 * Insert PlaceHolderVar nodes into any non-junk targetlist items that are
1057 * not simple variables or strict functions of simple variables (and hence
1058 * might not correctly go to NULL when examined above the point of an outer
1059 * join). We assume we can modify the tlist items in-place.
1060 *
1061 * varno is the upper-query relid of the subquery; this is used as the
1062 * syntactic location of the PlaceHolderVars.
1063 * If wrap_non_vars is true then *only* simple Var references escape being
1064 * wrapped with PlaceHolderVars.
1065 */
1069 {
1073 {
1076 /* ignore resjunk columns */
1080 /*
1081 * Simple Vars always escape being wrapped. This is common enough
1082 * to deserve a fast path even if we aren't doing wrap_non_vars.
1083 */
1089 {
1090 /*
1091 * If it contains a Var of current level, and does not contain
1092 * any non-strict constructs, then it's certainly nullable and we
1093 * don't need to insert a PlaceHolderVar. (Note: in future maybe
1094 * we should insert PlaceHolderVars anyway, when a tlist item is
1095 * expensive to evaluate?
1096 */
1100 }
1102 /* Else wrap it in a PlaceHolderVar */
1106 }
1108 }
1110 /*
1111 * is_safe_append_member
1112 * Check a subquery that is a leaf of a UNION ALL appendrel to see if it's
1113 * safe to pull up.
1114 */
1115 static bool
1117 {
1120 /*
1121 * It's only safe to pull up the child if its jointree contains exactly
1122 * one RTE, else the AppendRelInfo data structure breaks. The one base RTE
1123 * could be buried in several levels of FromExpr, however.
1124 *
1125 * Also, the child can't have any WHERE quals because there's no place to
1126 * put them in an appendrel. (This is a bit annoying...) If we didn't
1127 * need to check this, we'd just test whether get_relids_in_jointree()
1128 * yields a singleton set, to be more consistent with the coding of
1129 * fix_append_rel_relids().
1130 */
1133 {
1139 }
1144 }
1146 /*
1147 * Helper routine for pull_up_subqueries: do ResolveNew on every expression
1148 * in the jointree, without changing the jointree structure itself. Ugly,
1149 * but there's no other way...
1150 */
1151 static void
1154 {
1158 {
1159 /* nothing to do here */
1160 }
1162 {
1171 }
1173 {
1182 /*
1183 * We don't bother to update the colvars list, since it won't be used
1184 * again ...
1185 */
1186 }
1187 else
1190 }
1192 /*
1193 * reduce_outer_joins
1194 * Attempt to reduce outer joins to plain inner joins.
1195 *
1196 * The idea here is that given a query like
1197 * SELECT ... FROM a LEFT JOIN b ON (...) WHERE b.y = 42;
1198 * we can reduce the LEFT JOIN to a plain JOIN if the "=" operator in WHERE
1199 * is strict. The strict operator will always return NULL, causing the outer
1200 * WHERE to fail, on any row where the LEFT JOIN filled in NULLs for b's
1201 * columns. Therefore, there's no need for the join to produce null-extended
1202 * rows in the first place --- which makes it a plain join not an outer join.
1203 * (This scenario may not be very likely in a query written out by hand, but
1204 * it's reasonably likely when pushing quals down into complex views.)
1205 *
1206 * More generally, an outer join can be reduced in strength if there is a
1207 * strict qual above it in the qual tree that constrains a Var from the
1208 * nullable side of the join to be non-null. (For FULL joins this applies
1209 * to each side separately.)
1210 *
1211 * Another transformation we apply here is to recognize cases like
1212 * SELECT ... FROM a LEFT JOIN b ON (a.x = b.y) WHERE b.y IS NULL;
1213 * If the join clause is strict for b.y, then only null-extended rows could
1214 * pass the upper WHERE, and we can conclude that what the query is really
1215 * specifying is an anti-semijoin. We change the join type from JOIN_LEFT
1216 * to JOIN_ANTI. The IS NULL clause then becomes redundant, and must be
1217 * removed to prevent bogus selectivity calculations, but we leave it to
1218 * distribute_qual_to_rels to get rid of such clauses.
1219 *
1220 * Also, we get rid of JOIN_RIGHT cases by flipping them around to become
1221 * JOIN_LEFT. This saves some code here and in some later planner routines,
1222 * but the main reason to do it is to not need to invent a JOIN_REVERSE_ANTI
1223 * join type.
1224 *
1225 * To ease recognition of strict qual clauses, we require this routine to be
1226 * run after expression preprocessing (i.e., qual canonicalization and JOIN
1227 * alias-var expansion).
1228 */
1229 void
1231 {
1234 /*
1235 * To avoid doing strictness checks on more quals than necessary, we want
1236 * to stop descending the jointree as soon as there are no outer joins
1237 * below our current point. This consideration forces a two-pass process.
1238 * The first pass gathers information about which base rels appear below
1239 * each side of each join clause, and about whether there are outer
1240 * join(s) below each side of each join clause. The second pass examines
1241 * qual clauses and changes join types as it descends the tree.
1242 */
1245 /* planner.c shouldn't have called me if no outer joins */
1251 }
1253 /*
1254 * reduce_outer_joins_pass1 - phase 1 data collection
1255 *
1256 * Returns a state node describing the given jointree node.
1257 */
1260 {
1272 {
1276 }
1278 {
1283 {
1291 }
1292 }
1294 {
1298 /* join's own RT index is not wanted in result->relids */
1313 }
1314 else
1318 }
1320 /*
1321 * reduce_outer_joins_pass2 - phase 2 processing
1322 *
1323 * jtnode: current jointree node
1324 * state: state data collected by phase 1 for this node
1325 * root: toplevel planner state
1326 * nonnullable_rels: set of base relids forced non-null by upper quals
1327 * nonnullable_vars: list of Vars forced non-null by upper quals
1328 * forced_null_vars: list of Vars forced null by upper quals
1329 */
1330 static void
1334 Relids nonnullable_rels,
1337 {
1338 /*
1339 * pass 2 should never descend as far as an empty subnode or base rel,
1340 * because it's only called on subtrees marked as contains_outer.
1341 */
1347 {
1351 Relids pass_nonnullable_rels;
1355 /* Scan quals to see if we can add any constraints */
1358 nonnullable_rels);
1359 /* NB: we rely on list_concat to not damage its second argument */
1362 nonnullable_vars);
1365 forced_null_vars);
1366 /* And recurse --- but only into interesting subtrees */
1369 {
1374 pass_nonnullable_rels,
1375 pass_nonnullable_vars,
1376 pass_forced_null_vars);
1377 }
1379 /* can't so easily clean up var lists, unfortunately */
1380 }
1382 {
1391 /* Can we simplify this join? */
1393 {
1406 {
1409 else
1411 }
1412 else
1413 {
1416 }
1422 }
1424 /*
1425 * Convert JOIN_RIGHT to JOIN_LEFT. Note that in the case where we
1426 * reduced JOIN_FULL to JOIN_RIGHT, this will mean the JoinExpr no
1427 * longer matches the internal ordering of any CoalesceExpr's built to
1428 * represent merged join variables. We don't care about that at
1429 * present, but be wary of it ...
1430 */
1432 {
1441 }
1443 /*
1444 * See if we can reduce JOIN_LEFT to JOIN_ANTI. This is the case
1445 * if the join's own quals are strict for any var that was forced
1446 * null by higher qual levels. NOTE: there are other ways that we
1447 * could detect an anti-join, in particular if we were to check
1448 * whether Vars coming from the RHS must be non-null because of
1449 * table constraints. That seems complicated and expensive though
1450 * (in particular, one would have to be wary of lower outer joins).
1451 * For the moment this seems sufficient.
1452 */
1454 {
1460 /*
1461 * It's not sufficient to check whether local_nonnullable_vars
1462 * and forced_null_vars overlap: we need to know if the overlap
1463 * includes any RHS variables.
1464 */
1466 forced_null_vars);
1471 }
1473 /* Apply the jointype change, if any, to both jointree node and RTE */
1475 {
1481 }
1483 /* Only recurse if there's more to do below here */
1485 {
1486 Relids local_nonnullable_rels;
1488 Relids pass_nonnullable_rels;
1492 /*
1493 * If this join is (now) inner, we can add any constraints its
1494 * quals provide to those we got from above. But if it is outer,
1495 * we can pass down the local constraints only into the nullable
1496 * side, because an outer join never eliminates any rows from its
1497 * non-nullable side. Also, there is no point in passing upper
1498 * constraints into the nullable side, since if there were any
1499 * we'd have been able to reduce the join. (In the case of
1500 * upper forced-null constraints, we *must not* pass them into
1501 * the nullable side --- they either applied here, or not.)
1502 * The upshot is that we pass either the local or the upper
1503 * constraints, never both, to the children of an outer join.
1504 *
1505 * At a FULL join we just punt and pass nothing down --- is it
1506 * possible to be smarter?
1507 */
1509 {
1515 {
1516 /* OK to merge upper and local constraints */
1518 nonnullable_rels);
1520 nonnullable_vars);
1522 forced_null_vars);
1523 }
1524 }
1525 else
1526 {
1527 /* no use in calculating these */
1530 }
1533 {
1535 {
1536 /* pass union of local and upper constraints */
1540 }
1542 {
1543 /* can't pass local constraints to non-nullable side */
1547 }
1548 else
1549 {
1550 /* no constraints pass through JOIN_FULL */
1554 }
1556 pass_nonnullable_rels,
1557 pass_nonnullable_vars,
1558 pass_forced_null_vars);
1559 }
1562 {
1564 {
1565 /* pass appropriate constraints, per comment above */
1569 }
1570 else
1571 {
1572 /* no constraints pass through JOIN_FULL */
1576 }
1578 pass_nonnullable_rels,
1579 pass_nonnullable_vars,
1580 pass_forced_null_vars);
1581 }
1583 }
1584 }
1585 else
1588 }
1590 /*
1591 * substitute_multiple_relids - adjust node relid sets after pulling up
1592 * a subquery
1593 *
1594 * Find any FlattenedSubLink or PlaceHolderVar nodes in the given tree that
1595 * reference the pulled-up relid, and change them to reference the replacement
1596 * relid(s). We do not need to recurse into subqueries, since no subquery of
1597 * the current top query could (yet) contain such a reference.
1598 *
1599 * NOTE: although this has the form of a walker, we cheat and modify the
1600 * nodes in-place. This should be OK since the tree was copied by ResolveNew
1601 * earlier. Avoid scribbling on the original values of the bitmapsets, though,
1602 * because expression_tree_mutator doesn't copy those.
1603 */
1606 {
1608 Relids subrelids;
1611 static bool
1614 {
1618 {
1622 {
1627 }
1629 {
1634 }
1635 /* fall through to examine children */
1636 }
1638 {
1642 {
1647 }
1648 /* fall through to examine children */
1649 }
1650 /* Shouldn't need to handle planner auxiliary nodes here */
1657 }
1659 static void
1661 {
1662 substitute_multiple_relids_context context;
1667 /*
1668 * Must be prepared to start with a Query or a bare expression tree.
1669 */
1671 substitute_multiple_relids_walker,
1674 }
1676 /*
1677 * fix_append_rel_relids: update RT-index fields of AppendRelInfo nodes
1678 *
1679 * When we pull up a subquery, any AppendRelInfo references to the subquery's
1680 * RT index have to be replaced by the substituted relid (and there had better
1681 * be only one). We also need to apply substitute_multiple_relids to their
1682 * translated_vars lists, since those might contain PlaceHolderVars.
1683 *
1684 * We assume we may modify the AppendRelInfo nodes in-place.
1685 */
1686 static void
1688 {
1692 /*
1693 * We only want to extract the member relid once, but we mustn't fail
1694 * immediately if there are multiple members; it could be that none of the
1695 * AppendRelInfo nodes refer to it. So compute it on first use. Note that
1696 * bms_singleton_member will complain if set is not singleton.
1697 */
1699 {
1702 /* The parent_relid shouldn't ever be a pullup target */
1706 {
1710 }
1712 /* Also finish fixups for its translated vars */
1715 }
1716 }
1718 /*
1719 * get_relids_in_jointree: get set of RT indexes present in a jointree
1720 *
1721 * If include_joins is true, join RT indexes are included; if false,
1722 * only base rels are included.
1723 */
1724 Relids
1726 {
1732 {
1736 }
1738 {
1743 {
1746 include_joins));
1747 }
1748 }
1750 {
1758 }
1759 else
1763 }
1765 /*
1766 * get_relids_for_join: get set of base RT indexes making up a join
1767 */
1768 Relids
1770 {
1774 joinrelid);
1778 }
1780 /*
1781 * find_jointree_node_for_rel: locate jointree node for a base or join RT index
1782 *
1783 * Returns NULL if not found
1784 */
1787 {
1791 {
1796 }
1798 {
1803 {
1807 }
1808 }
1810 {
1821 }
1822 else
1826 }