PostgreSQL Source Code git master
initsplan.c
Go to the documentation of this file.
1/*-------------------------------------------------------------------------
2 *
3 * initsplan.c
4 * Target list, group by, qualification, joininfo initialization routines
5 *
6 * Portions Copyright (c) 1996-2025, PostgreSQL Global Development Group
7 * Portions Copyright (c) 1994, Regents of the University of California
8 *
9 *
10 * IDENTIFICATION
11 * src/backend/optimizer/plan/initsplan.c
12 *
13 *-------------------------------------------------------------------------
14 */
15#include "postgres.h"
16
18#include "catalog/pg_type.h"
19#include "nodes/makefuncs.h"
20#include "nodes/nodeFuncs.h"
21#include "optimizer/clauses.h"
22#include "optimizer/cost.h"
23#include "optimizer/inherit.h"
24#include "optimizer/joininfo.h"
25#include "optimizer/optimizer.h"
26#include "optimizer/pathnode.h"
27#include "optimizer/paths.h"
29#include "optimizer/planmain.h"
30#include "optimizer/planner.h"
32#include "parser/analyze.h"
34#include "utils/lsyscache.h"
35#include "utils/rel.h"
36#include "utils/typcache.h"
37
38/* These parameters are set by GUC */
41
42
43/*
44 * deconstruct_jointree requires multiple passes over the join tree, because we
45 * need to finish computing JoinDomains before we start distributing quals.
46 * As long as we have to do that, other information such as the relevant
47 * qualscopes might as well be computed in the first pass too.
48 *
49 * deconstruct_recurse recursively examines the join tree and builds a List
50 * (in depth-first traversal order) of JoinTreeItem structs, which are then
51 * processed iteratively by deconstruct_distribute. If there are outer
52 * joins, non-degenerate outer join clauses are processed in a third pass
53 * deconstruct_distribute_oj_quals.
54 *
55 * The JoinTreeItem structs themselves can be freed at the end of
56 * deconstruct_jointree, but do not modify or free their substructure,
57 * as the relid sets may also be pointed to by RestrictInfo and
58 * SpecialJoinInfo nodes.
59 */
60typedef struct JoinTreeItem
61{
62 /* Fields filled during deconstruct_recurse: */
63 Node *jtnode; /* jointree node to examine */
64 JoinDomain *jdomain; /* join domain for its ON/WHERE clauses */
65 struct JoinTreeItem *jti_parent; /* JoinTreeItem for this node's
66 * parent, or NULL if it's the top */
67 Relids qualscope; /* base+OJ Relids syntactically included in
68 * this jointree node */
69 Relids inner_join_rels; /* base+OJ Relids syntactically included
70 * in inner joins appearing at or below
71 * this jointree node */
72 Relids left_rels; /* if join node, Relids of the left side */
73 Relids right_rels; /* if join node, Relids of the right side */
74 Relids nonnullable_rels; /* if outer join, Relids of the
75 * non-nullable side */
76 /* Fields filled during deconstruct_distribute: */
77 SpecialJoinInfo *sjinfo; /* if outer join, its SpecialJoinInfo */
78 List *oj_joinclauses; /* outer join quals not yet distributed */
79 List *lateral_clauses; /* quals postponed from children due to
80 * lateral references */
82
83
85 Index rtindex);
87 JoinDomain *parent_domain,
88 JoinTreeItem *parent_jtitem,
89 List **item_list);
92 int rti, JoinTreeItem *jtitem);
94 Relids lower_rels);
98 JoinType jointype, Index ojrelid,
99 List *clause);
101 List *clause);
103 List *jtitems,
104 JoinTreeItem *jtitem);
105static void distribute_quals_to_rels(PlannerInfo *root, List *clauses,
106 JoinTreeItem *jtitem,
108 Index security_level,
110 Relids ojscope,
111 Relids outerjoin_nonnullable,
112 Relids incompatible_relids,
113 bool allow_equivalence,
114 bool has_clone,
115 bool is_clone,
116 List **postponed_oj_qual_list);
117static void distribute_qual_to_rels(PlannerInfo *root, Node *clause,
118 JoinTreeItem *jtitem,
120 Index security_level,
122 Relids ojscope,
123 Relids outerjoin_nonnullable,
124 Relids incompatible_relids,
125 bool allow_equivalence,
126 bool has_clone,
127 bool is_clone,
128 List **postponed_oj_qual_list);
131static void check_mergejoinable(RestrictInfo *restrictinfo);
132static void check_hashjoinable(RestrictInfo *restrictinfo);
133static void check_memoizable(RestrictInfo *restrictinfo);
134
135
136/*****************************************************************************
137 *
138 * JOIN TREES
139 *
140 *****************************************************************************/
141
142/*
143 * add_base_rels_to_query
144 *
145 * Scan the query's jointree and create baserel RelOptInfos for all
146 * the base relations (e.g., table, subquery, and function RTEs)
147 * appearing in the jointree.
148 *
149 * The initial invocation must pass root->parse->jointree as the value of
150 * jtnode. Internally, the function recurses through the jointree.
151 *
152 * At the end of this process, there should be one baserel RelOptInfo for
153 * every non-join RTE that is used in the query. Some of the baserels
154 * may be appendrel parents, which will require additional "otherrel"
155 * RelOptInfos for their member rels, but those are added later.
156 */
157void
159{
160 if (jtnode == NULL)
161 return;
162 if (IsA(jtnode, RangeTblRef))
163 {
164 int varno = ((RangeTblRef *) jtnode)->rtindex;
165
166 (void) build_simple_rel(root, varno, NULL);
167 }
168 else if (IsA(jtnode, FromExpr))
169 {
170 FromExpr *f = (FromExpr *) jtnode;
171 ListCell *l;
172
173 foreach(l, f->fromlist)
175 }
176 else if (IsA(jtnode, JoinExpr))
177 {
178 JoinExpr *j = (JoinExpr *) jtnode;
179
182 }
183 else
184 elog(ERROR, "unrecognized node type: %d",
185 (int) nodeTag(jtnode));
186}
187
188/*
189 * add_other_rels_to_query
190 * create "otherrel" RelOptInfos for the children of appendrel baserels
191 *
192 * At the end of this process, there should be RelOptInfos for all relations
193 * that will be scanned by the query.
194 */
195void
197{
198 int rti;
199
200 for (rti = 1; rti < root->simple_rel_array_size; rti++)
201 {
202 RelOptInfo *rel = root->simple_rel_array[rti];
203 RangeTblEntry *rte = root->simple_rte_array[rti];
204
205 /* there may be empty slots corresponding to non-baserel RTEs */
206 if (rel == NULL)
207 continue;
208
209 /* Ignore any "otherrels" that were already added. */
210 if (rel->reloptkind != RELOPT_BASEREL)
211 continue;
212
213 /* If it's marked as inheritable, look for children. */
214 if (rte->inh)
215 expand_inherited_rtentry(root, rel, rte, rti);
216 }
217}
218
219
220/*****************************************************************************
221 *
222 * TARGET LISTS
223 *
224 *****************************************************************************/
225
226/*
227 * build_base_rel_tlists
228 * Add targetlist entries for each var needed in the query's final tlist
229 * (and HAVING clause, if any) to the appropriate base relations.
230 *
231 * We mark such vars as needed by "relation 0" to ensure that they will
232 * propagate up through all join plan steps.
233 */
234void
236{
237 List *tlist_vars = pull_var_clause((Node *) final_tlist,
241
242 if (tlist_vars != NIL)
243 {
245 list_free(tlist_vars);
246 }
247
248 /*
249 * If there's a HAVING clause, we'll need the Vars it uses, too. Note
250 * that HAVING can contain Aggrefs but not WindowFuncs.
251 */
252 if (root->parse->havingQual)
253 {
254 List *having_vars = pull_var_clause(root->parse->havingQual,
257
258 if (having_vars != NIL)
259 {
260 add_vars_to_targetlist(root, having_vars,
262 list_free(having_vars);
263 }
264 }
265}
266
267/*
268 * add_vars_to_targetlist
269 * For each variable appearing in the list, add it to the owning
270 * relation's targetlist if not already present, and mark the variable
271 * as being needed for the indicated join (or for final output if
272 * where_needed includes "relation 0").
273 *
274 * The list may also contain PlaceHolderVars. These don't necessarily
275 * have a single owning relation; we keep their attr_needed info in
276 * root->placeholder_list instead. Find or create the associated
277 * PlaceHolderInfo entry, and update its ph_needed.
278 *
279 * See also add_vars_to_attr_needed.
280 */
281void
283 Relids where_needed)
284{
285 ListCell *temp;
286
287 Assert(!bms_is_empty(where_needed));
288
289 foreach(temp, vars)
290 {
291 Node *node = (Node *) lfirst(temp);
292
293 if (IsA(node, Var))
294 {
295 Var *var = (Var *) node;
296 RelOptInfo *rel = find_base_rel(root, var->varno);
297 int attno = var->varattno;
298
299 if (bms_is_subset(where_needed, rel->relids))
300 continue;
301 Assert(attno >= rel->min_attr && attno <= rel->max_attr);
302 attno -= rel->min_attr;
303 if (rel->attr_needed[attno] == NULL)
304 {
305 /*
306 * Variable not yet requested, so add to rel's targetlist.
307 *
308 * The value available at the rel's scan level has not been
309 * nulled by any outer join, so drop its varnullingrels.
310 * (We'll put those back as we climb up the join tree.)
311 */
312 var = copyObject(var);
313 var->varnullingrels = NULL;
314 rel->reltarget->exprs = lappend(rel->reltarget->exprs, var);
315 /* reltarget cost and width will be computed later */
316 }
317 rel->attr_needed[attno] = bms_add_members(rel->attr_needed[attno],
318 where_needed);
319 }
320 else if (IsA(node, PlaceHolderVar))
321 {
322 PlaceHolderVar *phv = (PlaceHolderVar *) node;
324
325 phinfo->ph_needed = bms_add_members(phinfo->ph_needed,
326 where_needed);
327 }
328 else
329 elog(ERROR, "unrecognized node type: %d", (int) nodeTag(node));
330 }
331}
332
333/*
334 * add_vars_to_attr_needed
335 * This does a subset of what add_vars_to_targetlist does: it just
336 * updates attr_needed for Vars and ph_needed for PlaceHolderVars.
337 * We assume the Vars are already in their relations' targetlists.
338 *
339 * This is used to rebuild attr_needed/ph_needed sets after removal
340 * of a useless outer join. The removed join clause might have been
341 * the only upper-level use of some other relation's Var, in which
342 * case we can reduce that Var's attr_needed and thereby possibly
343 * open the door to further join removals. But we can't tell that
344 * without tedious reconstruction of the attr_needed data.
345 *
346 * Note that if a Var's attr_needed is successfully reduced to empty,
347 * it will still be in the relation's targetlist even though we do
348 * not really need the scan plan node to emit it. The extra plan
349 * inefficiency seems tiny enough to not be worth spending planner
350 * cycles to get rid of it.
351 */
352void
354 Relids where_needed)
355{
356 ListCell *temp;
357
358 Assert(!bms_is_empty(where_needed));
359
360 foreach(temp, vars)
361 {
362 Node *node = (Node *) lfirst(temp);
363
364 if (IsA(node, Var))
365 {
366 Var *var = (Var *) node;
367 RelOptInfo *rel = find_base_rel(root, var->varno);
368 int attno = var->varattno;
369
370 if (bms_is_subset(where_needed, rel->relids))
371 continue;
372 Assert(attno >= rel->min_attr && attno <= rel->max_attr);
373 attno -= rel->min_attr;
374 rel->attr_needed[attno] = bms_add_members(rel->attr_needed[attno],
375 where_needed);
376 }
377 else if (IsA(node, PlaceHolderVar))
378 {
379 PlaceHolderVar *phv = (PlaceHolderVar *) node;
381
382 phinfo->ph_needed = bms_add_members(phinfo->ph_needed,
383 where_needed);
384 }
385 else
386 elog(ERROR, "unrecognized node type: %d", (int) nodeTag(node));
387 }
388}
389
390/*****************************************************************************
391 *
392 * GROUP BY
393 *
394 *****************************************************************************/
395
396/*
397 * remove_useless_groupby_columns
398 * Remove any columns in the GROUP BY clause that are redundant due to
399 * being functionally dependent on other GROUP BY columns.
400 *
401 * Since some other DBMSes do not allow references to ungrouped columns, it's
402 * not unusual to find all columns listed in GROUP BY even though listing the
403 * primary-key columns, or columns of a unique constraint would be sufficient.
404 * Deleting such excess columns avoids redundant sorting or hashing work, so
405 * it's worth doing.
406 *
407 * Relcache invalidations will ensure that cached plans become invalidated
408 * when the underlying supporting indexes are dropped or if a column's NOT
409 * NULL attribute is removed.
410 */
411void
413{
414 Query *parse = root->parse;
415 Bitmapset **groupbyattnos;
416 Bitmapset **surplusvars;
417 bool tryremove = false;
418 ListCell *lc;
419 int relid;
420
421 /* No chance to do anything if there are less than two GROUP BY items */
422 if (list_length(root->processed_groupClause) < 2)
423 return;
424
425 /* Don't fiddle with the GROUP BY clause if the query has grouping sets */
426 if (parse->groupingSets)
427 return;
428
429 /*
430 * Scan the GROUP BY clause to find GROUP BY items that are simple Vars.
431 * Fill groupbyattnos[k] with a bitmapset of the column attnos of RTE k
432 * that are GROUP BY items.
433 */
434 groupbyattnos = (Bitmapset **) palloc0(sizeof(Bitmapset *) *
435 (list_length(parse->rtable) + 1));
436 foreach(lc, root->processed_groupClause)
437 {
439 TargetEntry *tle = get_sortgroupclause_tle(sgc, parse->targetList);
440 Var *var = (Var *) tle->expr;
441
442 /*
443 * Ignore non-Vars and Vars from other query levels.
444 *
445 * XXX in principle, stable expressions containing Vars could also be
446 * removed, if all the Vars are functionally dependent on other GROUP
447 * BY items. But it's not clear that such cases occur often enough to
448 * be worth troubling over.
449 */
450 if (!IsA(var, Var) ||
451 var->varlevelsup > 0)
452 continue;
453
454 /* OK, remember we have this Var */
455 relid = var->varno;
456 Assert(relid <= list_length(parse->rtable));
457
458 /*
459 * If this isn't the first column for this relation then we now have
460 * multiple columns. That means there might be some that can be
461 * removed.
462 */
463 tryremove |= !bms_is_empty(groupbyattnos[relid]);
464 groupbyattnos[relid] = bms_add_member(groupbyattnos[relid],
466 }
467
468 /*
469 * No Vars or didn't find multiple Vars for any relation in the GROUP BY?
470 * If so, nothing can be removed, so don't waste more effort trying.
471 */
472 if (!tryremove)
473 return;
474
475 /*
476 * Consider each relation and see if it is possible to remove some of its
477 * Vars from GROUP BY. For simplicity and speed, we do the actual removal
478 * in a separate pass. Here, we just fill surplusvars[k] with a bitmapset
479 * of the column attnos of RTE k that are removable GROUP BY items.
480 */
481 surplusvars = NULL; /* don't allocate array unless required */
482 relid = 0;
483 foreach(lc, parse->rtable)
484 {
486 RelOptInfo *rel;
487 Bitmapset *relattnos;
488 Bitmapset *best_keycolumns = NULL;
489 int32 best_nkeycolumns = PG_INT32_MAX;
490
491 relid++;
492
493 /* Only plain relations could have primary-key constraints */
494 if (rte->rtekind != RTE_RELATION)
495 continue;
496
497 /*
498 * We must skip inheritance parent tables as some of the child rels
499 * may cause duplicate rows. This cannot happen with partitioned
500 * tables, however.
501 */
502 if (rte->inh && rte->relkind != RELKIND_PARTITIONED_TABLE)
503 continue;
504
505 /* Nothing to do unless this rel has multiple Vars in GROUP BY */
506 relattnos = groupbyattnos[relid];
507 if (bms_membership(relattnos) != BMS_MULTIPLE)
508 continue;
509
510 rel = root->simple_rel_array[relid];
511
512 /*
513 * Now check each index for this relation to see if there are any with
514 * columns which are a proper subset of the grouping columns for this
515 * relation.
516 */
518 {
519 Bitmapset *ind_attnos;
520 bool nulls_check_ok;
521
522 /*
523 * Skip any non-unique and deferrable indexes. Predicate indexes
524 * have not been checked yet, so we must skip those too as the
525 * predOK check that's done later might fail.
526 */
527 if (!index->unique || !index->immediate || index->indpred != NIL)
528 continue;
529
530 /* For simplicity, we currently don't support expression indexes */
531 if (index->indexprs != NIL)
532 continue;
533
534 ind_attnos = NULL;
535 nulls_check_ok = true;
536 for (int i = 0; i < index->nkeycolumns; i++)
537 {
538 /*
539 * We must insist that the index columns are all defined NOT
540 * NULL otherwise duplicate NULLs could exist. However, we
541 * can relax this check when the index is defined with NULLS
542 * NOT DISTINCT as there can only be 1 NULL row, therefore
543 * functional dependency on the unique columns is maintained,
544 * despite the NULL.
545 */
546 if (!index->nullsnotdistinct &&
547 !bms_is_member(index->indexkeys[i],
548 rel->notnullattnums))
549 {
550 nulls_check_ok = false;
551 break;
552 }
553
554 ind_attnos =
555 bms_add_member(ind_attnos,
556 index->indexkeys[i] -
558 }
559
560 if (!nulls_check_ok)
561 continue;
562
563 /*
564 * Skip any indexes where the indexed columns aren't a proper
565 * subset of the GROUP BY.
566 */
567 if (bms_subset_compare(ind_attnos, relattnos) != BMS_SUBSET1)
568 continue;
569
570 /*
571 * Record the attribute numbers from the index with the fewest
572 * columns. This allows the largest number of columns to be
573 * removed from the GROUP BY clause. In the future, we may wish
574 * to consider using the narrowest set of columns and looking at
575 * pg_statistic.stawidth as it might be better to use an index
576 * with, say two INT4s, rather than, say, one long varlena column.
577 */
578 if (index->nkeycolumns < best_nkeycolumns)
579 {
580 best_keycolumns = ind_attnos;
581 best_nkeycolumns = index->nkeycolumns;
582 }
583 }
584
585 /* Did we find a suitable index? */
586 if (!bms_is_empty(best_keycolumns))
587 {
588 /*
589 * To easily remember whether we've found anything to do, we don't
590 * allocate the surplusvars[] array until we find something.
591 */
592 if (surplusvars == NULL)
593 surplusvars = (Bitmapset **) palloc0(sizeof(Bitmapset *) *
594 (list_length(parse->rtable) + 1));
595
596 /* Remember the attnos of the removable columns */
597 surplusvars[relid] = bms_difference(relattnos, best_keycolumns);
598 }
599 }
600
601 /*
602 * If we found any surplus Vars, build a new GROUP BY clause without them.
603 * (Note: this may leave some TLEs with unreferenced ressortgroupref
604 * markings, but that's harmless.)
605 */
606 if (surplusvars != NULL)
607 {
608 List *new_groupby = NIL;
609
610 foreach(lc, root->processed_groupClause)
611 {
613 TargetEntry *tle = get_sortgroupclause_tle(sgc, parse->targetList);
614 Var *var = (Var *) tle->expr;
615
616 /*
617 * New list must include non-Vars, outer Vars, and anything not
618 * marked as surplus.
619 */
620 if (!IsA(var, Var) ||
621 var->varlevelsup > 0 ||
623 surplusvars[var->varno]))
624 new_groupby = lappend(new_groupby, sgc);
625 }
626
627 root->processed_groupClause = new_groupby;
628 }
629}
630
631/*****************************************************************************
632 *
633 * LATERAL REFERENCES
634 *
635 *****************************************************************************/
636
637/*
638 * find_lateral_references
639 * For each LATERAL subquery, extract all its references to Vars and
640 * PlaceHolderVars of the current query level, and make sure those values
641 * will be available for evaluation of the subquery.
642 *
643 * While later planning steps ensure that the Var/PHV source rels are on the
644 * outside of nestloops relative to the LATERAL subquery, we also need to
645 * ensure that the Vars/PHVs propagate up to the nestloop join level; this
646 * means setting suitable where_needed values for them.
647 *
648 * Note that this only deals with lateral references in unflattened LATERAL
649 * subqueries. When we flatten a LATERAL subquery, its lateral references
650 * become plain Vars in the parent query, but they may have to be wrapped in
651 * PlaceHolderVars if they need to be forced NULL by outer joins that don't
652 * also null the LATERAL subquery. That's all handled elsewhere.
653 *
654 * This has to run before deconstruct_jointree, since it might result in
655 * creation of PlaceHolderInfos.
656 */
657void
659{
660 Index rti;
661
662 /* We need do nothing if the query contains no LATERAL RTEs */
663 if (!root->hasLateralRTEs)
664 return;
665
666 /*
667 * Examine all baserels (the rel array has been set up by now).
668 */
669 for (rti = 1; rti < root->simple_rel_array_size; rti++)
670 {
671 RelOptInfo *brel = root->simple_rel_array[rti];
672
673 /* there may be empty slots corresponding to non-baserel RTEs */
674 if (brel == NULL)
675 continue;
676
677 Assert(brel->relid == rti); /* sanity check on array */
678
679 /*
680 * This bit is less obvious than it might look. We ignore appendrel
681 * otherrels and consider only their parent baserels. In a case where
682 * a LATERAL-containing UNION ALL subquery was pulled up, it is the
683 * otherrel that is actually going to be in the plan. However, we
684 * want to mark all its lateral references as needed by the parent,
685 * because it is the parent's relid that will be used for join
686 * planning purposes. And the parent's RTE will contain all the
687 * lateral references we need to know, since the pulled-up member is
688 * nothing but a copy of parts of the original RTE's subquery. We
689 * could visit the parent's children instead and transform their
690 * references back to the parent's relid, but it would be much more
691 * complicated for no real gain. (Important here is that the child
692 * members have not yet received any processing beyond being pulled
693 * up.) Similarly, in appendrels created by inheritance expansion,
694 * it's sufficient to look at the parent relation.
695 */
696
697 /* ignore RTEs that are "other rels" */
698 if (brel->reloptkind != RELOPT_BASEREL)
699 continue;
700
702 }
703}
704
705static void
707{
708 RangeTblEntry *rte = root->simple_rte_array[rtindex];
709 List *vars;
710 List *newvars;
711 Relids where_needed;
712 ListCell *lc;
713
714 /* No cross-references are possible if it's not LATERAL */
715 if (!rte->lateral)
716 return;
717
718 /* Fetch the appropriate variables */
719 if (rte->rtekind == RTE_RELATION)
721 else if (rte->rtekind == RTE_SUBQUERY)
722 vars = pull_vars_of_level((Node *) rte->subquery, 1);
723 else if (rte->rtekind == RTE_FUNCTION)
724 vars = pull_vars_of_level((Node *) rte->functions, 0);
725 else if (rte->rtekind == RTE_TABLEFUNC)
726 vars = pull_vars_of_level((Node *) rte->tablefunc, 0);
727 else if (rte->rtekind == RTE_VALUES)
729 else
730 {
731 Assert(false);
732 return; /* keep compiler quiet */
733 }
734
735 if (vars == NIL)
736 return; /* nothing to do */
737
738 /* Copy each Var (or PlaceHolderVar) and adjust it to match our level */
739 newvars = NIL;
740 foreach(lc, vars)
741 {
742 Node *node = (Node *) lfirst(lc);
743
744 node = copyObject(node);
745 if (IsA(node, Var))
746 {
747 Var *var = (Var *) node;
748
749 /* Adjustment is easy since it's just one node */
750 var->varlevelsup = 0;
751 }
752 else if (IsA(node, PlaceHolderVar))
753 {
754 PlaceHolderVar *phv = (PlaceHolderVar *) node;
755 int levelsup = phv->phlevelsup;
756
757 /* Have to work harder to adjust the contained expression too */
758 if (levelsup != 0)
759 IncrementVarSublevelsUp(node, -levelsup, 0);
760
761 /*
762 * If we pulled the PHV out of a subquery RTE, its expression
763 * needs to be preprocessed. subquery_planner() already did this
764 * for level-zero PHVs in function and values RTEs, though.
765 */
766 if (levelsup > 0)
767 phv->phexpr = preprocess_phv_expression(root, phv->phexpr);
768 }
769 else
770 Assert(false);
771 newvars = lappend(newvars, node);
772 }
773
775
776 /*
777 * We mark the Vars as being "needed" at the LATERAL RTE. This is a bit
778 * of a cheat: a more formal approach would be to mark each one as needed
779 * at the join of the LATERAL RTE with its source RTE. But it will work,
780 * and it's much less tedious than computing a separate where_needed for
781 * each Var.
782 */
783 where_needed = bms_make_singleton(rtindex);
784
785 /*
786 * Push Vars into their source relations' targetlists, and PHVs into
787 * root->placeholder_list.
788 */
789 add_vars_to_targetlist(root, newvars, where_needed);
790
791 /*
792 * Remember the lateral references for rebuild_lateral_attr_needed and
793 * create_lateral_join_info.
794 */
795 brel->lateral_vars = newvars;
796}
797
798/*
799 * rebuild_lateral_attr_needed
800 * Put back attr_needed bits for Vars/PHVs needed for lateral references.
801 *
802 * This is used to rebuild attr_needed/ph_needed sets after removal of a
803 * useless outer join. It should match what find_lateral_references did,
804 * except that we call add_vars_to_attr_needed not add_vars_to_targetlist.
805 */
806void
808{
809 Index rti;
810
811 /* We need do nothing if the query contains no LATERAL RTEs */
812 if (!root->hasLateralRTEs)
813 return;
814
815 /* Examine the same baserels that find_lateral_references did */
816 for (rti = 1; rti < root->simple_rel_array_size; rti++)
817 {
818 RelOptInfo *brel = root->simple_rel_array[rti];
819 Relids where_needed;
820
821 if (brel == NULL)
822 continue;
823 if (brel->reloptkind != RELOPT_BASEREL)
824 continue;
825
826 /*
827 * We don't need to repeat all of extract_lateral_references, since it
828 * kindly saved the extracted Vars/PHVs in lateral_vars.
829 */
830 if (brel->lateral_vars == NIL)
831 continue;
832
833 where_needed = bms_make_singleton(rti);
834
835 add_vars_to_attr_needed(root, brel->lateral_vars, where_needed);
836 }
837}
838
839/*
840 * create_lateral_join_info
841 * Fill in the per-base-relation direct_lateral_relids, lateral_relids
842 * and lateral_referencers sets.
843 */
844void
846{
847 bool found_laterals = false;
848 Index rti;
849 ListCell *lc;
850
851 /* We need do nothing if the query contains no LATERAL RTEs */
852 if (!root->hasLateralRTEs)
853 return;
854
855 /* We'll need to have the ph_eval_at values for PlaceHolderVars */
856 Assert(root->placeholdersFrozen);
857
858 /*
859 * Examine all baserels (the rel array has been set up by now).
860 */
861 for (rti = 1; rti < root->simple_rel_array_size; rti++)
862 {
863 RelOptInfo *brel = root->simple_rel_array[rti];
864 Relids lateral_relids;
865
866 /* there may be empty slots corresponding to non-baserel RTEs */
867 if (brel == NULL)
868 continue;
869
870 Assert(brel->relid == rti); /* sanity check on array */
871
872 /* ignore RTEs that are "other rels" */
873 if (brel->reloptkind != RELOPT_BASEREL)
874 continue;
875
876 lateral_relids = NULL;
877
878 /* consider each laterally-referenced Var or PHV */
879 foreach(lc, brel->lateral_vars)
880 {
881 Node *node = (Node *) lfirst(lc);
882
883 if (IsA(node, Var))
884 {
885 Var *var = (Var *) node;
886
887 found_laterals = true;
888 lateral_relids = bms_add_member(lateral_relids,
889 var->varno);
890 }
891 else if (IsA(node, PlaceHolderVar))
892 {
893 PlaceHolderVar *phv = (PlaceHolderVar *) node;
895
896 found_laterals = true;
897 lateral_relids = bms_add_members(lateral_relids,
898 phinfo->ph_eval_at);
899 }
900 else
901 Assert(false);
902 }
903
904 /* We now have all the simple lateral refs from this rel */
905 brel->direct_lateral_relids = lateral_relids;
906 brel->lateral_relids = bms_copy(lateral_relids);
907 }
908
909 /*
910 * Now check for lateral references within PlaceHolderVars, and mark their
911 * eval_at rels as having lateral references to the source rels.
912 *
913 * For a PHV that is due to be evaluated at a baserel, mark its source(s)
914 * as direct lateral dependencies of the baserel (adding onto the ones
915 * recorded above). If it's due to be evaluated at a join, mark its
916 * source(s) as indirect lateral dependencies of each baserel in the join,
917 * ie put them into lateral_relids but not direct_lateral_relids. This is
918 * appropriate because we can't put any such baserel on the outside of a
919 * join to one of the PHV's lateral dependencies, but on the other hand we
920 * also can't yet join it directly to the dependency.
921 */
922 foreach(lc, root->placeholder_list)
923 {
924 PlaceHolderInfo *phinfo = (PlaceHolderInfo *) lfirst(lc);
925 Relids eval_at = phinfo->ph_eval_at;
926 Relids lateral_refs;
927 int varno;
928
929 if (phinfo->ph_lateral == NULL)
930 continue; /* PHV is uninteresting if no lateral refs */
931
932 found_laterals = true;
933
934 /*
935 * Include only baserels not outer joins in the evaluation sites'
936 * lateral relids. This avoids problems when outer join order gets
937 * rearranged, and it should still ensure that the lateral values are
938 * available when needed.
939 */
940 lateral_refs = bms_intersect(phinfo->ph_lateral, root->all_baserels);
941 Assert(!bms_is_empty(lateral_refs));
942
943 if (bms_get_singleton_member(eval_at, &varno))
944 {
945 /* Evaluation site is a baserel */
946 RelOptInfo *brel = find_base_rel(root, varno);
947
950 lateral_refs);
951 brel->lateral_relids =
953 lateral_refs);
954 }
955 else
956 {
957 /* Evaluation site is a join */
958 varno = -1;
959 while ((varno = bms_next_member(eval_at, varno)) >= 0)
960 {
962
963 if (brel == NULL)
964 continue; /* ignore outer joins in eval_at */
966 lateral_refs);
967 }
968 }
969 }
970
971 /*
972 * If we found no actual lateral references, we're done; but reset the
973 * hasLateralRTEs flag to avoid useless work later.
974 */
975 if (!found_laterals)
976 {
977 root->hasLateralRTEs = false;
978 return;
979 }
980
981 /*
982 * Calculate the transitive closure of the lateral_relids sets, so that
983 * they describe both direct and indirect lateral references. If relation
984 * X references Y laterally, and Y references Z laterally, then we will
985 * have to scan X on the inside of a nestloop with Z, so for all intents
986 * and purposes X is laterally dependent on Z too.
987 *
988 * This code is essentially Warshall's algorithm for transitive closure.
989 * The outer loop considers each baserel, and propagates its lateral
990 * dependencies to those baserels that have a lateral dependency on it.
991 */
992 for (rti = 1; rti < root->simple_rel_array_size; rti++)
993 {
994 RelOptInfo *brel = root->simple_rel_array[rti];
995 Relids outer_lateral_relids;
996 Index rti2;
997
998 if (brel == NULL || brel->reloptkind != RELOPT_BASEREL)
999 continue;
1000
1001 /* need not consider baserel further if it has no lateral refs */
1002 outer_lateral_relids = brel->lateral_relids;
1003 if (outer_lateral_relids == NULL)
1004 continue;
1005
1006 /* else scan all baserels */
1007 for (rti2 = 1; rti2 < root->simple_rel_array_size; rti2++)
1008 {
1009 RelOptInfo *brel2 = root->simple_rel_array[rti2];
1010
1011 if (brel2 == NULL || brel2->reloptkind != RELOPT_BASEREL)
1012 continue;
1013
1014 /* if brel2 has lateral ref to brel, propagate brel's refs */
1015 if (bms_is_member(rti, brel2->lateral_relids))
1017 outer_lateral_relids);
1018 }
1019 }
1020
1021 /*
1022 * Now that we've identified all lateral references, mark each baserel
1023 * with the set of relids of rels that reference it laterally (possibly
1024 * indirectly) --- that is, the inverse mapping of lateral_relids.
1025 */
1026 for (rti = 1; rti < root->simple_rel_array_size; rti++)
1027 {
1028 RelOptInfo *brel = root->simple_rel_array[rti];
1029 Relids lateral_relids;
1030 int rti2;
1031
1032 if (brel == NULL || brel->reloptkind != RELOPT_BASEREL)
1033 continue;
1034
1035 /* Nothing to do at rels with no lateral refs */
1036 lateral_relids = brel->lateral_relids;
1037 if (bms_is_empty(lateral_relids))
1038 continue;
1039
1040 /* No rel should have a lateral dependency on itself */
1041 Assert(!bms_is_member(rti, lateral_relids));
1042
1043 /* Mark this rel's referencees */
1044 rti2 = -1;
1045 while ((rti2 = bms_next_member(lateral_relids, rti2)) >= 0)
1046 {
1047 RelOptInfo *brel2 = root->simple_rel_array[rti2];
1048
1049 if (brel2 == NULL)
1050 continue; /* must be an OJ */
1051
1052 Assert(brel2->reloptkind == RELOPT_BASEREL);
1053 brel2->lateral_referencers =
1055 }
1056 }
1057}
1058
1059
1060/*****************************************************************************
1061 *
1062 * JOIN TREE PROCESSING
1063 *
1064 *****************************************************************************/
1065
1066/*
1067 * deconstruct_jointree
1068 * Recursively scan the query's join tree for WHERE and JOIN/ON qual
1069 * clauses, and add these to the appropriate restrictinfo and joininfo
1070 * lists belonging to base RelOptInfos. Also, add SpecialJoinInfo nodes
1071 * to root->join_info_list for any outer joins appearing in the query tree.
1072 * Return a "joinlist" data structure showing the join order decisions
1073 * that need to be made by make_one_rel().
1074 *
1075 * The "joinlist" result is a list of items that are either RangeTblRef
1076 * jointree nodes or sub-joinlists. All the items at the same level of
1077 * joinlist must be joined in an order to be determined by make_one_rel()
1078 * (note that legal orders may be constrained by SpecialJoinInfo nodes).
1079 * A sub-joinlist represents a subproblem to be planned separately. Currently
1080 * sub-joinlists arise only from FULL OUTER JOIN or when collapsing of
1081 * subproblems is stopped by join_collapse_limit or from_collapse_limit.
1082 */
1083List *
1085{
1086 List *result;
1087 JoinDomain *top_jdomain;
1088 List *item_list = NIL;
1089 ListCell *lc;
1090
1091 /*
1092 * After this point, no more PlaceHolderInfos may be made, because
1093 * make_outerjoininfo requires all active placeholders to be present in
1094 * root->placeholder_list while we crawl up the join tree.
1095 */
1096 root->placeholdersFrozen = true;
1097
1098 /* Fetch the already-created top-level join domain for the query */
1099 top_jdomain = linitial_node(JoinDomain, root->join_domains);
1100 top_jdomain->jd_relids = NULL; /* filled during deconstruct_recurse */
1101
1102 /* Start recursion at top of jointree */
1103 Assert(root->parse->jointree != NULL &&
1104 IsA(root->parse->jointree, FromExpr));
1105
1106 /* These are filled as we scan the jointree */
1107 root->all_baserels = NULL;
1108 root->outer_join_rels = NULL;
1109
1110 /* Perform the initial scan of the jointree */
1111 result = deconstruct_recurse(root, (Node *) root->parse->jointree,
1112 top_jdomain, NULL,
1113 &item_list);
1114
1115 /* Now we can form the value of all_query_rels, too */
1116 root->all_query_rels = bms_union(root->all_baserels, root->outer_join_rels);
1117
1118 /* ... which should match what we computed for the top join domain */
1119 Assert(bms_equal(root->all_query_rels, top_jdomain->jd_relids));
1120
1121 /* Now scan all the jointree nodes again, and distribute quals */
1122 foreach(lc, item_list)
1123 {
1124 JoinTreeItem *jtitem = (JoinTreeItem *) lfirst(lc);
1125
1127 }
1128
1129 /*
1130 * If there were any special joins then we may have some postponed LEFT
1131 * JOIN clauses to deal with.
1132 */
1133 if (root->join_info_list)
1134 {
1135 foreach(lc, item_list)
1136 {
1137 JoinTreeItem *jtitem = (JoinTreeItem *) lfirst(lc);
1138
1139 if (jtitem->oj_joinclauses != NIL)
1140 deconstruct_distribute_oj_quals(root, item_list, jtitem);
1141 }
1142 }
1143
1144 /* Don't need the JoinTreeItems any more */
1145 list_free_deep(item_list);
1146
1147 return result;
1148}
1149
1150/*
1151 * deconstruct_recurse
1152 * One recursion level of deconstruct_jointree's initial jointree scan.
1153 *
1154 * jtnode is the jointree node to examine, and parent_domain is the
1155 * enclosing join domain. (We must add all base+OJ relids appearing
1156 * here or below to parent_domain.) parent_jtitem is the JoinTreeItem
1157 * for the parent jointree node, or NULL at the top of the recursion.
1158 *
1159 * item_list is an in/out parameter: we add a JoinTreeItem struct to
1160 * that list for each jointree node, in depth-first traversal order.
1161 * (Hence, after each call, the last list item corresponds to its jtnode.)
1162 *
1163 * Return value is the appropriate joinlist for this jointree node.
1164 */
1165static List *
1167 JoinDomain *parent_domain,
1168 JoinTreeItem *parent_jtitem,
1169 List **item_list)
1170{
1171 List *joinlist;
1172 JoinTreeItem *jtitem;
1173
1174 Assert(jtnode != NULL);
1175
1176 /* Make the new JoinTreeItem, but don't add it to item_list yet */
1177 jtitem = palloc0_object(JoinTreeItem);
1178 jtitem->jtnode = jtnode;
1179 jtitem->jti_parent = parent_jtitem;
1180
1181 if (IsA(jtnode, RangeTblRef))
1182 {
1183 int varno = ((RangeTblRef *) jtnode)->rtindex;
1184
1185 /* Fill all_baserels as we encounter baserel jointree nodes */
1186 root->all_baserels = bms_add_member(root->all_baserels, varno);
1187 /* This node belongs to parent_domain */
1188 jtitem->jdomain = parent_domain;
1189 parent_domain->jd_relids = bms_add_member(parent_domain->jd_relids,
1190 varno);
1191 /* qualscope is just the one RTE */
1192 jtitem->qualscope = bms_make_singleton(varno);
1193 /* A single baserel does not create an inner join */
1194 jtitem->inner_join_rels = NULL;
1195 joinlist = list_make1(jtnode);
1196 }
1197 else if (IsA(jtnode, FromExpr))
1198 {
1199 FromExpr *f = (FromExpr *) jtnode;
1200 int remaining;
1201 ListCell *l;
1202
1203 /* This node belongs to parent_domain, as do its children */
1204 jtitem->jdomain = parent_domain;
1205
1206 /*
1207 * Recurse to handle child nodes, and compute output joinlist. We
1208 * collapse subproblems into a single joinlist whenever the resulting
1209 * joinlist wouldn't exceed from_collapse_limit members. Also, always
1210 * collapse one-element subproblems, since that won't lengthen the
1211 * joinlist anyway.
1212 */
1213 jtitem->qualscope = NULL;
1214 jtitem->inner_join_rels = NULL;
1215 joinlist = NIL;
1217 foreach(l, f->fromlist)
1218 {
1219 JoinTreeItem *sub_item;
1220 List *sub_joinlist;
1221 int sub_members;
1222
1223 sub_joinlist = deconstruct_recurse(root, lfirst(l),
1224 parent_domain,
1225 jtitem,
1226 item_list);
1227 sub_item = (JoinTreeItem *) llast(*item_list);
1228 jtitem->qualscope = bms_add_members(jtitem->qualscope,
1229 sub_item->qualscope);
1230 jtitem->inner_join_rels = sub_item->inner_join_rels;
1231 sub_members = list_length(sub_joinlist);
1232 remaining--;
1233 if (sub_members <= 1 ||
1234 list_length(joinlist) + sub_members + remaining <= from_collapse_limit)
1235 joinlist = list_concat(joinlist, sub_joinlist);
1236 else
1237 joinlist = lappend(joinlist, sub_joinlist);
1238 }
1239
1240 /*
1241 * A FROM with more than one list element is an inner join subsuming
1242 * all below it, so we should report inner_join_rels = qualscope. If
1243 * there was exactly one element, we should (and already did) report
1244 * whatever its inner_join_rels were. If there were no elements (is
1245 * that still possible?) the initialization before the loop fixed it.
1246 */
1247 if (list_length(f->fromlist) > 1)
1248 jtitem->inner_join_rels = jtitem->qualscope;
1249 }
1250 else if (IsA(jtnode, JoinExpr))
1251 {
1252 JoinExpr *j = (JoinExpr *) jtnode;
1253 JoinDomain *child_domain,
1254 *fj_domain;
1255 JoinTreeItem *left_item,
1256 *right_item;
1257 List *leftjoinlist,
1258 *rightjoinlist;
1259
1260 switch (j->jointype)
1261 {
1262 case JOIN_INNER:
1263 /* This node belongs to parent_domain, as do its children */
1264 jtitem->jdomain = parent_domain;
1265 /* Recurse */
1266 leftjoinlist = deconstruct_recurse(root, j->larg,
1267 parent_domain,
1268 jtitem,
1269 item_list);
1270 left_item = (JoinTreeItem *) llast(*item_list);
1271 rightjoinlist = deconstruct_recurse(root, j->rarg,
1272 parent_domain,
1273 jtitem,
1274 item_list);
1275 right_item = (JoinTreeItem *) llast(*item_list);
1276 /* Compute qualscope etc */
1277 jtitem->qualscope = bms_union(left_item->qualscope,
1278 right_item->qualscope);
1279 jtitem->inner_join_rels = jtitem->qualscope;
1280 jtitem->left_rels = left_item->qualscope;
1281 jtitem->right_rels = right_item->qualscope;
1282 /* Inner join adds no restrictions for quals */
1283 jtitem->nonnullable_rels = NULL;
1284 break;
1285 case JOIN_LEFT:
1286 case JOIN_ANTI:
1287 /* Make new join domain for my quals and the RHS */
1288 child_domain = makeNode(JoinDomain);
1289 child_domain->jd_relids = NULL; /* filled by recursion */
1290 root->join_domains = lappend(root->join_domains, child_domain);
1291 jtitem->jdomain = child_domain;
1292 /* Recurse */
1293 leftjoinlist = deconstruct_recurse(root, j->larg,
1294 parent_domain,
1295 jtitem,
1296 item_list);
1297 left_item = (JoinTreeItem *) llast(*item_list);
1298 rightjoinlist = deconstruct_recurse(root, j->rarg,
1299 child_domain,
1300 jtitem,
1301 item_list);
1302 right_item = (JoinTreeItem *) llast(*item_list);
1303 /* Compute join domain contents, qualscope etc */
1304 parent_domain->jd_relids =
1305 bms_add_members(parent_domain->jd_relids,
1306 child_domain->jd_relids);
1307 jtitem->qualscope = bms_union(left_item->qualscope,
1308 right_item->qualscope);
1309 /* caution: ANTI join derived from SEMI will lack rtindex */
1310 if (j->rtindex != 0)
1311 {
1312 parent_domain->jd_relids =
1313 bms_add_member(parent_domain->jd_relids,
1314 j->rtindex);
1315 jtitem->qualscope = bms_add_member(jtitem->qualscope,
1316 j->rtindex);
1317 root->outer_join_rels = bms_add_member(root->outer_join_rels,
1318 j->rtindex);
1320 right_item->qualscope);
1321 }
1322 jtitem->inner_join_rels = bms_union(left_item->inner_join_rels,
1323 right_item->inner_join_rels);
1324 jtitem->left_rels = left_item->qualscope;
1325 jtitem->right_rels = right_item->qualscope;
1326 jtitem->nonnullable_rels = left_item->qualscope;
1327 break;
1328 case JOIN_SEMI:
1329 /* This node belongs to parent_domain, as do its children */
1330 jtitem->jdomain = parent_domain;
1331 /* Recurse */
1332 leftjoinlist = deconstruct_recurse(root, j->larg,
1333 parent_domain,
1334 jtitem,
1335 item_list);
1336 left_item = (JoinTreeItem *) llast(*item_list);
1337 rightjoinlist = deconstruct_recurse(root, j->rarg,
1338 parent_domain,
1339 jtitem,
1340 item_list);
1341 right_item = (JoinTreeItem *) llast(*item_list);
1342 /* Compute qualscope etc */
1343 jtitem->qualscope = bms_union(left_item->qualscope,
1344 right_item->qualscope);
1345 /* SEMI join never has rtindex, so don't add to anything */
1346 Assert(j->rtindex == 0);
1347 jtitem->inner_join_rels = bms_union(left_item->inner_join_rels,
1348 right_item->inner_join_rels);
1349 jtitem->left_rels = left_item->qualscope;
1350 jtitem->right_rels = right_item->qualscope;
1351 /* Semi join adds no restrictions for quals */
1352 jtitem->nonnullable_rels = NULL;
1353 break;
1354 case JOIN_FULL:
1355 /* The FULL JOIN's quals need their very own domain */
1356 fj_domain = makeNode(JoinDomain);
1357 root->join_domains = lappend(root->join_domains, fj_domain);
1358 jtitem->jdomain = fj_domain;
1359 /* Recurse, giving each side its own join domain */
1360 child_domain = makeNode(JoinDomain);
1361 child_domain->jd_relids = NULL; /* filled by recursion */
1362 root->join_domains = lappend(root->join_domains, child_domain);
1363 leftjoinlist = deconstruct_recurse(root, j->larg,
1364 child_domain,
1365 jtitem,
1366 item_list);
1367 left_item = (JoinTreeItem *) llast(*item_list);
1368 fj_domain->jd_relids = bms_copy(child_domain->jd_relids);
1369 child_domain = makeNode(JoinDomain);
1370 child_domain->jd_relids = NULL; /* filled by recursion */
1371 root->join_domains = lappend(root->join_domains, child_domain);
1372 rightjoinlist = deconstruct_recurse(root, j->rarg,
1373 child_domain,
1374 jtitem,
1375 item_list);
1376 right_item = (JoinTreeItem *) llast(*item_list);
1377 /* Compute qualscope etc */
1378 fj_domain->jd_relids = bms_add_members(fj_domain->jd_relids,
1379 child_domain->jd_relids);
1380 parent_domain->jd_relids = bms_add_members(parent_domain->jd_relids,
1381 fj_domain->jd_relids);
1382 jtitem->qualscope = bms_union(left_item->qualscope,
1383 right_item->qualscope);
1384 Assert(j->rtindex != 0);
1385 parent_domain->jd_relids = bms_add_member(parent_domain->jd_relids,
1386 j->rtindex);
1387 jtitem->qualscope = bms_add_member(jtitem->qualscope,
1388 j->rtindex);
1389 root->outer_join_rels = bms_add_member(root->outer_join_rels,
1390 j->rtindex);
1392 left_item->qualscope);
1394 right_item->qualscope);
1395 jtitem->inner_join_rels = bms_union(left_item->inner_join_rels,
1396 right_item->inner_join_rels);
1397 jtitem->left_rels = left_item->qualscope;
1398 jtitem->right_rels = right_item->qualscope;
1399 /* each side is both outer and inner */
1400 jtitem->nonnullable_rels = jtitem->qualscope;
1401 break;
1402 default:
1403 /* JOIN_RIGHT was eliminated during reduce_outer_joins() */
1404 elog(ERROR, "unrecognized join type: %d",
1405 (int) j->jointype);
1406 leftjoinlist = rightjoinlist = NIL; /* keep compiler quiet */
1407 break;
1408 }
1409
1410 /*
1411 * Compute the output joinlist. We fold subproblems together except
1412 * at a FULL JOIN or where join_collapse_limit would be exceeded.
1413 */
1414 if (j->jointype == JOIN_FULL)
1415 {
1416 /* force the join order exactly at this node */
1417 joinlist = list_make1(list_make2(leftjoinlist, rightjoinlist));
1418 }
1419 else if (list_length(leftjoinlist) + list_length(rightjoinlist) <=
1421 {
1422 /* OK to combine subproblems */
1423 joinlist = list_concat(leftjoinlist, rightjoinlist);
1424 }
1425 else
1426 {
1427 /* can't combine, but needn't force join order above here */
1428 Node *leftpart,
1429 *rightpart;
1430
1431 /* avoid creating useless 1-element sublists */
1432 if (list_length(leftjoinlist) == 1)
1433 leftpart = (Node *) linitial(leftjoinlist);
1434 else
1435 leftpart = (Node *) leftjoinlist;
1436 if (list_length(rightjoinlist) == 1)
1437 rightpart = (Node *) linitial(rightjoinlist);
1438 else
1439 rightpart = (Node *) rightjoinlist;
1440 joinlist = list_make2(leftpart, rightpart);
1441 }
1442 }
1443 else
1444 {
1445 elog(ERROR, "unrecognized node type: %d",
1446 (int) nodeTag(jtnode));
1447 joinlist = NIL; /* keep compiler quiet */
1448 }
1449
1450 /* Finally, we can add the new JoinTreeItem to item_list */
1451 *item_list = lappend(*item_list, jtitem);
1452
1453 return joinlist;
1454}
1455
1456/*
1457 * deconstruct_distribute
1458 * Process one jointree node in phase 2 of deconstruct_jointree processing.
1459 *
1460 * Distribute quals of the node to appropriate restriction and join lists.
1461 * In addition, entries will be added to root->join_info_list for outer joins.
1462 */
1463static void
1465{
1466 Node *jtnode = jtitem->jtnode;
1467
1468 if (IsA(jtnode, RangeTblRef))
1469 {
1470 int varno = ((RangeTblRef *) jtnode)->rtindex;
1471
1472 /* Deal with any securityQuals attached to the RTE */
1473 if (root->qual_security_level > 0)
1475 varno,
1476 jtitem);
1477 }
1478 else if (IsA(jtnode, FromExpr))
1479 {
1480 FromExpr *f = (FromExpr *) jtnode;
1481
1482 /*
1483 * Process any lateral-referencing quals that were postponed to this
1484 * level by children.
1485 */
1487 jtitem,
1488 NULL,
1489 root->qual_security_level,
1490 jtitem->qualscope,
1491 NULL, NULL, NULL,
1492 true, false, false,
1493 NULL);
1494
1495 /*
1496 * Now process the top-level quals.
1497 */
1499 jtitem,
1500 NULL,
1501 root->qual_security_level,
1502 jtitem->qualscope,
1503 NULL, NULL, NULL,
1504 true, false, false,
1505 NULL);
1506 }
1507 else if (IsA(jtnode, JoinExpr))
1508 {
1509 JoinExpr *j = (JoinExpr *) jtnode;
1510 Relids ojscope;
1511 List *my_quals;
1513 List **postponed_oj_qual_list;
1514
1515 /*
1516 * Include lateral-referencing quals postponed from children in
1517 * my_quals, so that they'll be handled properly in
1518 * make_outerjoininfo. (This is destructive to
1519 * jtitem->lateral_clauses, but we won't use that again.)
1520 */
1521 my_quals = list_concat(jtitem->lateral_clauses,
1522 (List *) j->quals);
1523
1524 /*
1525 * For an OJ, form the SpecialJoinInfo now, so that we can pass it to
1526 * distribute_qual_to_rels. We must compute its ojscope too.
1527 *
1528 * Semijoins are a bit of a hybrid: we build a SpecialJoinInfo, but we
1529 * want ojscope = NULL for distribute_qual_to_rels.
1530 */
1531 if (j->jointype != JOIN_INNER)
1532 {
1534 jtitem->left_rels,
1535 jtitem->right_rels,
1536 jtitem->inner_join_rels,
1537 j->jointype,
1538 j->rtindex,
1539 my_quals);
1540 jtitem->sjinfo = sjinfo;
1541 if (j->jointype == JOIN_SEMI)
1542 ojscope = NULL;
1543 else
1544 ojscope = bms_union(sjinfo->min_lefthand,
1546 }
1547 else
1548 {
1549 sjinfo = NULL;
1550 ojscope = NULL;
1551 }
1552
1553 /*
1554 * If it's a left join with a join clause that is strict for the LHS,
1555 * then we need to postpone handling of any non-degenerate join
1556 * clauses, in case the join is able to commute with another left join
1557 * per identity 3. (Degenerate clauses need not be postponed, since
1558 * they will drop down below this join anyway.)
1559 */
1560 if (j->jointype == JOIN_LEFT && sjinfo->lhs_strict)
1561 {
1562 postponed_oj_qual_list = &jtitem->oj_joinclauses;
1563
1564 /*
1565 * Add back any commutable lower OJ relids that were removed from
1566 * min_lefthand or min_righthand, else the ojscope cross-check in
1567 * distribute_qual_to_rels will complain. Since we are postponing
1568 * processing of non-degenerate clauses, this addition doesn't
1569 * affect anything except that cross-check. Real clause
1570 * positioning decisions will be made later, when we revisit the
1571 * postponed clauses.
1572 */
1573 ojscope = bms_add_members(ojscope, sjinfo->commute_below_l);
1574 ojscope = bms_add_members(ojscope, sjinfo->commute_below_r);
1575 }
1576 else
1577 postponed_oj_qual_list = NULL;
1578
1579 /* Process the JOIN's qual clauses */
1581 jtitem,
1582 sjinfo,
1583 root->qual_security_level,
1584 jtitem->qualscope,
1585 ojscope, jtitem->nonnullable_rels,
1586 NULL, /* incompatible_relids */
1587 true, /* allow_equivalence */
1588 false, false, /* not clones */
1589 postponed_oj_qual_list);
1590
1591 /* And add the SpecialJoinInfo to join_info_list */
1592 if (sjinfo)
1593 root->join_info_list = lappend(root->join_info_list, sjinfo);
1594 }
1595 else
1596 {
1597 elog(ERROR, "unrecognized node type: %d",
1598 (int) nodeTag(jtnode));
1599 }
1600}
1601
1602/*
1603 * process_security_barrier_quals
1604 * Transfer security-barrier quals into relation's baserestrictinfo list.
1605 *
1606 * The rewriter put any relevant security-barrier conditions into the RTE's
1607 * securityQuals field, but it's now time to copy them into the rel's
1608 * baserestrictinfo.
1609 *
1610 * In inheritance cases, we only consider quals attached to the parent rel
1611 * here; they will be valid for all children too, so it's okay to consider
1612 * them for purposes like equivalence class creation. Quals attached to
1613 * individual child rels will be dealt with during path creation.
1614 */
1615static void
1617 int rti, JoinTreeItem *jtitem)
1618{
1619 RangeTblEntry *rte = root->simple_rte_array[rti];
1620 Index security_level = 0;
1621 ListCell *lc;
1622
1623 /*
1624 * Each element of the securityQuals list has been preprocessed into an
1625 * implicitly-ANDed list of clauses. All the clauses in a given sublist
1626 * should get the same security level, but successive sublists get higher
1627 * levels.
1628 */
1629 foreach(lc, rte->securityQuals)
1630 {
1631 List *qualset = (List *) lfirst(lc);
1632
1633 /*
1634 * We cheat to the extent of passing ojscope = qualscope rather than
1635 * its more logical value of NULL. The only effect this has is to
1636 * force a Var-free qual to be evaluated at the rel rather than being
1637 * pushed up to top of tree, which we don't want.
1638 */
1640 jtitem,
1641 NULL,
1642 security_level,
1643 jtitem->qualscope,
1644 jtitem->qualscope,
1645 NULL,
1646 NULL,
1647 true,
1648 false, false, /* not clones */
1649 NULL);
1650 security_level++;
1651 }
1652
1653 /* Assert that qual_security_level is higher than anything we just used */
1654 Assert(security_level <= root->qual_security_level);
1655}
1656
1657/*
1658 * mark_rels_nulled_by_join
1659 * Fill RelOptInfo.nulling_relids of baserels nulled by this outer join
1660 *
1661 * Inputs:
1662 * ojrelid: RT index of the join RTE (must not be 0)
1663 * lower_rels: the base+OJ Relids syntactically below nullable side of join
1664 */
1665static void
1667 Relids lower_rels)
1668{
1669 int relid = -1;
1670
1671 while ((relid = bms_next_member(lower_rels, relid)) > 0)
1672 {
1673 RelOptInfo *rel = root->simple_rel_array[relid];
1674
1675 /* ignore the RTE_GROUP RTE */
1676 if (relid == root->group_rtindex)
1677 continue;
1678
1679 if (rel == NULL) /* must be an outer join */
1680 {
1681 Assert(bms_is_member(relid, root->outer_join_rels));
1682 continue;
1683 }
1684 rel->nulling_relids = bms_add_member(rel->nulling_relids, ojrelid);
1685 }
1686}
1687
1688/*
1689 * make_outerjoininfo
1690 * Build a SpecialJoinInfo for the current outer join
1691 *
1692 * Inputs:
1693 * left_rels: the base+OJ Relids syntactically on outer side of join
1694 * right_rels: the base+OJ Relids syntactically on inner side of join
1695 * inner_join_rels: base+OJ Relids participating in inner joins below this one
1696 * jointype: what it says (must always be LEFT, FULL, SEMI, or ANTI)
1697 * ojrelid: RT index of the join RTE (0 for SEMI, which isn't in the RT list)
1698 * clause: the outer join's join condition (in implicit-AND format)
1699 *
1700 * The node should eventually be appended to root->join_info_list, but we
1701 * do not do that here.
1702 *
1703 * Note: we assume that this function is invoked bottom-up, so that
1704 * root->join_info_list already contains entries for all outer joins that are
1705 * syntactically below this one.
1706 */
1707static SpecialJoinInfo *
1711 JoinType jointype, Index ojrelid,
1712 List *clause)
1713{
1715 Relids clause_relids;
1716 Relids strict_relids;
1717 Relids min_lefthand;
1718 Relids min_righthand;
1719 Relids commute_below_l;
1720 Relids commute_below_r;
1721 ListCell *l;
1722
1723 /*
1724 * We should not see RIGHT JOIN here because left/right were switched
1725 * earlier
1726 */
1727 Assert(jointype != JOIN_INNER);
1728 Assert(jointype != JOIN_RIGHT);
1729
1730 /*
1731 * Presently the executor cannot support FOR [KEY] UPDATE/SHARE marking of
1732 * rels appearing on the nullable side of an outer join. (It's somewhat
1733 * unclear what that would mean, anyway: what should we mark when a result
1734 * row is generated from no element of the nullable relation?) So,
1735 * complain if any nullable rel is FOR [KEY] UPDATE/SHARE.
1736 *
1737 * You might be wondering why this test isn't made far upstream in the
1738 * parser. It's because the parser hasn't got enough info --- consider
1739 * FOR UPDATE applied to a view. Only after rewriting and flattening do
1740 * we know whether the view contains an outer join.
1741 *
1742 * We use the original RowMarkClause list here; the PlanRowMark list would
1743 * list everything.
1744 */
1745 foreach(l, root->parse->rowMarks)
1746 {
1747 RowMarkClause *rc = (RowMarkClause *) lfirst(l);
1748
1749 if (bms_is_member(rc->rti, right_rels) ||
1750 (jointype == JOIN_FULL && bms_is_member(rc->rti, left_rels)))
1751 ereport(ERROR,
1752 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
1753 /*------
1754 translator: %s is a SQL row locking clause such as FOR UPDATE */
1755 errmsg("%s cannot be applied to the nullable side of an outer join",
1756 LCS_asString(rc->strength))));
1757 }
1758
1761 sjinfo->jointype = jointype;
1762 sjinfo->ojrelid = ojrelid;
1763 /* these fields may get added to later: */
1764 sjinfo->commute_above_l = NULL;
1765 sjinfo->commute_above_r = NULL;
1766 sjinfo->commute_below_l = NULL;
1767 sjinfo->commute_below_r = NULL;
1768
1770
1771 /* If it's a full join, no need to be very smart */
1772 if (jointype == JOIN_FULL)
1773 {
1776 sjinfo->lhs_strict = false; /* don't care about this */
1777 return sjinfo;
1778 }
1779
1780 /*
1781 * Retrieve all relids mentioned within the join clause.
1782 */
1783 clause_relids = pull_varnos(root, (Node *) clause);
1784
1785 /*
1786 * For which relids is the clause strict, ie, it cannot succeed if the
1787 * rel's columns are all NULL?
1788 */
1789 strict_relids = find_nonnullable_rels((Node *) clause);
1790
1791 /* Remember whether the clause is strict for any LHS relations */
1792 sjinfo->lhs_strict = bms_overlap(strict_relids, left_rels);
1793
1794 /*
1795 * Required LHS always includes the LHS rels mentioned in the clause. We
1796 * may have to add more rels based on lower outer joins; see below.
1797 */
1798 min_lefthand = bms_intersect(clause_relids, left_rels);
1799
1800 /*
1801 * Similarly for required RHS. But here, we must also include any lower
1802 * inner joins, to ensure we don't try to commute with any of them.
1803 */
1804 min_righthand = bms_int_members(bms_union(clause_relids, inner_join_rels),
1805 right_rels);
1806
1807 /*
1808 * Now check previous outer joins for ordering restrictions.
1809 *
1810 * commute_below_l and commute_below_r accumulate the relids of lower
1811 * outer joins that we think this one can commute with. These decisions
1812 * are just tentative within this loop, since we might find an
1813 * intermediate outer join that prevents commutation. Surviving relids
1814 * will get merged into the SpecialJoinInfo structs afterwards.
1815 */
1816 commute_below_l = commute_below_r = NULL;
1817 foreach(l, root->join_info_list)
1818 {
1819 SpecialJoinInfo *otherinfo = (SpecialJoinInfo *) lfirst(l);
1820 bool have_unsafe_phvs;
1821
1822 /*
1823 * A full join is an optimization barrier: we can't associate into or
1824 * out of it. Hence, if it overlaps either LHS or RHS of the current
1825 * rel, expand that side's min relset to cover the whole full join.
1826 */
1827 if (otherinfo->jointype == JOIN_FULL)
1828 {
1829 Assert(otherinfo->ojrelid != 0);
1830 if (bms_overlap(left_rels, otherinfo->syn_lefthand) ||
1831 bms_overlap(left_rels, otherinfo->syn_righthand))
1832 {
1833 min_lefthand = bms_add_members(min_lefthand,
1834 otherinfo->syn_lefthand);
1835 min_lefthand = bms_add_members(min_lefthand,
1836 otherinfo->syn_righthand);
1837 min_lefthand = bms_add_member(min_lefthand,
1838 otherinfo->ojrelid);
1839 }
1840 if (bms_overlap(right_rels, otherinfo->syn_lefthand) ||
1842 {
1843 min_righthand = bms_add_members(min_righthand,
1844 otherinfo->syn_lefthand);
1845 min_righthand = bms_add_members(min_righthand,
1846 otherinfo->syn_righthand);
1847 min_righthand = bms_add_member(min_righthand,
1848 otherinfo->ojrelid);
1849 }
1850 /* Needn't do anything else with the full join */
1851 continue;
1852 }
1853
1854 /*
1855 * If our join condition contains any PlaceHolderVars that need to be
1856 * evaluated above the lower OJ, then we can't commute with it.
1857 */
1858 if (otherinfo->ojrelid != 0)
1859 have_unsafe_phvs =
1861 (Node *) clause,
1862 otherinfo->ojrelid);
1863 else
1864 have_unsafe_phvs = false;
1865
1866 /*
1867 * For a lower OJ in our LHS, if our join condition uses the lower
1868 * join's RHS and is not strict for that rel, we must preserve the
1869 * ordering of the two OJs, so add lower OJ's full syntactic relset to
1870 * min_lefthand. (We must use its full syntactic relset, not just its
1871 * min_lefthand + min_righthand. This is because there might be other
1872 * OJs below this one that this one can commute with, but we cannot
1873 * commute with them if we don't with this one.) Also, if we have
1874 * unsafe PHVs or the current join is a semijoin or antijoin, we must
1875 * preserve ordering regardless of strictness.
1876 *
1877 * Note: I believe we have to insist on being strict for at least one
1878 * rel in the lower OJ's min_righthand, not its whole syn_righthand.
1879 *
1880 * When we don't need to preserve ordering, check to see if outer join
1881 * identity 3 applies, and if so, remove the lower OJ's ojrelid from
1882 * our min_lefthand so that commutation is allowed.
1883 */
1884 if (bms_overlap(left_rels, otherinfo->syn_righthand))
1885 {
1886 if (bms_overlap(clause_relids, otherinfo->syn_righthand) &&
1887 (have_unsafe_phvs ||
1888 jointype == JOIN_SEMI || jointype == JOIN_ANTI ||
1889 !bms_overlap(strict_relids, otherinfo->min_righthand)))
1890 {
1891 /* Preserve ordering */
1892 min_lefthand = bms_add_members(min_lefthand,
1893 otherinfo->syn_lefthand);
1894 min_lefthand = bms_add_members(min_lefthand,
1895 otherinfo->syn_righthand);
1896 if (otherinfo->ojrelid != 0)
1897 min_lefthand = bms_add_member(min_lefthand,
1898 otherinfo->ojrelid);
1899 }
1900 else if (jointype == JOIN_LEFT &&
1901 otherinfo->jointype == JOIN_LEFT &&
1902 bms_overlap(strict_relids, otherinfo->min_righthand) &&
1903 !bms_overlap(clause_relids, otherinfo->syn_lefthand))
1904 {
1905 /* Identity 3 applies, so remove the ordering restriction */
1906 min_lefthand = bms_del_member(min_lefthand, otherinfo->ojrelid);
1907 /* Record the (still tentative) commutability relationship */
1908 commute_below_l =
1909 bms_add_member(commute_below_l, otherinfo->ojrelid);
1910 }
1911 }
1912
1913 /*
1914 * For a lower OJ in our RHS, if our join condition does not use the
1915 * lower join's RHS and the lower OJ's join condition is strict, we
1916 * can interchange the ordering of the two OJs; otherwise we must add
1917 * the lower OJ's full syntactic relset to min_righthand.
1918 *
1919 * Also, if our join condition does not use the lower join's LHS
1920 * either, force the ordering to be preserved. Otherwise we can end
1921 * up with SpecialJoinInfos with identical min_righthands, which can
1922 * confuse join_is_legal (see discussion in backend/optimizer/README).
1923 *
1924 * Also, we must preserve ordering anyway if we have unsafe PHVs, or
1925 * if either this join or the lower OJ is a semijoin or antijoin.
1926 *
1927 * When we don't need to preserve ordering, check to see if outer join
1928 * identity 3 applies, and if so, remove the lower OJ's ojrelid from
1929 * our min_righthand so that commutation is allowed.
1930 */
1931 if (bms_overlap(right_rels, otherinfo->syn_righthand))
1932 {
1933 if (bms_overlap(clause_relids, otherinfo->syn_righthand) ||
1934 !bms_overlap(clause_relids, otherinfo->min_lefthand) ||
1935 have_unsafe_phvs ||
1936 jointype == JOIN_SEMI ||
1937 jointype == JOIN_ANTI ||
1938 otherinfo->jointype == JOIN_SEMI ||
1939 otherinfo->jointype == JOIN_ANTI ||
1940 !otherinfo->lhs_strict)
1941 {
1942 /* Preserve ordering */
1943 min_righthand = bms_add_members(min_righthand,
1944 otherinfo->syn_lefthand);
1945 min_righthand = bms_add_members(min_righthand,
1946 otherinfo->syn_righthand);
1947 if (otherinfo->ojrelid != 0)
1948 min_righthand = bms_add_member(min_righthand,
1949 otherinfo->ojrelid);
1950 }
1951 else if (jointype == JOIN_LEFT &&
1952 otherinfo->jointype == JOIN_LEFT &&
1953 otherinfo->lhs_strict)
1954 {
1955 /* Identity 3 applies, so remove the ordering restriction */
1956 min_righthand = bms_del_member(min_righthand,
1957 otherinfo->ojrelid);
1958 /* Record the (still tentative) commutability relationship */
1959 commute_below_r =
1960 bms_add_member(commute_below_r, otherinfo->ojrelid);
1961 }
1962 }
1963 }
1964
1965 /*
1966 * Examine PlaceHolderVars. If a PHV is supposed to be evaluated within
1967 * this join's nullable side, then ensure that min_righthand contains the
1968 * full eval_at set of the PHV. This ensures that the PHV actually can be
1969 * evaluated within the RHS. Note that this works only because we should
1970 * already have determined the final eval_at level for any PHV
1971 * syntactically within this join.
1972 */
1973 foreach(l, root->placeholder_list)
1974 {
1975 PlaceHolderInfo *phinfo = (PlaceHolderInfo *) lfirst(l);
1976 Relids ph_syn_level = phinfo->ph_var->phrels;
1977
1978 /* Ignore placeholder if it didn't syntactically come from RHS */
1979 if (!bms_is_subset(ph_syn_level, right_rels))
1980 continue;
1981
1982 /* Else, prevent join from being formed before we eval the PHV */
1983 min_righthand = bms_add_members(min_righthand, phinfo->ph_eval_at);
1984 }
1985
1986 /*
1987 * If we found nothing to put in min_lefthand, punt and make it the full
1988 * LHS, to avoid having an empty min_lefthand which will confuse later
1989 * processing. (We don't try to be smart about such cases, just correct.)
1990 * Likewise for min_righthand.
1991 */
1992 if (bms_is_empty(min_lefthand))
1993 min_lefthand = bms_copy(left_rels);
1994 if (bms_is_empty(min_righthand))
1995 min_righthand = bms_copy(right_rels);
1996
1997 /* Now they'd better be nonempty */
1998 Assert(!bms_is_empty(min_lefthand));
1999 Assert(!bms_is_empty(min_righthand));
2000 /* Shouldn't overlap either */
2001 Assert(!bms_overlap(min_lefthand, min_righthand));
2002
2003 sjinfo->min_lefthand = min_lefthand;
2004 sjinfo->min_righthand = min_righthand;
2005
2006 /*
2007 * Now that we've identified the correct min_lefthand and min_righthand,
2008 * any commute_below_l or commute_below_r relids that have not gotten
2009 * added back into those sets (due to intervening outer joins) are indeed
2010 * commutable with this one.
2011 *
2012 * First, delete any subsequently-added-back relids (this is easier than
2013 * maintaining commute_below_l/r precisely through all the above).
2014 */
2015 commute_below_l = bms_del_members(commute_below_l, min_lefthand);
2016 commute_below_r = bms_del_members(commute_below_r, min_righthand);
2017
2018 /* Anything left? */
2019 if (commute_below_l || commute_below_r)
2020 {
2021 /* Yup, so we must update the derived data in the SpecialJoinInfos */
2022 sjinfo->commute_below_l = commute_below_l;
2023 sjinfo->commute_below_r = commute_below_r;
2024 foreach(l, root->join_info_list)
2025 {
2026 SpecialJoinInfo *otherinfo = (SpecialJoinInfo *) lfirst(l);
2027
2028 if (bms_is_member(otherinfo->ojrelid, commute_below_l))
2029 otherinfo->commute_above_l =
2030 bms_add_member(otherinfo->commute_above_l, ojrelid);
2031 else if (bms_is_member(otherinfo->ojrelid, commute_below_r))
2032 otherinfo->commute_above_r =
2033 bms_add_member(otherinfo->commute_above_r, ojrelid);
2034 }
2035 }
2036
2037 return sjinfo;
2038}
2039
2040/*
2041 * compute_semijoin_info
2042 * Fill semijoin-related fields of a new SpecialJoinInfo
2043 *
2044 * Note: this relies on only the jointype and syn_righthand fields of the
2045 * SpecialJoinInfo; the rest may not be set yet.
2046 */
2047static void
2049{
2050 List *semi_operators;
2051 List *semi_rhs_exprs;
2052 bool all_btree;
2053 bool all_hash;
2054 ListCell *lc;
2055
2056 /* Initialize semijoin-related fields in case we can't unique-ify */
2057 sjinfo->semi_can_btree = false;
2058 sjinfo->semi_can_hash = false;
2061
2062 /* Nothing more to do if it's not a semijoin */
2063 if (sjinfo->jointype != JOIN_SEMI)
2064 return;
2065
2066 /*
2067 * Look to see whether the semijoin's join quals consist of AND'ed
2068 * equality operators, with (only) RHS variables on only one side of each
2069 * one. If so, we can figure out how to enforce uniqueness for the RHS.
2070 *
2071 * Note that the input clause list is the list of quals that are
2072 * *syntactically* associated with the semijoin, which in practice means
2073 * the synthesized comparison list for an IN or the WHERE of an EXISTS.
2074 * Particularly in the latter case, it might contain clauses that aren't
2075 * *semantically* associated with the join, but refer to just one side or
2076 * the other. We can ignore such clauses here, as they will just drop
2077 * down to be processed within one side or the other. (It is okay to
2078 * consider only the syntactically-associated clauses here because for a
2079 * semijoin, no higher-level quals could refer to the RHS, and so there
2080 * can be no other quals that are semantically associated with this join.
2081 * We do things this way because it is useful to have the set of potential
2082 * unique-ification expressions before we can extract the list of quals
2083 * that are actually semantically associated with the particular join.)
2084 *
2085 * Note that the semi_operators list consists of the joinqual operators
2086 * themselves (but commuted if needed to put the RHS value on the right).
2087 * These could be cross-type operators, in which case the operator
2088 * actually needed for uniqueness is a related single-type operator. We
2089 * assume here that that operator will be available from the btree or hash
2090 * opclass when the time comes ... if not, create_unique_plan() will fail.
2091 */
2092 semi_operators = NIL;
2093 semi_rhs_exprs = NIL;
2094 all_btree = true;
2095 all_hash = enable_hashagg; /* don't consider hash if not enabled */
2096 foreach(lc, clause)
2097 {
2098 OpExpr *op = (OpExpr *) lfirst(lc);
2099 Oid opno;
2100 Node *left_expr;
2101 Node *right_expr;
2102 Relids left_varnos;
2103 Relids right_varnos;
2104 Relids all_varnos;
2105 Oid opinputtype;
2106
2107 /* Is it a binary opclause? */
2108 if (!IsA(op, OpExpr) ||
2109 list_length(op->args) != 2)
2110 {
2111 /* No, but does it reference both sides? */
2112 all_varnos = pull_varnos(root, (Node *) op);
2113 if (!bms_overlap(all_varnos, sjinfo->syn_righthand) ||
2114 bms_is_subset(all_varnos, sjinfo->syn_righthand))
2115 {
2116 /*
2117 * Clause refers to only one rel, so ignore it --- unless it
2118 * contains volatile functions, in which case we'd better
2119 * punt.
2120 */
2121 if (contain_volatile_functions((Node *) op))
2122 return;
2123 continue;
2124 }
2125 /* Non-operator clause referencing both sides, must punt */
2126 return;
2127 }
2128
2129 /* Extract data from binary opclause */
2130 opno = op->opno;
2131 left_expr = linitial(op->args);
2132 right_expr = lsecond(op->args);
2133 left_varnos = pull_varnos(root, left_expr);
2134 right_varnos = pull_varnos(root, right_expr);
2135 all_varnos = bms_union(left_varnos, right_varnos);
2136 opinputtype = exprType(left_expr);
2137
2138 /* Does it reference both sides? */
2139 if (!bms_overlap(all_varnos, sjinfo->syn_righthand) ||
2140 bms_is_subset(all_varnos, sjinfo->syn_righthand))
2141 {
2142 /*
2143 * Clause refers to only one rel, so ignore it --- unless it
2144 * contains volatile functions, in which case we'd better punt.
2145 */
2146 if (contain_volatile_functions((Node *) op))
2147 return;
2148 continue;
2149 }
2150
2151 /* check rel membership of arguments */
2152 if (!bms_is_empty(right_varnos) &&
2153 bms_is_subset(right_varnos, sjinfo->syn_righthand) &&
2154 !bms_overlap(left_varnos, sjinfo->syn_righthand))
2155 {
2156 /* typical case, right_expr is RHS variable */
2157 }
2158 else if (!bms_is_empty(left_varnos) &&
2159 bms_is_subset(left_varnos, sjinfo->syn_righthand) &&
2160 !bms_overlap(right_varnos, sjinfo->syn_righthand))
2161 {
2162 /* flipped case, left_expr is RHS variable */
2163 opno = get_commutator(opno);
2164 if (!OidIsValid(opno))
2165 return;
2166 right_expr = left_expr;
2167 }
2168 else
2169 {
2170 /* mixed membership of args, punt */
2171 return;
2172 }
2173
2174 /* all operators must be btree equality or hash equality */
2175 if (all_btree)
2176 {
2177 /* oprcanmerge is considered a hint... */
2178 if (!op_mergejoinable(opno, opinputtype) ||
2180 all_btree = false;
2181 }
2182 if (all_hash)
2183 {
2184 /* ... but oprcanhash had better be correct */
2185 if (!op_hashjoinable(opno, opinputtype))
2186 all_hash = false;
2187 }
2188 if (!(all_btree || all_hash))
2189 return;
2190
2191 /* so far so good, keep building lists */
2192 semi_operators = lappend_oid(semi_operators, opno);
2193 semi_rhs_exprs = lappend(semi_rhs_exprs, copyObject(right_expr));
2194 }
2195
2196 /* Punt if we didn't find at least one column to unique-ify */
2197 if (semi_rhs_exprs == NIL)
2198 return;
2199
2200 /*
2201 * The expressions we'd need to unique-ify mustn't be volatile.
2202 */
2203 if (contain_volatile_functions((Node *) semi_rhs_exprs))
2204 return;
2205
2206 /*
2207 * If we get here, we can unique-ify the semijoin's RHS using at least one
2208 * of sorting and hashing. Save the information about how to do that.
2209 */
2210 sjinfo->semi_can_btree = all_btree;
2211 sjinfo->semi_can_hash = all_hash;
2212 sjinfo->semi_operators = semi_operators;
2213 sjinfo->semi_rhs_exprs = semi_rhs_exprs;
2214}
2215
2216/*
2217 * deconstruct_distribute_oj_quals
2218 * Adjust LEFT JOIN quals to be suitable for commuted-left-join cases,
2219 * then push them into the joinqual lists and EquivalenceClass structures.
2220 *
2221 * This runs immediately after we've completed the deconstruct_distribute scan.
2222 * jtitems contains all the JoinTreeItems (in depth-first order), and jtitem
2223 * is one that has postponed oj_joinclauses to deal with.
2224 */
2225static void
2227 List *jtitems,
2228 JoinTreeItem *jtitem)
2229{
2230 SpecialJoinInfo *sjinfo = jtitem->sjinfo;
2232 ojscope,
2234
2235 /* Recompute syntactic and semantic scopes of this left join */
2240
2241 /*
2242 * If this join can commute with any other ones per outer-join identity 3,
2243 * and it is the one providing the join clause with flexible semantics,
2244 * then we have to generate variants of the join clause with different
2245 * nullingrels labeling. Otherwise, just push out the postponed clause
2246 * as-is.
2247 */
2248 Assert(sjinfo->lhs_strict); /* else we shouldn't be here */
2250 {
2251 Relids joins_above;
2252 Relids joins_below;
2253 Relids incompatible_joins;
2254 Relids joins_so_far;
2255 List *quals;
2256 int save_last_rinfo_serial;
2257 ListCell *lc;
2258
2259 /* Identify the outer joins this one commutes with */
2260 joins_above = sjinfo->commute_above_r;
2261 joins_below = sjinfo->commute_below_l;
2262
2263 /*
2264 * Generate qual variants with different sets of nullingrels bits.
2265 *
2266 * We only need bit-sets that correspond to the successively less
2267 * deeply syntactically-nested subsets of this join and its
2268 * commutators. That's true first because obviously only those forms
2269 * of the Vars and PHVs could appear elsewhere in the query, and
2270 * second because the outer join identities do not provide a way to
2271 * re-order such joins in a way that would require different marking.
2272 * (That is, while the current join may commute with several others,
2273 * none of those others can commute with each other.) To visit the
2274 * interesting joins in syntactic nesting order, we rely on the
2275 * jtitems list to be ordered that way.
2276 *
2277 * We first strip out all the nullingrels bits corresponding to
2278 * commuting joins below this one, and then successively put them back
2279 * as we crawl up the join stack.
2280 */
2281 quals = jtitem->oj_joinclauses;
2282 if (!bms_is_empty(joins_below))
2283 quals = (List *) remove_nulling_relids((Node *) quals,
2284 joins_below,
2285 NULL);
2286
2287 /*
2288 * We'll need to mark the lower versions of the quals as not safe to
2289 * apply above not-yet-processed joins of the stack. This prevents
2290 * possibly applying a cloned qual at the wrong join level.
2291 */
2292 incompatible_joins = bms_union(joins_below, joins_above);
2293 incompatible_joins = bms_add_member(incompatible_joins,
2294 sjinfo->ojrelid);
2295
2296 /*
2297 * Each time we produce RestrictInfo(s) from these quals, reset the
2298 * last_rinfo_serial counter, so that the RestrictInfos for the "same"
2299 * qual condition get identical serial numbers. (This relies on the
2300 * fact that we're not changing the qual list in any way that'd affect
2301 * the number of RestrictInfos built from it.) This'll allow us to
2302 * detect duplicative qual usage later.
2303 */
2304 save_last_rinfo_serial = root->last_rinfo_serial;
2305
2306 joins_so_far = NULL;
2307 foreach(lc, jtitems)
2308 {
2309 JoinTreeItem *otherjtitem = (JoinTreeItem *) lfirst(lc);
2310 SpecialJoinInfo *othersj = otherjtitem->sjinfo;
2311 bool below_sjinfo = false;
2312 bool above_sjinfo = false;
2313 Relids this_qualscope;
2314 Relids this_ojscope;
2315 bool allow_equivalence,
2316 has_clone,
2317 is_clone;
2318
2319 if (othersj == NULL)
2320 continue; /* not an outer-join item, ignore */
2321
2322 if (bms_is_member(othersj->ojrelid, joins_below))
2323 {
2324 /* othersj commutes with sjinfo from below left */
2325 below_sjinfo = true;
2326 }
2327 else if (othersj == sjinfo)
2328 {
2329 /* found our join in syntactic order */
2330 Assert(bms_equal(joins_so_far, joins_below));
2331 }
2332 else if (bms_is_member(othersj->ojrelid, joins_above))
2333 {
2334 /* othersj commutes with sjinfo from above */
2335 above_sjinfo = true;
2336 }
2337 else
2338 {
2339 /* othersj is not relevant, ignore */
2340 continue;
2341 }
2342
2343 /* Reset serial counter for this version of the quals */
2344 root->last_rinfo_serial = save_last_rinfo_serial;
2345
2346 /*
2347 * When we are looking at joins above sjinfo, we are envisioning
2348 * pushing sjinfo to above othersj, so add othersj's nulling bit
2349 * before distributing the quals. We should add it to Vars coming
2350 * from the current join's LHS: we want to transform the second
2351 * form of OJ identity 3 to the first form, in which Vars of
2352 * relation B will appear nulled by the syntactically-upper OJ
2353 * within the Pbc clause, but those of relation C will not. (In
2354 * the notation used by optimizer/README, we're converting a qual
2355 * of the form Pbc to Pb*c.) Of course, we must also remove that
2356 * bit from the incompatible_joins value, else we'll make a qual
2357 * that can't be placed anywhere.
2358 */
2359 if (above_sjinfo)
2360 {
2361 quals = (List *)
2362 add_nulling_relids((Node *) quals,
2364 bms_make_singleton(othersj->ojrelid));
2365 incompatible_joins = bms_del_member(incompatible_joins,
2366 othersj->ojrelid);
2367 }
2368
2369 /* Compute qualscope and ojscope for this join level */
2370 this_qualscope = bms_union(qualscope, joins_so_far);
2371 this_ojscope = bms_union(ojscope, joins_so_far);
2372 if (above_sjinfo)
2373 {
2374 /* othersj is not yet in joins_so_far, but we need it */
2375 this_qualscope = bms_add_member(this_qualscope,
2376 othersj->ojrelid);
2377 this_ojscope = bms_add_member(this_ojscope,
2378 othersj->ojrelid);
2379 /* sjinfo is in joins_so_far, and we don't want it */
2380 this_ojscope = bms_del_member(this_ojscope,
2381 sjinfo->ojrelid);
2382 }
2383
2384 /*
2385 * We generate EquivalenceClasses only from the first form of the
2386 * quals, with the fewest nullingrels bits set. An EC made from
2387 * this version of the quals can be useful below the outer-join
2388 * nest, whereas versions with some nullingrels bits set would not
2389 * be. We cannot generate ECs from more than one version, or
2390 * we'll make nonsensical conclusions that Vars with nullingrels
2391 * bits set are equal to their versions without. Fortunately,
2392 * such ECs wouldn't be very useful anyway, because they'd equate
2393 * values not observable outside the join nest. (See
2394 * optimizer/README.)
2395 *
2396 * The first form of the quals is also the only one marked as
2397 * has_clone rather than is_clone.
2398 */
2399 allow_equivalence = (joins_so_far == NULL);
2400 has_clone = allow_equivalence;
2401 is_clone = !has_clone;
2402
2404 otherjtitem,
2405 sjinfo,
2406 root->qual_security_level,
2407 this_qualscope,
2408 this_ojscope, nonnullable_rels,
2409 bms_copy(incompatible_joins),
2410 allow_equivalence,
2411 has_clone,
2412 is_clone,
2413 NULL); /* no more postponement */
2414
2415 /*
2416 * Adjust qual nulling bits for next level up, if needed. We
2417 * don't want to put sjinfo's own bit in at all, and if we're
2418 * above sjinfo then we did it already. Here, we should mark all
2419 * Vars coming from the lower join's RHS. (Again, we are
2420 * converting a qual of the form Pbc to Pb*c, but now we are
2421 * putting back bits that were there in the parser output and were
2422 * temporarily stripped above.) Update incompatible_joins too.
2423 */
2424 if (below_sjinfo)
2425 {
2426 quals = (List *)
2427 add_nulling_relids((Node *) quals,
2428 othersj->syn_righthand,
2429 bms_make_singleton(othersj->ojrelid));
2430 incompatible_joins = bms_del_member(incompatible_joins,
2431 othersj->ojrelid);
2432 }
2433
2434 /* ... and track joins processed so far */
2435 joins_so_far = bms_add_member(joins_so_far, othersj->ojrelid);
2436 }
2437 }
2438 else
2439 {
2440 /* No commutation possible, just process the postponed clauses */
2442 jtitem,
2443 sjinfo,
2444 root->qual_security_level,
2445 qualscope,
2446 ojscope, nonnullable_rels,
2447 NULL, /* incompatible_relids */
2448 true, /* allow_equivalence */
2449 false, false, /* not clones */
2450 NULL); /* no more postponement */
2451 }
2452}
2453
2454
2455/*****************************************************************************
2456 *
2457 * QUALIFICATIONS
2458 *
2459 *****************************************************************************/
2460
2461/*
2462 * distribute_quals_to_rels
2463 * Convenience routine to apply distribute_qual_to_rels to each element
2464 * of an AND'ed list of clauses.
2465 */
2466static void
2468 JoinTreeItem *jtitem,
2470 Index security_level,
2472 Relids ojscope,
2473 Relids outerjoin_nonnullable,
2474 Relids incompatible_relids,
2475 bool allow_equivalence,
2476 bool has_clone,
2477 bool is_clone,
2478 List **postponed_oj_qual_list)
2479{
2480 ListCell *lc;
2481
2482 foreach(lc, clauses)
2483 {
2484 Node *clause = (Node *) lfirst(lc);
2485
2487 jtitem,
2488 sjinfo,
2489 security_level,
2490 qualscope,
2491 ojscope,
2492 outerjoin_nonnullable,
2493 incompatible_relids,
2494 allow_equivalence,
2495 has_clone,
2496 is_clone,
2497 postponed_oj_qual_list);
2498 }
2499}
2500
2501/*
2502 * distribute_qual_to_rels
2503 * Add clause information to either the baserestrictinfo or joininfo list
2504 * (depending on whether the clause is a join) of each base relation
2505 * mentioned in the clause. A RestrictInfo node is created and added to
2506 * the appropriate list for each rel. Alternatively, if the clause uses a
2507 * mergejoinable operator, enter its left- and right-side expressions into
2508 * the query's EquivalenceClasses.
2509 *
2510 * In some cases, quals will be added to parent jtitems' lateral_clauses
2511 * or to postponed_oj_qual_list instead of being processed right away.
2512 * These will be dealt with in later calls of deconstruct_distribute.
2513 *
2514 * 'clause': the qual clause to be distributed
2515 * 'jtitem': the JoinTreeItem for the containing jointree node
2516 * 'sjinfo': join's SpecialJoinInfo (NULL for an inner join or WHERE clause)
2517 * 'security_level': security_level to assign to the qual
2518 * 'qualscope': set of base+OJ rels the qual's syntactic scope covers
2519 * 'ojscope': NULL if not an outer-join qual, else the minimum set of base+OJ
2520 * rels needed to form this join
2521 * 'outerjoin_nonnullable': NULL if not an outer-join qual, else the set of
2522 * base+OJ rels appearing on the outer (nonnullable) side of the join
2523 * (for FULL JOIN this includes both sides of the join, and must in fact
2524 * equal qualscope)
2525 * 'incompatible_relids': the set of outer-join relid(s) that must not be
2526 * computed below this qual. We only bother to compute this for
2527 * "clone" quals, otherwise it can be left NULL.
2528 * 'allow_equivalence': true if it's okay to convert clause into an
2529 * EquivalenceClass
2530 * 'has_clone': has_clone property to assign to the qual
2531 * 'is_clone': is_clone property to assign to the qual
2532 * 'postponed_oj_qual_list': if not NULL, non-degenerate outer join clauses
2533 * should be added to this list instead of being processed (list entries
2534 * are just the bare clauses)
2535 *
2536 * 'qualscope' identifies what level of JOIN the qual came from syntactically.
2537 * 'ojscope' is needed if we decide to force the qual up to the outer-join
2538 * level, which will be ojscope not necessarily qualscope.
2539 *
2540 * At the time this is called, root->join_info_list must contain entries for
2541 * at least those special joins that are syntactically below this qual.
2542 * (We now need that only for detection of redundant IS NULL quals.)
2543 */
2544static void
2546 JoinTreeItem *jtitem,
2548 Index security_level,
2550 Relids ojscope,
2551 Relids outerjoin_nonnullable,
2552 Relids incompatible_relids,
2553 bool allow_equivalence,
2554 bool has_clone,
2555 bool is_clone,
2556 List **postponed_oj_qual_list)
2557{
2558 Relids relids;
2559 bool is_pushed_down;
2560 bool pseudoconstant = false;
2561 bool maybe_equivalence;
2562 bool maybe_outer_join;
2563 RestrictInfo *restrictinfo;
2564
2565 /*
2566 * Retrieve all relids mentioned within the clause.
2567 */
2568 relids = pull_varnos(root, clause);
2569
2570 /*
2571 * In ordinary SQL, a WHERE or JOIN/ON clause can't reference any rels
2572 * that aren't within its syntactic scope; however, if we pulled up a
2573 * LATERAL subquery then we might find such references in quals that have
2574 * been pulled up. We need to treat such quals as belonging to the join
2575 * level that includes every rel they reference. Although we could make
2576 * pull_up_subqueries() place such quals correctly to begin with, it's
2577 * easier to handle it here. When we find a clause that contains Vars
2578 * outside its syntactic scope, locate the nearest parent join level that
2579 * includes all the required rels and add the clause to that level's
2580 * lateral_clauses list. We'll process it when we reach that join level.
2581 */
2582 if (!bms_is_subset(relids, qualscope))
2583 {
2584 JoinTreeItem *pitem;
2585
2586 Assert(root->hasLateralRTEs); /* shouldn't happen otherwise */
2587 Assert(sjinfo == NULL); /* mustn't postpone past outer join */
2588 for (pitem = jtitem->jti_parent; pitem; pitem = pitem->jti_parent)
2589 {
2590 if (bms_is_subset(relids, pitem->qualscope))
2591 {
2592 pitem->lateral_clauses = lappend(pitem->lateral_clauses,
2593 clause);
2594 return;
2595 }
2596
2597 /*
2598 * We should not be postponing any quals past an outer join. If
2599 * this Assert fires, pull_up_subqueries() messed up.
2600 */
2601 Assert(pitem->sjinfo == NULL);
2602 }
2603 elog(ERROR, "failed to postpone qual containing lateral reference");
2604 }
2605
2606 /*
2607 * If it's an outer-join clause, also check that relids is a subset of
2608 * ojscope. (This should not fail if the syntactic scope check passed.)
2609 */
2610 if (ojscope && !bms_is_subset(relids, ojscope))
2611 elog(ERROR, "JOIN qualification cannot refer to other relations");
2612
2613 /*
2614 * If the clause is variable-free, our normal heuristic for pushing it
2615 * down to just the mentioned rels doesn't work, because there are none.
2616 *
2617 * If the clause is an outer-join clause, we must force it to the OJ's
2618 * semantic level to preserve semantics.
2619 *
2620 * Otherwise, when the clause contains volatile functions, we force it to
2621 * be evaluated at its original syntactic level. This preserves the
2622 * expected semantics.
2623 *
2624 * When the clause contains no volatile functions either, it is actually a
2625 * pseudoconstant clause that will not change value during any one
2626 * execution of the plan, and hence can be used as a one-time qual in a
2627 * gating Result plan node. We put such a clause into the regular
2628 * RestrictInfo lists for the moment, but eventually createplan.c will
2629 * pull it out and make a gating Result node immediately above whatever
2630 * plan node the pseudoconstant clause is assigned to. It's usually best
2631 * to put a gating node as high in the plan tree as possible.
2632 */
2633 if (bms_is_empty(relids))
2634 {
2635 if (ojscope)
2636 {
2637 /* clause is attached to outer join, eval it there */
2638 relids = bms_copy(ojscope);
2639 /* mustn't use as gating qual, so don't mark pseudoconstant */
2640 }
2641 else if (contain_volatile_functions(clause))
2642 {
2643 /* eval at original syntactic level */
2644 relids = bms_copy(qualscope);
2645 /* again, can't mark pseudoconstant */
2646 }
2647 else
2648 {
2649 /*
2650 * If we are in the top-level join domain, we can push the qual to
2651 * the top of the plan tree. Otherwise, be conservative and eval
2652 * it at original syntactic level. (Ideally we'd push it to the
2653 * top of the current join domain in all cases, but that causes
2654 * problems if we later rearrange outer-join evaluation order.
2655 * Pseudoconstant quals below the top level are a pretty odd case,
2656 * so it's not clear that it's worth working hard on.)
2657 */
2658 if (jtitem->jdomain == (JoinDomain *) linitial(root->join_domains))
2659 relids = bms_copy(jtitem->jdomain->jd_relids);
2660 else
2661 relids = bms_copy(qualscope);
2662 /* mark as gating qual */
2663 pseudoconstant = true;
2664 /* tell createplan.c to check for gating quals */
2665 root->hasPseudoConstantQuals = true;
2666 }
2667 }
2668
2669 /*----------
2670 * Check to see if clause application must be delayed by outer-join
2671 * considerations.
2672 *
2673 * A word about is_pushed_down: we mark the qual as "pushed down" if
2674 * it is (potentially) applicable at a level different from its original
2675 * syntactic level. This flag is used to distinguish OUTER JOIN ON quals
2676 * from other quals pushed down to the same joinrel. The rules are:
2677 * WHERE quals and INNER JOIN quals: is_pushed_down = true.
2678 * Non-degenerate OUTER JOIN quals: is_pushed_down = false.
2679 * Degenerate OUTER JOIN quals: is_pushed_down = true.
2680 * A "degenerate" OUTER JOIN qual is one that doesn't mention the
2681 * non-nullable side, and hence can be pushed down into the nullable side
2682 * without changing the join result. It is correct to treat it as a
2683 * regular filter condition at the level where it is evaluated.
2684 *
2685 * Note: it is not immediately obvious that a simple boolean is enough
2686 * for this: if for some reason we were to attach a degenerate qual to
2687 * its original join level, it would need to be treated as an outer join
2688 * qual there. However, this cannot happen, because all the rels the
2689 * clause mentions must be in the outer join's min_righthand, therefore
2690 * the join it needs must be formed before the outer join; and we always
2691 * attach quals to the lowest level where they can be evaluated. But
2692 * if we were ever to re-introduce a mechanism for delaying evaluation
2693 * of "expensive" quals, this area would need work.
2694 *
2695 * Note: generally, use of is_pushed_down has to go through the macro
2696 * RINFO_IS_PUSHED_DOWN, because that flag alone is not always sufficient
2697 * to tell whether a clause must be treated as pushed-down in context.
2698 * This seems like another reason why it should perhaps be rethought.
2699 *----------
2700 */
2701 if (bms_overlap(relids, outerjoin_nonnullable))
2702 {
2703 /*
2704 * The qual is attached to an outer join and mentions (some of the)
2705 * rels on the nonnullable side, so it's not degenerate. If the
2706 * caller wants to postpone handling such clauses, just add it to
2707 * postponed_oj_qual_list and return. (The work we've done up to here
2708 * will have to be redone later, but there's not much of it.)
2709 */
2710 if (postponed_oj_qual_list != NULL)
2711 {
2712 *postponed_oj_qual_list = lappend(*postponed_oj_qual_list, clause);
2713 return;
2714 }
2715
2716 /*
2717 * We can't use such a clause to deduce equivalence (the left and
2718 * right sides might be unequal above the join because one of them has
2719 * gone to NULL) ... but we might be able to use it for more limited
2720 * deductions, if it is mergejoinable. So consider adding it to the
2721 * lists of set-aside outer-join clauses.
2722 */
2723 is_pushed_down = false;
2724 maybe_equivalence = false;
2725 maybe_outer_join = true;
2726
2727 /*
2728 * Now force the qual to be evaluated exactly at the level of joining
2729 * corresponding to the outer join. We cannot let it get pushed down
2730 * into the nonnullable side, since then we'd produce no output rows,
2731 * rather than the intended single null-extended row, for any
2732 * nonnullable-side rows failing the qual.
2733 */
2734 Assert(ojscope);
2735 relids = ojscope;
2736 Assert(!pseudoconstant);
2737 }
2738 else
2739 {
2740 /*
2741 * Normal qual clause or degenerate outer-join clause. Either way, we
2742 * can mark it as pushed-down.
2743 */
2744 is_pushed_down = true;
2745
2746 /*
2747 * It's possible that this is an IS NULL clause that's redundant with
2748 * a lower antijoin; if so we can just discard it. We need not test
2749 * in any of the other cases, because this will only be possible for
2750 * pushed-down clauses.
2751 */
2753 return;
2754
2755 /* Feed qual to the equivalence machinery, if allowed by caller */
2756 maybe_equivalence = allow_equivalence;
2757
2758 /*
2759 * Since it doesn't mention the LHS, it's certainly not useful as a
2760 * set-aside OJ clause, even if it's in an OJ.
2761 */
2762 maybe_outer_join = false;
2763 }
2764
2765 /*
2766 * Build the RestrictInfo node itself.
2767 */
2768 restrictinfo = make_restrictinfo(root,
2769 (Expr *) clause,
2770 is_pushed_down,
2771 has_clone,
2772 is_clone,
2773 pseudoconstant,
2774 security_level,
2775 relids,
2776 incompatible_relids,
2777 outerjoin_nonnullable);
2778
2779 /*
2780 * If it's a join clause, add vars used in the clause to targetlists of
2781 * their relations, so that they will be emitted by the plan nodes that
2782 * scan those relations (else they won't be available at the join node!).
2783 *
2784 * Normally we mark the vars as needed at the join identified by "relids".
2785 * However, if this is a clone clause then ignore the outer-join relids in
2786 * that set. Otherwise, vars appearing in a cloned clause would end up
2787 * marked as having to propagate to the highest one of the commuting
2788 * joins, which would often be an overestimate. For such clauses, correct
2789 * var propagation is ensured by making ojscope include input rels from
2790 * both sides of the join.
2791 *
2792 * See also rebuild_joinclause_attr_needed, which has to partially repeat
2793 * this work after removal of an outer join.
2794 *
2795 * Note: if the clause gets absorbed into an EquivalenceClass then this
2796 * may be unnecessary, but for now we have to do it to cover the case
2797 * where the EC becomes ec_broken and we end up reinserting the original
2798 * clauses into the plan.
2799 */
2800 if (bms_membership(relids) == BMS_MULTIPLE)
2801 {
2802 List *vars = pull_var_clause(clause,
2806 Relids where_needed;
2807
2808 if (is_clone)
2809 where_needed = bms_intersect(relids, root->all_baserels);
2810 else
2811 where_needed = relids;
2812 add_vars_to_targetlist(root, vars, where_needed);
2813 list_free(vars);
2814 }
2815
2816 /*
2817 * We check "mergejoinability" of every clause, not only join clauses,
2818 * because we want to know about equivalences between vars of the same
2819 * relation, or between vars and consts.
2820 */
2821 check_mergejoinable(restrictinfo);
2822
2823 /*
2824 * If it is a true equivalence clause, send it to the EquivalenceClass
2825 * machinery. We do *not* attach it directly to any restriction or join
2826 * lists. The EC code will propagate it to the appropriate places later.
2827 *
2828 * If the clause has a mergejoinable operator, yet isn't an equivalence
2829 * because it is an outer-join clause, the EC code may still be able to do
2830 * something with it. We add it to appropriate lists for further
2831 * consideration later. Specifically:
2832 *
2833 * If it is a left or right outer-join qualification that relates the two
2834 * sides of the outer join (no funny business like leftvar1 = leftvar2 +
2835 * rightvar), we add it to root->left_join_clauses or
2836 * root->right_join_clauses according to which side the nonnullable
2837 * variable appears on.
2838 *
2839 * If it is a full outer-join qualification, we add it to
2840 * root->full_join_clauses. (Ideally we'd discard cases that aren't
2841 * leftvar = rightvar, as we do for left/right joins, but this routine
2842 * doesn't have the info needed to do that; and the current usage of the
2843 * full_join_clauses list doesn't require that, so it's not currently
2844 * worth complicating this routine's API to make it possible.)
2845 *
2846 * If none of the above hold, pass it off to
2847 * distribute_restrictinfo_to_rels().
2848 *
2849 * In all cases, it's important to initialize the left_ec and right_ec
2850 * fields of a mergejoinable clause, so that all possibly mergejoinable
2851 * expressions have representations in EquivalenceClasses. If
2852 * process_equivalence is successful, it will take care of that;
2853 * otherwise, we have to call initialize_mergeclause_eclasses to do it.
2854 */
2855 if (restrictinfo->mergeopfamilies)
2856 {
2857 if (maybe_equivalence)
2858 {
2859 if (process_equivalence(root, &restrictinfo, jtitem->jdomain))
2860 return;
2861 /* EC rejected it, so set left_ec/right_ec the hard way ... */
2862 if (restrictinfo->mergeopfamilies) /* EC might have changed this */
2864 /* ... and fall through to distribute_restrictinfo_to_rels */
2865 }
2866 else if (maybe_outer_join && restrictinfo->can_join)
2867 {
2868 /* we need to set up left_ec/right_ec the hard way */
2870 /* now see if it should go to any outer-join lists */
2871 Assert(sjinfo != NULL);
2872 if (bms_is_subset(restrictinfo->left_relids,
2873 outerjoin_nonnullable) &&
2874 !bms_overlap(restrictinfo->right_relids,
2875 outerjoin_nonnullable))
2876 {
2877 /* we have outervar = innervar */
2879
2880 ojcinfo->rinfo = restrictinfo;
2881 ojcinfo->sjinfo = sjinfo;
2882 root->left_join_clauses = lappend(root->left_join_clauses,
2883 ojcinfo);
2884 return;
2885 }
2886 if (bms_is_subset(restrictinfo->right_relids,
2887 outerjoin_nonnullable) &&
2888 !bms_overlap(restrictinfo->left_relids,
2889 outerjoin_nonnullable))
2890 {
2891 /* we have innervar = outervar */
2893
2894 ojcinfo->rinfo = restrictinfo;
2895 ojcinfo->sjinfo = sjinfo;
2896 root->right_join_clauses = lappend(root->right_join_clauses,
2897 ojcinfo);
2898 return;
2899 }
2900 if (sjinfo->jointype == JOIN_FULL)
2901 {
2902 /* FULL JOIN (above tests cannot match in this case) */
2904
2905 ojcinfo->rinfo = restrictinfo;
2906 ojcinfo->sjinfo = sjinfo;
2907 root->full_join_clauses = lappend(root->full_join_clauses,
2908 ojcinfo);
2909 return;
2910 }
2911 /* nope, so fall through to distribute_restrictinfo_to_rels */
2912 }
2913 else
2914 {
2915 /* we still need to set up left_ec/right_ec */
2917 }
2918 }
2919
2920 /* No EC special case applies, so push it into the clause lists */
2922}
2923
2924/*
2925 * check_redundant_nullability_qual
2926 * Check to see if the qual is an IS NULL qual that is redundant with
2927 * a lower JOIN_ANTI join.
2928 *
2929 * We want to suppress redundant IS NULL quals, not so much to save cycles
2930 * as to avoid generating bogus selectivity estimates for them. So if
2931 * redundancy is detected here, distribute_qual_to_rels() just throws away
2932 * the qual.
2933 */
2934static bool
2936{
2937 Var *forced_null_var;
2938 ListCell *lc;
2939
2940 /* Check for IS NULL, and identify the Var forced to NULL */
2941 forced_null_var = find_forced_null_var(clause);
2942 if (forced_null_var == NULL)
2943 return false;
2944
2945 /*
2946 * If the Var comes from the nullable side of a lower antijoin, the IS
2947 * NULL condition is necessarily true. If it's not nulled by anything,
2948 * there is no point in searching the join_info_list. Otherwise, we need
2949 * to find out whether the nulling rel is an antijoin.
2950 */
2951 if (forced_null_var->varnullingrels == NULL)
2952 return false;
2953
2954 foreach(lc, root->join_info_list)
2955 {
2957
2958 /*
2959 * This test will not succeed if sjinfo->ojrelid is zero, which is
2960 * possible for an antijoin that was converted from a semijoin; but in
2961 * such a case the Var couldn't have come from its nullable side.
2962 */
2963 if (sjinfo->jointype == JOIN_ANTI && sjinfo->ojrelid != 0 &&
2964 bms_is_member(sjinfo->ojrelid, forced_null_var->varnullingrels))
2965 return true;
2966 }
2967
2968 return false;
2969}
2970
2971/*
2972 * add_base_clause_to_rel
2973 * Add 'restrictinfo' as a baserestrictinfo to the base relation denoted
2974 * by 'relid'. We offer some simple prechecks to try to determine if the
2975 * qual is always true, in which case we ignore it rather than add it.
2976 * If we detect the qual is always false, we replace it with
2977 * constant-FALSE.
2978 */
2979static void
2981 RestrictInfo *restrictinfo)
2982{
2983 RelOptInfo *rel = find_base_rel(root, relid);
2984 RangeTblEntry *rte = root->simple_rte_array[relid];
2985
2987
2988 /*
2989 * For inheritance parent tables, we must always record the RestrictInfo
2990 * in baserestrictinfo as is. If we were to transform or skip adding it,
2991 * then the original wouldn't be available in apply_child_basequals. Since
2992 * there are two RangeTblEntries for inheritance parents, one with
2993 * inh==true and the other with inh==false, we're still able to apply this
2994 * optimization to the inh==false one. The inh==true one is what
2995 * apply_child_basequals() sees, whereas the inh==false one is what's used
2996 * for the scan node in the final plan.
2997 *
2998 * We make an exception to this for partitioned tables. For these, we
2999 * always apply the constant-TRUE and constant-FALSE transformations. A
3000 * qual which is either of these for a partitioned table must also be that
3001 * for all of its child partitions.
3002 */
3003 if (!rte->inh || rte->relkind == RELKIND_PARTITIONED_TABLE)
3004 {
3005 /* Don't add the clause if it is always true */
3006 if (restriction_is_always_true(root, restrictinfo))
3007 return;
3008
3009 /*
3010 * Substitute the origin qual with constant-FALSE if it is provably
3011 * always false.
3012 *
3013 * Note that we need to keep the same rinfo_serial, since it is in
3014 * practice the same condition. We also need to reset the
3015 * last_rinfo_serial counter, which is essential to ensure that the
3016 * RestrictInfos for the "same" qual condition get identical serial
3017 * numbers (see deconstruct_distribute_oj_quals).
3018 */
3019 if (restriction_is_always_false(root, restrictinfo))
3020 {
3021 int save_rinfo_serial = restrictinfo->rinfo_serial;
3022 int save_last_rinfo_serial = root->last_rinfo_serial;
3023
3024 restrictinfo = make_restrictinfo(root,
3025 (Expr *) makeBoolConst(false, false),
3026 restrictinfo->is_pushed_down,
3027 restrictinfo->has_clone,
3028 restrictinfo->is_clone,
3029 restrictinfo->pseudoconstant,
3030 0, /* security_level */
3031 restrictinfo->required_relids,
3032 restrictinfo->incompatible_relids,
3033 restrictinfo->outer_relids);
3034 restrictinfo->rinfo_serial = save_rinfo_serial;
3035 root->last_rinfo_serial = save_last_rinfo_serial;
3036 }
3037 }
3038
3039 /* Add clause to rel's restriction list */
3040 rel->baserestrictinfo = lappend(rel->baserestrictinfo, restrictinfo);
3041
3042 /* Update security level info */
3044 restrictinfo->security_level);
3045}
3046
3047/*
3048 * expr_is_nonnullable
3049 * Check to see if the Expr cannot be NULL
3050 *
3051 * If the Expr is a simple Var that is defined NOT NULL and meanwhile is not
3052 * nulled by any outer joins, then we can know that it cannot be NULL.
3053 */
3054static bool
3056{
3057 RelOptInfo *rel;
3058 Var *var;
3059
3060 /* For now only check simple Vars */
3061 if (!IsA(expr, Var))
3062 return false;
3063
3064 var = (Var *) expr;
3065
3066 /* could the Var be nulled by any outer joins? */
3067 if (!bms_is_empty(var->varnullingrels))
3068 return false;
3069
3070 /* system columns cannot be NULL */
3071 if (var->varattno < 0)
3072 return true;
3073
3074 /* is the column defined NOT NULL? */
3075 rel = find_base_rel(root, var->varno);
3076 if (var->varattno > 0 &&
3078 return true;
3079
3080 return false;
3081}
3082
3083/*
3084 * restriction_is_always_true
3085 * Check to see if the RestrictInfo is always true.
3086 *
3087 * Currently we only check for NullTest quals and OR clauses that include
3088 * NullTest quals. We may extend it in the future.
3089 */
3090bool
3092 RestrictInfo *restrictinfo)
3093{
3094 /* Check for NullTest qual */
3095 if (IsA(restrictinfo->clause, NullTest))
3096 {
3097 NullTest *nulltest = (NullTest *) restrictinfo->clause;
3098
3099 /* is this NullTest an IS_NOT_NULL qual? */
3100 if (nulltest->nulltesttype != IS_NOT_NULL)
3101 return false;
3102
3103 return expr_is_nonnullable(root, nulltest->arg);
3104 }
3105
3106 /* If it's an OR, check its sub-clauses */
3107 if (restriction_is_or_clause(restrictinfo))
3108 {
3109 ListCell *lc;
3110
3111 Assert(is_orclause(restrictinfo->orclause));
3112
3113 /*
3114 * if any of the given OR branches is provably always true then the
3115 * entire condition is true.
3116 */
3117 foreach(lc, ((BoolExpr *) restrictinfo->orclause)->args)
3118 {
3119 Node *orarg = (Node *) lfirst(lc);
3120
3121 if (!IsA(orarg, RestrictInfo))
3122 continue;
3123
3125 return true;
3126 }
3127 }
3128
3129 return false;
3130}
3131
3132/*
3133 * restriction_is_always_false
3134 * Check to see if the RestrictInfo is always false.
3135 *
3136 * Currently we only check for NullTest quals and OR clauses that include
3137 * NullTest quals. We may extend it in the future.
3138 */
3139bool
3141 RestrictInfo *restrictinfo)
3142{
3143 /* Check for NullTest qual */
3144 if (IsA(restrictinfo->clause, NullTest))
3145 {
3146 NullTest *nulltest = (NullTest *) restrictinfo->clause;
3147
3148 /* is this NullTest an IS_NULL qual? */
3149 if (nulltest->nulltesttype != IS_NULL)
3150 return false;
3151
3152 return expr_is_nonnullable(root, nulltest->arg);
3153 }
3154
3155 /* If it's an OR, check its sub-clauses */
3156 if (restriction_is_or_clause(restrictinfo))
3157 {
3158 ListCell *lc;
3159
3160 Assert(is_orclause(restrictinfo->orclause));
3161
3162 /*
3163 * Currently, when processing OR expressions, we only return true when
3164 * all of the OR branches are always false. This could perhaps be
3165 * expanded to remove OR branches that are provably false. This may
3166 * be a useful thing to do as it could result in the OR being left
3167 * with a single arg. That's useful as it would allow the OR
3168 * condition to be replaced with its single argument which may allow
3169 * use of an index for faster filtering on the remaining condition.
3170 */
3171 foreach(lc, ((BoolExpr *) restrictinfo->orclause)->args)
3172 {
3173 Node *orarg = (Node *) lfirst(lc);
3174
3175 if (!IsA(orarg, RestrictInfo) ||
3177 return false;
3178 }
3179 return true;
3180 }
3181
3182 return false;
3183}
3184
3185/*
3186 * distribute_restrictinfo_to_rels
3187 * Push a completed RestrictInfo into the proper restriction or join
3188 * clause list(s).
3189 *
3190 * This is the last step of distribute_qual_to_rels() for ordinary qual
3191 * clauses. Clauses that are interesting for equivalence-class processing
3192 * are diverted to the EC machinery, but may ultimately get fed back here.
3193 */
3194void
3196 RestrictInfo *restrictinfo)
3197{
3198 Relids relids = restrictinfo->required_relids;
3199
3200 if (!bms_is_empty(relids))
3201 {
3202 int relid;
3203
3204 if (bms_get_singleton_member(relids, &relid))
3205 {
3206 /*
3207 * There is only one relation participating in the clause, so it
3208 * is a restriction clause for that relation.
3209 */
3210 add_base_clause_to_rel(root, relid, restrictinfo);
3211 }
3212 else
3213 {
3214 /*
3215 * The clause is a join clause, since there is more than one rel
3216 * in its relid set.
3217 */
3218
3219 /*
3220 * Check for hashjoinable operators. (We don't bother setting the
3221 * hashjoin info except in true join clauses.)
3222 */
3223 check_hashjoinable(restrictinfo);
3224
3225 /*
3226 * Likewise, check if the clause is suitable to be used with a
3227 * Memoize node to cache inner tuples during a parameterized
3228 * nested loop.
3229 */
3230 check_memoizable(restrictinfo);
3231
3232 /*
3233 * Add clause to the join lists of all the relevant relations.
3234 */
3235 add_join_clause_to_rels(root, restrictinfo, relids);
3236 }
3237 }
3238 else
3239 {
3240 /*
3241 * clause references no rels, and therefore we have no place to attach
3242 * it. Shouldn't get here if callers are working properly.
3243 */
3244 elog(ERROR, "cannot cope with variable-free clause");
3245 }
3246}
3247
3248/*
3249 * process_implied_equality
3250 * Create a restrictinfo item that says "item1 op item2", and push it
3251 * into the appropriate lists. (In practice opno is always a btree
3252 * equality operator.)
3253 *
3254 * "qualscope" is the nominal syntactic level to impute to the restrictinfo.
3255 * This must contain at least all the rels used in the expressions, but it
3256 * is used only to set the qual application level when both exprs are
3257 * variable-free. (Hence, it should usually match the join domain in which
3258 * the clause applies.) Otherwise the qual is applied at the lowest join
3259 * level that provides all its variables.
3260 *
3261 * "security_level" is the security level to assign to the new restrictinfo.
3262 *
3263 * "both_const" indicates whether both items are known pseudo-constant;
3264 * in this case it is worth applying eval_const_expressions() in case we
3265 * can produce constant TRUE or constant FALSE. (Otherwise it's not,
3266 * because the expressions went through eval_const_expressions already.)
3267 *
3268 * Returns the generated RestrictInfo, if any. The result will be NULL
3269 * if both_const is true and we successfully reduced the clause to
3270 * constant TRUE.
3271 *
3272 * Note: this function will copy item1 and item2, but it is caller's
3273 * responsibility to make sure that the Relids parameters are fresh copies
3274 * not shared with other uses.
3275 *
3276 * Note: we do not do initialize_mergeclause_eclasses() here. It is
3277 * caller's responsibility that left_ec/right_ec be set as necessary.
3278 */
3281 Oid opno,
3282 Oid collation,
3283 Expr *item1,
3284 Expr *item2,
3286 Index security_level,
3287 bool both_const)
3288{
3289 RestrictInfo *restrictinfo;
3290 Node *clause;
3291 Relids relids;
3292 bool pseudoconstant = false;
3293
3294 /*
3295 * Build the new clause. Copy to ensure it shares no substructure with
3296 * original (this is necessary in case there are subselects in there...)
3297 */
3298 clause = (Node *) make_opclause(opno,
3299 BOOLOID, /* opresulttype */
3300 false, /* opretset */
3301 copyObject(item1),
3302 copyObject(item2),
3303 InvalidOid,
3304 collation);
3305
3306 /* If both constant, try to reduce to a boolean constant. */
3307 if (both_const)
3308 {
3309 clause = eval_const_expressions(root, clause);
3310
3311 /* If we produced const TRUE, just drop the clause */
3312 if (clause && IsA(clause, Const))
3313 {
3314 Const *cclause = (Const *) clause;
3315
3316 Assert(cclause->consttype == BOOLOID);
3317 if (!cclause->constisnull && DatumGetBool(cclause->constvalue))
3318 return NULL;
3319 }
3320 }
3321
3322 /*
3323 * The rest of this is a very cut-down version of distribute_qual_to_rels.
3324 * We can skip most of the work therein, but there are a couple of special
3325 * cases we still have to handle.
3326 *
3327 * Retrieve all relids mentioned within the possibly-simplified clause.
3328 */
3329 relids = pull_varnos(root, clause);
3330 Assert(bms_is_subset(relids, qualscope));
3331
3332 /*
3333 * If the clause is variable-free, our normal heuristic for pushing it
3334 * down to just the mentioned rels doesn't work, because there are none.
3335 * Apply it as a gating qual at the appropriate level (see comments for
3336 * get_join_domain_min_rels).
3337 */
3338 if (bms_is_empty(relids))
3339 {
3340 /* eval at join domain's safe level */
3342 /* mark as gating qual */
3343 pseudoconstant = true;
3344 /* tell createplan.c to check for gating quals */
3345 root->hasPseudoConstantQuals = true;
3346 }
3347
3348 /*
3349 * Build the RestrictInfo node itself.
3350 */
3351 restrictinfo = make_restrictinfo(root,
3352 (Expr *) clause,
3353 true, /* is_pushed_down */
3354 false, /* !has_clone */
3355 false, /* !is_clone */
3356 pseudoconstant,
3357 security_level,
3358 relids,
3359 NULL, /* incompatible_relids */
3360 NULL); /* outer_relids */
3361
3362 /*
3363 * If it's a join clause, add vars used in the clause to targetlists of
3364 * their relations, so that they will be emitted by the plan nodes that
3365 * scan those relations (else they won't be available at the join node!).
3366 *
3367 * Typically, we'd have already done this when the component expressions
3368 * were first seen by distribute_qual_to_rels; but it is possible that
3369 * some of the Vars could have missed having that done because they only
3370 * appeared in single-relation clauses originally. So do it here for
3371 * safety.
3372 *
3373 * See also rebuild_joinclause_attr_needed, which has to partially repeat
3374 * this work after removal of an outer join. (Since we will put this
3375 * clause into the joininfo lists, that function needn't do any extra work
3376 * to find it.)
3377 */
3378 if (bms_membership(relids) == BMS_MULTIPLE)
3379 {
3380 List *vars = pull_var_clause(clause,
3384
3386 list_free(vars);
3387 }
3388
3389 /*
3390 * Check mergejoinability. This will usually succeed, since the op came
3391 * from an EquivalenceClass; but we could have reduced the original clause
3392 * to a constant.
3393 */
3394 check_mergejoinable(restrictinfo);
3395
3396 /*
3397 * Note we don't do initialize_mergeclause_eclasses(); the caller can
3398 * handle that much more cheaply than we can. It's okay to call
3399 * distribute_restrictinfo_to_rels() before that happens.
3400 */
3401
3402 /*
3403 * Push the new clause into all the appropriate restrictinfo lists.
3404 */
3406
3407 return restrictinfo;
3408}
3409
3410/*
3411 * build_implied_join_equality --- build a RestrictInfo for a derived equality
3412 *
3413 * This overlaps the functionality of process_implied_equality(), but we
3414 * must not push the RestrictInfo into the joininfo tree.
3415 *
3416 * Note: this function will copy item1 and item2, but it is caller's
3417 * responsibility to make sure that the Relids parameters are fresh copies
3418 * not shared with other uses.
3419 *
3420 * Note: we do not do initialize_mergeclause_eclasses() here. It is
3421 * caller's responsibility that left_ec/right_ec be set as necessary.
3422 */
3425 Oid opno,
3426 Oid collation,
3427 Expr *item1,
3428 Expr *item2,
3430 Index security_level)
3431{
3432 RestrictInfo *restrictinfo;
3433 Expr *clause;
3434
3435 /*
3436 * Build the new clause. Copy to ensure it shares no substructure with
3437 * original (this is necessary in case there are subselects in there...)
3438 */
3439 clause = make_opclause(opno,
3440 BOOLOID, /* opresulttype */
3441 false, /* opretset */
3442 copyObject(item1),
3443 copyObject(item2),
3444 InvalidOid,
3445 collation);
3446
3447 /*
3448 * Build the RestrictInfo node itself.
3449 */
3450 restrictinfo = make_restrictinfo(root,
3451 clause,
3452 true, /* is_pushed_down */
3453 false, /* !has_clone */
3454 false, /* !is_clone */
3455 false, /* pseudoconstant */
3456 security_level, /* security_level */
3457 qualscope, /* required_relids */
3458 NULL, /* incompatible_relids */
3459 NULL); /* outer_relids */
3460
3461 /* Set mergejoinability/hashjoinability flags */
3462 check_mergejoinable(restrictinfo);
3463 check_hashjoinable(restrictinfo);
3464 check_memoizable(restrictinfo);
3465
3466 return restrictinfo;
3467}
3468
3469/*
3470 * get_join_domain_min_rels
3471 * Identify the appropriate join level for derived quals belonging
3472 * to the join domain with the given relids.
3473 *
3474 * When we derive a pseudoconstant (Var-free) clause from an EquivalenceClass,
3475 * we'd ideally apply the clause at the top level of the EC's join domain.
3476 * However, if there are any outer joins inside that domain that get commuted
3477 * with joins outside it, that leads to not finding a correct place to apply
3478 * the clause. Instead, remove any lower outer joins from the relid set,
3479 * and apply the clause to just the remaining rels. This still results in a
3480 * correct answer, since if the clause produces FALSE then the LHS of these
3481 * joins will be empty leading to an empty join result.
3482 *
3483 * However, there's no need to remove outer joins if this is the top-level
3484 * join domain of the query, since then there's nothing else to commute with.
3485 *
3486 * Note: it's tempting to use this in distribute_qual_to_rels where it's
3487 * dealing with pseudoconstant quals; but we can't because the necessary
3488 * SpecialJoinInfos aren't all formed at that point.
3489 *
3490 * The result is always freshly palloc'd; we do not modify domain_relids.
3491 */
3492static Relids
3494{
3495 Relids result = bms_copy(domain_relids);
3496 ListCell *lc;
3497
3498 /* Top-level join domain? */
3499 if (bms_equal(result, root->all_query_rels))
3500 return result;
3501
3502 /* Nope, look for lower outer joins that could potentially commute out */
3503 foreach(lc, root->join_info_list)
3504 {
3506
3507 if (sjinfo->jointype == JOIN_LEFT &&
3508 bms_is_member(sjinfo->ojrelid, result))
3509 {
3510 result = bms_del_member(result, sjinfo->ojrelid);
3511 result = bms_del_members(result, sjinfo->syn_righthand);
3512 }
3513 }
3514 return result;
3515}
3516
3517
3518/*
3519 * rebuild_joinclause_attr_needed
3520 * Put back attr_needed bits for Vars/PHVs needed for join clauses.
3521 *
3522 * This is used to rebuild attr_needed/ph_needed sets after removal of a
3523 * useless outer join. It should match what distribute_qual_to_rels did,
3524 * except that we call add_vars_to_attr_needed not add_vars_to_targetlist.
3525 */
3526void
3528{
3529 /*
3530 * We must examine all join clauses, but there's no value in processing
3531 * any join clause more than once. So it's slightly annoying that we have
3532 * to find them via the per-base-relation joininfo lists. Avoid duplicate
3533 * processing by tracking the rinfo_serial numbers of join clauses we've
3534 * already seen. (This doesn't work for is_clone clauses, so we must
3535 * waste effort on them.)
3536 */
3537 Bitmapset *seen_serials = NULL;
3538 Index rti;
3539
3540 /* Scan all baserels for join clauses */
3541 for (rti = 1; rti < root->simple_rel_array_size; rti++)
3542 {
3543 RelOptInfo *brel = root->simple_rel_array[rti];
3544 ListCell *lc;
3545
3546 if (brel == NULL)
3547 continue;
3548 if (brel->reloptkind != RELOPT_BASEREL)
3549 continue;
3550
3551 foreach(lc, brel->joininfo)
3552 {
3553 RestrictInfo *rinfo = (RestrictInfo *) lfirst(lc);
3554 Relids relids = rinfo->required_relids;
3555
3556 if (!rinfo->is_clone) /* else serial number is not unique */
3557 {
3558 if (bms_is_member(rinfo->rinfo_serial, seen_serials))
3559 continue; /* saw it already */
3560 seen_serials = bms_add_member(seen_serials,
3561 rinfo->rinfo_serial);
3562 }
3563
3564 if (bms_membership(relids) == BMS_MULTIPLE)
3565 {
3566 List *vars = pull_var_clause((Node *) rinfo->clause,
3570 Relids where_needed;
3571
3572 if (rinfo->is_clone)
3573 where_needed = bms_intersect(relids, root->all_baserels);
3574 else
3575 where_needed = relids;
3576 add_vars_to_attr_needed(root, vars, where_needed);
3577 list_free(vars);
3578 }
3579 }
3580 }
3581}
3582
3583
3584/*
3585 * match_foreign_keys_to_quals
3586 * Match foreign-key constraints to equivalence classes and join quals
3587 *
3588 * The idea here is to see which query join conditions match equality
3589 * constraints of a foreign-key relationship. For such join conditions,
3590 * we can use the FK semantics to make selectivity estimates that are more
3591 * reliable than estimating from statistics, especially for multiple-column
3592 * FKs, where the normal assumption of independent conditions tends to fail.
3593 *
3594 * In this function we annotate the ForeignKeyOptInfos in root->fkey_list
3595 * with info about which eclasses and join qual clauses they match, and
3596 * discard any ForeignKeyOptInfos that are irrelevant for the query.
3597 */
3598void
3600{
3601 List *newlist = NIL;
3602 ListCell *lc;
3603
3604 foreach(lc, root->fkey_list)
3605 {
3606 ForeignKeyOptInfo *fkinfo = (ForeignKeyOptInfo *) lfirst(lc);
3607 RelOptInfo *con_rel;
3608 RelOptInfo *ref_rel;
3609 int colno;
3610
3611 /*
3612 * Either relid might identify a rel that is in the query's rtable but
3613 * isn't referenced by the jointree, or has been removed by join
3614 * removal, so that it won't have a RelOptInfo. Hence don't use
3615 * find_base_rel() here. We can ignore such FKs.
3616 */
3617 if (fkinfo->con_relid >= root->simple_rel_array_size ||
3618 fkinfo->ref_relid >= root->simple_rel_array_size)
3619 continue; /* just paranoia */
3620 con_rel = root->simple_rel_array[fkinfo->con_relid];
3621 if (con_rel == NULL)
3622 continue;
3623 ref_rel = root->simple_rel_array[fkinfo->ref_relid];
3624 if (ref_rel == NULL)
3625 continue;
3626
3627 /*
3628 * Ignore FK unless both rels are baserels. This gets rid of FKs that
3629 * link to inheritance child rels (otherrels).
3630 */
3631 if (con_rel->reloptkind != RELOPT_BASEREL ||
3632 ref_rel->reloptkind != RELOPT_BASEREL)
3633 continue;
3634
3635 /*
3636 * Scan the columns and try to match them to eclasses and quals.
3637 *
3638 * Note: for simple inner joins, any match should be in an eclass.
3639 * "Loose" quals that syntactically match an FK equality must have
3640 * been rejected for EC status because they are outer-join quals or
3641 * similar. We can still consider them to match the FK.
3642 */
3643 for (colno = 0; colno < fkinfo->nkeys; colno++)
3644 {
3645 EquivalenceClass *ec;
3646 AttrNumber con_attno,
3647 ref_attno;
3648 Oid fpeqop;
3649 ListCell *lc2;
3650
3651 ec = match_eclasses_to_foreign_key_col(root, fkinfo, colno);
3652 /* Don't bother looking for loose quals if we got an EC match */
3653 if (ec != NULL)
3654 {
3655 fkinfo->nmatched_ec++;
3656 if (ec->ec_has_const)
3657 fkinfo->nconst_ec++;
3658 continue;
3659 }
3660
3661 /*
3662 * Scan joininfo list for relevant clauses. Either rel's joininfo
3663 * list would do equally well; we use con_rel's.
3664 */
3665 con_attno = fkinfo->conkey[colno];
3666 ref_attno = fkinfo->confkey[colno];
3667 fpeqop = InvalidOid; /* we'll look this up only if needed */
3668
3669 foreach(lc2, con_rel->joininfo)
3670 {
3671 RestrictInfo *rinfo = (RestrictInfo *) lfirst(lc2);
3672 OpExpr *clause = (OpExpr *) rinfo->clause;
3673 Var *leftvar;
3674 Var *rightvar;
3675
3676 /* Only binary OpExprs are useful for consideration */
3677 if (!IsA(clause, OpExpr) ||
3678 list_length(clause->args) != 2)
3679 continue;
3680 leftvar = (Var *) get_leftop((Expr *) clause);
3681 rightvar = (Var *) get_rightop((Expr *) clause);
3682
3683 /* Operands must be Vars, possibly with RelabelType */
3684 while (leftvar && IsA(leftvar, RelabelType))
3685 leftvar = (Var *) ((RelabelType *) leftvar)->arg;
3686 if (!(leftvar && IsA(leftvar, Var)))
3687 continue;
3688 while (rightvar && IsA(rightvar, RelabelType))
3689 rightvar = (Var *) ((RelabelType *) rightvar)->arg;
3690 if (!(rightvar && IsA(rightvar, Var)))
3691 continue;
3692
3693 /* Now try to match the vars to the current foreign key cols */
3694 if (fkinfo->ref_relid == leftvar->varno &&
3695 ref_attno == leftvar->varattno &&
3696 fkinfo->con_relid == rightvar->varno &&
3697 con_attno == rightvar->varattno)
3698 {
3699 /* Vars match, but is it the right operator? */
3700 if (clause->opno == fkinfo->conpfeqop[colno])
3701 {
3702 fkinfo->rinfos[colno] = lappend(fkinfo->rinfos[colno],
3703 rinfo);
3704 fkinfo->nmatched_ri++;
3705 }
3706 }
3707 else if (fkinfo->ref_relid == rightvar->varno &&
3708 ref_attno == rightvar->varattno &&
3709 fkinfo->con_relid == leftvar->varno &&
3710 con_attno == leftvar->varattno)
3711 {
3712 /*
3713 * Reverse match, must check commutator operator. Look it
3714 * up if we didn't already. (In the worst case we might
3715 * do multiple lookups here, but that would require an FK
3716 * equality operator without commutator, which is
3717 * unlikely.)
3718 */
3719 if (!OidIsValid(fpeqop))
3720 fpeqop = get_commutator(fkinfo->conpfeqop[colno]);
3721 if (clause->opno == fpeqop)
3722 {
3723 fkinfo->rinfos[colno] = lappend(fkinfo->rinfos[colno],
3724 rinfo);
3725 fkinfo->nmatched_ri++;
3726 }
3727 }
3728 }
3729 /* If we found any matching loose quals, count col as matched */
3730 if (fkinfo->rinfos[colno])
3731 fkinfo->nmatched_rcols++;
3732 }
3733
3734 /*
3735 * Currently, we drop multicolumn FKs that aren't fully matched to the
3736 * query. Later we might figure out how to derive some sort of
3737 * estimate from them, in which case this test should be weakened to
3738 * "if ((fkinfo->nmatched_ec + fkinfo->nmatched_rcols) > 0)".
3739 */
3740 if ((fkinfo->nmatched_ec + fkinfo->nmatched_rcols) == fkinfo->nkeys)
3741 newlist = lappend(newlist, fkinfo);
3742 }
3743 /* Replace fkey_list, thereby discarding any useless entries */
3744 root->fkey_list = newlist;
3745}
3746
3747
3748/*****************************************************************************
3749 *
3750 * CHECKS FOR MERGEJOINABLE AND HASHJOINABLE CLAUSES
3751 *
3752 *****************************************************************************/
3753
3754/*
3755 * check_mergejoinable
3756 * If the restrictinfo's clause is mergejoinable, set the mergejoin
3757 * info fields in the restrictinfo.
3758 *
3759 * Currently, we support mergejoin for binary opclauses where
3760 * the operator is a mergejoinable operator. The arguments can be
3761 * anything --- as long as there are no volatile functions in them.
3762 */
3763static void
3765{
3766 Expr *clause = restrictinfo->clause;
3767 Oid opno;
3768 Node *leftarg;
3769
3770 if (restrictinfo->pseudoconstant)
3771 return;
3772 if (!is_opclause(clause))
3773 return;
3774 if (list_length(((OpExpr *) clause)->args) != 2)
3775 return;
3776
3777 opno = ((OpExpr *) clause)->opno;
3778 leftarg = linitial(((OpExpr *) clause)->args);
3779
3780 if (op_mergejoinable(opno, exprType(leftarg)) &&
3781 !contain_volatile_functions((Node *) restrictinfo))
3782 restrictinfo->mergeopfamilies = get_mergejoin_opfamilies(opno);
3783
3784 /*
3785 * Note: op_mergejoinable is just a hint; if we fail to find the operator
3786 * in any btree opfamilies, mergeopfamilies remains NIL and so the clause
3787 * is not treated as mergejoinable.
3788 */
3789}
3790
3791/*
3792 * check_hashjoinable
3793 * If the restrictinfo's clause is hashjoinable, set the hashjoin
3794 * info fields in the restrictinfo.
3795 *
3796 * Currently, we support hashjoin for binary opclauses where
3797 * the operator is a hashjoinable operator. The arguments can be
3798 * anything --- as long as there are no volatile functions in them.
3799 */
3800static void
3802{
3803 Expr *clause = restrictinfo->clause;
3804 Oid opno;
3805 Node *leftarg;
3806
3807 if (restrictinfo->pseudoconstant)
3808 return;
3809 if (!is_opclause(clause))
3810 return;
3811 if (list_length(((OpExpr *) clause)->args) != 2)
3812 return;
3813
3814 opno = ((OpExpr *) clause)->opno;
3815 leftarg = linitial(((OpExpr *) clause)->args);
3816
3817 if (op_hashjoinable(opno, exprType(leftarg)) &&
3818 !contain_volatile_functions((Node *) restrictinfo))
3819 restrictinfo->hashjoinoperator = opno;
3820}
3821
3822/*
3823 * check_memoizable
3824 * If the restrictinfo's clause is suitable to be used for a Memoize node,
3825 * set the left_hasheqoperator and right_hasheqoperator to the hash equality
3826 * operator that will be needed during caching.
3827 */
3828static void
3830{
3831 TypeCacheEntry *typentry;
3832 Expr *clause = restrictinfo->clause;
3833 Oid lefttype;
3834 Oid righttype;
3835
3836 if (restrictinfo->pseudoconstant)
3837 return;
3838 if (!is_opclause(clause))
3839 return;
3840 if (list_length(((OpExpr *) clause)->args) != 2)
3841 return;
3842
3843 lefttype = exprType(linitial(((OpExpr *) clause)->args));
3844
3845 typentry = lookup_type_cache(lefttype, TYPECACHE_HASH_PROC |
3847
3848 if (OidIsValid(typentry->hash_proc) && OidIsValid(typentry->eq_opr))
3849 restrictinfo->left_hasheqoperator = typentry->eq_opr;
3850
3851 righttype = exprType(lsecond(((OpExpr *) clause)->args));
3852
3853 /*
3854 * Lookup the right type, unless it's the same as the left type, in which
3855 * case typentry is already pointing to the required TypeCacheEntry.
3856 */
3857 if (lefttype != righttype)
3858 typentry = lookup_type_cache(righttype, TYPECACHE_HASH_PROC |
3860
3861 if (OidIsValid(typentry->hash_proc) && OidIsValid(typentry->eq_opr))
3862 restrictinfo->right_hasheqoperator = typentry->eq_opr;
3863}
int16 AttrNumber
Definition: attnum.h:21
Bitmapset * bms_difference(const Bitmapset *a, const Bitmapset *b)
Definition: bitmapset.c:346
Bitmapset * bms_make_singleton(int x)
Definition: bitmapset.c:216
Bitmapset * bms_int_members(Bitmapset *a, const Bitmapset *b)
Definition: bitmapset.c:1109
Bitmapset * bms_intersect(const Bitmapset *a, const Bitmapset *b)
Definition: bitmapset.c:292
bool bms_equal(const Bitmapset *a, const Bitmapset *b)
Definition: bitmapset.c:142
BMS_Comparison bms_subset_compare(const Bitmapset *a, const Bitmapset *b)
Definition: bitmapset.c:445
int bms_next_member(const Bitmapset *a, int prevbit)
Definition: bitmapset.c:1306
Bitmapset * bms_del_members(Bitmapset *a, const Bitmapset *b)
Definition: bitmapset.c:1161
Bitmapset * bms_del_member(Bitmapset *a, int x)
Definition: bitmapset.c:868
bool bms_is_subset(const Bitmapset *a, const Bitmapset *b)
Definition: bitmapset.c:412
bool bms_is_member(int x, const Bitmapset *a)
Definition: bitmapset.c:510
Bitmapset * bms_add_member(Bitmapset *a, int x)
Definition: bitmapset.c:815
Bitmapset * bms_add_members(Bitmapset *a, const Bitmapset *b)
Definition: bitmapset.c:917
Bitmapset * bms_union(const Bitmapset *a, const Bitmapset *b)
Definition: bitmapset.c:251
BMS_Membership bms_membership(const Bitmapset *a)
Definition: bitmapset.c:781
bool bms_overlap(const Bitmapset *a, const Bitmapset *b)
Definition: bitmapset.c:582
bool bms_get_singleton_member(const Bitmapset *a, int *member)
Definition: bitmapset.c:715
Bitmapset * bms_copy(const Bitmapset *a)
Definition: bitmapset.c:122
#define bms_is_empty(a)
Definition: bitmapset.h:118
@ BMS_SUBSET1
Definition: bitmapset.h:63
@ BMS_SINGLETON
Definition: bitmapset.h:72
@ BMS_MULTIPLE
Definition: bitmapset.h:73
#define PG_INT32_MAX
Definition: c.h:546
#define Min(x, y)
Definition: c.h:961
#define Assert(condition)
Definition: c.h:815
int32_t int32
Definition: c.h:484
unsigned int Index
Definition: c.h:571
#define OidIsValid(objectId)
Definition: c.h:732
Var * find_forced_null_var(Node *node)
Definition: clauses.c:1977
Node * eval_const_expressions(PlannerInfo *root, Node *node)
Definition: clauses.c:2254
Relids find_nonnullable_rels(Node *clause)
Definition: clauses.c:1456
bool contain_volatile_functions(Node *clause)
Definition: clauses.c:537
bool enable_hashagg
Definition: costsize.c:152
int errcode(int sqlerrcode)
Definition: elog.c:853
int errmsg(const char *fmt,...)
Definition: elog.c:1070
#define ERROR
Definition: elog.h:39
#define elog(elevel,...)
Definition: elog.h:225
#define ereport(elevel,...)
Definition: elog.h:149
bool process_equivalence(PlannerInfo *root, RestrictInfo **p_restrictinfo, JoinDomain *jdomain)
Definition: equivclass.c:117
EquivalenceClass * match_eclasses_to_foreign_key_col(PlannerInfo *root, ForeignKeyOptInfo *fkinfo, int colno)
Definition: equivclass.c:2559
#define palloc0_object(type)
Definition: fe_memutils.h:75
int remaining
Definition: informix.c:692
void expand_inherited_rtentry(PlannerInfo *root, RelOptInfo *rel, RangeTblEntry *rte, Index rti)
Definition: inherit.c:86
int join_collapse_limit
Definition: initsplan.c:40
static void check_hashjoinable(RestrictInfo *restrictinfo)
Definition: initsplan.c:3801
static void extract_lateral_references(PlannerInfo *root, RelOptInfo *brel, Index rtindex)
Definition: initsplan.c:706
void rebuild_lateral_attr_needed(PlannerInfo *root)
Definition: initsplan.c:807
static void check_mergejoinable(RestrictInfo *restrictinfo)
Definition: initsplan.c:3764
void distribute_restrictinfo_to_rels(PlannerInfo *root, RestrictInfo *restrictinfo)
Definition: initsplan.c:3195
static List * deconstruct_recurse(PlannerInfo *root, Node *jtnode, JoinDomain *parent_domain, JoinTreeItem *parent_jtitem, List **item_list)
Definition: initsplan.c:1166
static void compute_semijoin_info(PlannerInfo *root, SpecialJoinInfo *sjinfo, List *clause)
Definition: initsplan.c:2048
struct JoinTreeItem JoinTreeItem
void match_foreign_keys_to_quals(PlannerInfo *root)
Definition: initsplan.c:3599
void find_lateral_references(PlannerInfo *root)
Definition: initsplan.c:658
void remove_useless_groupby_columns(PlannerInfo *root)
Definition: initsplan.c:412
static void add_base_clause_to_rel(PlannerInfo *root, Index relid, RestrictInfo *restrictinfo)
Definition: initsplan.c:2980
void add_base_rels_to_query(PlannerInfo *root, Node *jtnode)
Definition: initsplan.c:158
void build_base_rel_tlists(PlannerInfo *root, List *final_tlist)
Definition: initsplan.c:235
bool restriction_is_always_true(PlannerInfo *root, RestrictInfo *restrictinfo)
Definition: initsplan.c:3091
RestrictInfo * build_implied_join_equality(PlannerInfo *root, Oid opno, Oid collation, Expr *item1, Expr *item2, Relids qualscope, Index security_level)
Definition: initsplan.c:3424
int from_collapse_limit
Definition: initsplan.c:39
static void deconstruct_distribute_oj_quals(PlannerInfo *root, List *jtitems, JoinTreeItem *jtitem)
Definition: initsplan.c:2226
static void distribute_quals_to_rels(PlannerInfo *root, List *clauses, JoinTreeItem *jtitem, SpecialJoinInfo *sjinfo, Index security_level, Relids qualscope, Relids ojscope, Relids outerjoin_nonnullable, Relids incompatible_relids, bool allow_equivalence, bool has_clone, bool is_clone, List **postponed_oj_qual_list)
Definition: initsplan.c:2467
static SpecialJoinInfo * make_outerjoininfo(PlannerInfo *root, Relids left_rels, Relids right_rels, Relids inner_join_rels, JoinType jointype, Index ojrelid, List *clause)
Definition: initsplan.c:1708
void add_vars_to_targetlist(PlannerInfo *root, List *vars, Relids where_needed)
Definition: initsplan.c:282
bool restriction_is_always_false(PlannerInfo *root, RestrictInfo *restrictinfo)
Definition: initsplan.c:3140
static void distribute_qual_to_rels(PlannerInfo *root, Node *clause, JoinTreeItem *jtitem, SpecialJoinInfo *sjinfo, Index security_level, Relids qualscope, Relids ojscope, Relids outerjoin_nonnullable, Relids incompatible_relids, bool allow_equivalence, bool has_clone, bool is_clone, List **postponed_oj_qual_list)
Definition: initsplan.c:2545
List * deconstruct_jointree(PlannerInfo *root)
Definition: initsplan.c:1084
static bool check_redundant_nullability_qual(PlannerInfo *root, Node *clause)
Definition: initsplan.c:2935
void rebuild_joinclause_attr_needed(PlannerInfo *root)
Definition: initsplan.c:3527
static bool expr_is_nonnullable(PlannerInfo *root, Expr *expr)
Definition: initsplan.c:3055
void add_other_rels_to_query(PlannerInfo *root)
Definition: initsplan.c:196
static void mark_rels_nulled_by_join(PlannerInfo *root, Index ojrelid, Relids lower_rels)
Definition: initsplan.c:1666
RestrictInfo * process_implied_equality(PlannerInfo *root, Oid opno, Oid collation, Expr *item1, Expr *item2, Relids qualscope, Index security_level, bool both_const)
Definition: initsplan.c:3280
void create_lateral_join_info(PlannerInfo *root)
Definition: initsplan.c:845
static void process_security_barrier_quals(PlannerInfo *root, int rti, JoinTreeItem *jtitem)
Definition: initsplan.c:1616
static void deconstruct_distribute(PlannerInfo *root, JoinTreeItem *jtitem)
Definition: initsplan.c:1464
void add_vars_to_attr_needed(PlannerInfo *root, List *vars, Relids where_needed)
Definition: initsplan.c:353
static void check_memoizable(RestrictInfo *restrictinfo)
Definition: initsplan.c:3829
static Relids get_join_domain_min_rels(PlannerInfo *root, Relids domain_relids)
Definition: initsplan.c:3493
int j
Definition: isn.c:73
int i
Definition: isn.c:72
if(TABLE==NULL||TABLE_index==NULL)
Definition: isn.c:76
void add_join_clause_to_rels(PlannerInfo *root, RestrictInfo *restrictinfo, Relids join_relids)
Definition: joininfo.c:98
List * lappend(List *list, void *datum)
Definition: list.c:339
List * list_concat(List *list1, const List *list2)
Definition: list.c:561
List * lappend_oid(List *list, Oid datum)
Definition: list.c:375
void list_free(List *list)
Definition: list.c:1546
void list_free_deep(List *list)
Definition: list.c:1560
bool op_hashjoinable(Oid opno, Oid inputtype)
Definition: lsyscache.c:1464
bool op_mergejoinable(Oid opno, Oid inputtype)
Definition: lsyscache.c:1413
List * get_mergejoin_opfamilies(Oid opno)
Definition: lsyscache.c:367
Oid get_commutator(Oid opno)
Definition: lsyscache.c:1536
Node * makeBoolConst(bool value, bool isnull)
Definition: makefuncs.c:361
Expr * make_opclause(Oid opno, Oid opresulttype, bool opretset, Expr *leftop, Expr *rightop, Oid opcollid, Oid inputcollid)
Definition: makefuncs.c:654
void * palloc0(Size size)
Definition: mcxt.c:1347
Oid exprType(const Node *expr)
Definition: nodeFuncs.c:42
static bool is_orclause(const void *clause)
Definition: nodeFuncs.h:116
static Node * get_rightop(const void *clause)
Definition: nodeFuncs.h:95
static bool is_opclause(const void *clause)
Definition: nodeFuncs.h:76
static Node * get_leftop(const void *clause)
Definition: nodeFuncs.h:83
#define IsA(nodeptr, _type_)
Definition: nodes.h:158
#define copyObject(obj)
Definition: nodes.h:224
#define nodeTag(nodeptr)
Definition: nodes.h:133
#define makeNode(_type_)
Definition: nodes.h:155
JoinType
Definition: nodes.h:288
@ JOIN_SEMI
Definition: nodes.h:307
@ JOIN_FULL
Definition: nodes.h:295
@ JOIN_INNER
Definition: nodes.h:293
@ JOIN_RIGHT
Definition: nodes.h:296
@ JOIN_LEFT
Definition: nodes.h:294
@ JOIN_ANTI
Definition: nodes.h:308
#define PVC_RECURSE_AGGREGATES
Definition: optimizer.h:188
#define PVC_RECURSE_WINDOWFUNCS
Definition: optimizer.h:190
#define PVC_INCLUDE_PLACEHOLDERS
Definition: optimizer.h:191
@ RTE_VALUES
Definition: parsenodes.h:1031
@ RTE_SUBQUERY
Definition: parsenodes.h:1027
@ RTE_FUNCTION
Definition: parsenodes.h:1029
@ RTE_TABLEFUNC
Definition: parsenodes.h:1030
@ RTE_RELATION
Definition: parsenodes.h:1026
const char * LCS_asString(LockClauseStrength strength)
Definition: analyze.c:3407
void initialize_mergeclause_eclasses(PlannerInfo *root, RestrictInfo *restrictinfo)
Definition: pathkeys.c:1462
@ RELOPT_BASEREL
Definition: pathnodes.h:833
#define lfirst(lc)
Definition: pg_list.h:172
#define llast(l)
Definition: pg_list.h:198
#define lfirst_node(type, lc)
Definition: pg_list.h:176
static int list_length(const List *l)
Definition: pg_list.h:152
#define linitial_node(type, l)
Definition: pg_list.h:181
#define NIL
Definition: pg_list.h:68
#define list_make1(x1)
Definition: pg_list.h:212
#define linitial(l)
Definition: pg_list.h:178
#define lsecond(l)
Definition: pg_list.h:183
#define foreach_node(type, var, lst)
Definition: pg_list.h:496
#define list_make2(x1, x2)
Definition: pg_list.h:214
bool contain_placeholder_references_to(PlannerInfo *root, Node *clause, int relid)
Definition: placeholder.c:491
PlaceHolderInfo * find_placeholder_info(PlannerInfo *root, PlaceHolderVar *phv)
Definition: placeholder.c:83
Expr * preprocess_phv_expression(PlannerInfo *root, Expr *expr)
Definition: planner.c:1332
static bool DatumGetBool(Datum X)
Definition: postgres.h:95
#define InvalidOid
Definition: postgres_ext.h:37
unsigned int Oid
Definition: postgres_ext.h:32
@ IS_NULL
Definition: primnodes.h:1957
@ IS_NOT_NULL
Definition: primnodes.h:1957
tree ctl root
Definition: radixtree.h:1857
static struct subre * parse(struct vars *v, int stopper, int type, struct state *init, struct state *final)
Definition: regcomp.c:717
RelOptInfo * find_base_rel(PlannerInfo *root, int relid)
Definition: relnode.c:414
RelOptInfo * build_simple_rel(PlannerInfo *root, int relid, RelOptInfo *parent)
Definition: relnode.c:192
RelOptInfo * find_base_rel_ignore_join(PlannerInfo *root, int relid)
Definition: relnode.c:454
bool restriction_is_or_clause(RestrictInfo *restrictinfo)
Definition: restrictinfo.c:407
RestrictInfo * make_restrictinfo(PlannerInfo *root, Expr *clause, bool is_pushed_down, bool has_clone, bool is_clone, bool pseudoconstant, Index security_level, Relids required_relids, Relids incompatible_relids, Relids outer_relids)
Definition: restrictinfo.c:52
Node * add_nulling_relids(Node *node, const Bitmapset *target_relids, const Bitmapset *added_relids)
Node * remove_nulling_relids(Node *node, const Bitmapset *removable_relids, const Bitmapset *except_relids)
void IncrementVarSublevelsUp(Node *node, int delta_sublevels_up, int min_sublevels_up)
Definition: rewriteManip.c:850
Oid consttype
Definition: primnodes.h:329
List * rinfos[INDEX_MAX_KEYS]
Definition: pathnodes.h:1271
Node * quals
Definition: primnodes.h:2338
List * fromlist
Definition: primnodes.h:2337
Relids jd_relids
Definition: pathnodes.h:1338
struct JoinTreeItem * jti_parent
Definition: initsplan.c:65
SpecialJoinInfo * sjinfo
Definition: initsplan.c:77
Relids inner_join_rels
Definition: initsplan.c:69
Relids left_rels
Definition: initsplan.c:72
Relids right_rels
Definition: initsplan.c:73
Relids nonnullable_rels
Definition: initsplan.c:74
Node * jtnode
Definition: initsplan.c:63
JoinDomain * jdomain
Definition: initsplan.c:64
List * oj_joinclauses
Definition: initsplan.c:78
Relids qualscope
Definition: initsplan.c:67
List * lateral_clauses
Definition: initsplan.c:79
Definition: pg_list.h:54
Definition: nodes.h:129
NullTestType nulltesttype
Definition: primnodes.h:1964
Expr * arg
Definition: primnodes.h:1963
Oid opno
Definition: primnodes.h:835
List * args
Definition: primnodes.h:853
RestrictInfo * rinfo
Definition: pathnodes.h:2940
SpecialJoinInfo * sjinfo
Definition: pathnodes.h:2941
List * exprs
Definition: pathnodes.h:1550
Relids ph_lateral
Definition: pathnodes.h:3108
Relids ph_needed
Definition: pathnodes.h:3111
Relids ph_eval_at
Definition: pathnodes.h:3105
PlaceHolderVar * ph_var
Definition: pathnodes.h:3102
Index phlevelsup
Definition: pathnodes.h:2814
TableFunc * tablefunc
Definition: parsenodes.h:1193
struct TableSampleClause * tablesample
Definition: parsenodes.h:1107
Query * subquery
Definition: parsenodes.h:1113
List * values_lists
Definition: parsenodes.h:1199
List * functions
Definition: parsenodes.h:1186
RTEKind rtekind
Definition: parsenodes.h:1056
List * baserestrictinfo
Definition: pathnodes.h:991
List * joininfo
Definition: pathnodes.h:997
Bitmapset * notnullattnums
Definition: pathnodes.h:942
Relids relids
Definition: pathnodes.h:877
struct PathTarget * reltarget
Definition: pathnodes.h:899
Index relid
Definition: pathnodes.h:924
List * lateral_vars
Definition: pathnodes.h:946
Relids lateral_relids
Definition: pathnodes.h:919
RelOptKind reloptkind
Definition: pathnodes.h:871
List * indexlist
Definition: pathnodes.h:950
Relids lateral_referencers
Definition: pathnodes.h:948
Relids direct_lateral_relids
Definition: pathnodes.h:917
Relids nulling_relids
Definition: pathnodes.h:944
Index baserestrict_min_security
Definition: pathnodes.h:995
AttrNumber min_attr
Definition: pathnodes.h:930
bool is_pushed_down
Definition: pathnodes.h:2584
Index security_level
Definition: pathnodes.h:2603
Relids required_relids
Definition: pathnodes.h:2612
int rinfo_serial
Definition: pathnodes.h:2653
Relids outer_relids
Definition: pathnodes.h:2618
Relids incompatible_relids
Definition: pathnodes.h:2615
Expr * clause
Definition: pathnodes.h:2581
bool has_clone
Definition: pathnodes.h:2593
LockClauseStrength strength
Definition: parsenodes.h:1589
Relids commute_above_r
Definition: pathnodes.h:2918
Relids syn_lefthand
Definition: pathnodes.h:2913
Relids min_righthand
Definition: pathnodes.h:2912
List * semi_rhs_exprs
Definition: pathnodes.h:2926
Relids commute_above_l
Definition: pathnodes.h:2917
JoinType jointype
Definition: pathnodes.h:2915
Relids commute_below_l
Definition: pathnodes.h:2919
Relids min_lefthand
Definition: pathnodes.h:2911
Relids syn_righthand
Definition: pathnodes.h:2914
Relids commute_below_r
Definition: pathnodes.h:2920
List * semi_operators
Definition: pathnodes.h:2925
Expr * expr
Definition: primnodes.h:2219
Definition: primnodes.h:262
AttrNumber varattno
Definition: primnodes.h:274
int varno
Definition: primnodes.h:269
Index varlevelsup
Definition: primnodes.h:294
Definition: type.h:96
Definition: regcomp.c:282
#define FirstLowInvalidHeapAttributeNumber
Definition: sysattr.h:27
TargetEntry * get_sortgroupclause_tle(SortGroupClause *sgClause, List *targetList)
Definition: tlist.c:367
TypeCacheEntry * lookup_type_cache(Oid type_id, int flags)
Definition: typcache.c:386
#define TYPECACHE_EQ_OPR
Definition: typcache.h:137
#define TYPECACHE_HASH_PROC
Definition: typcache.h:141
Relids pull_varnos(PlannerInfo *root, Node *node)
Definition: var.c:114
List * pull_vars_of_level(Node *node, int levelsup)
Definition: var.c:339
List * pull_var_clause(Node *node, int flags)
Definition: var.c:653