Loading...
Searching...
No Matches
paths.h File Reference
#include "nodes/pathnodes.h"
Include dependency graph for paths.h:
This graph shows which files directly or indirectly include this file:
Go to the source code of this file.
Typedefs | |
| typedef void(* | join_path_setup_hook_type) (PlannerInfo *root, RelOptInfo *joinrel, RelOptInfo *outerrel, RelOptInfo *innerrel, JoinType jointype, JoinPathExtraData *extra) |
| typedef void(* | set_rel_pathlist_hook_type) (PlannerInfo *root, RelOptInfo *rel, Index rti, RangeTblEntry *rte) |
| typedef void(* | set_join_pathlist_hook_type) (PlannerInfo *root, RelOptInfo *joinrel, RelOptInfo *outerrel, RelOptInfo *innerrel, JoinType jointype, JoinPathExtraData *extra) |
| typedef RelOptInfo *(* | join_search_hook_type) (PlannerInfo *root, int levels_needed, List *initial_rels) |
| typedef bool(* | ec_matches_callback_type) (PlannerInfo *root, RelOptInfo *rel, EquivalenceClass *ec, EquivalenceMember *em, void *arg) |
Enumerations | |
| enum | PathKeysComparison { PATHKEYS_EQUAL , PATHKEYS_BETTER1 , PATHKEYS_BETTER2 , PATHKEYS_DIFFERENT } |
Typedef Documentation
◆ ec_matches_callback_type
| typedef bool(* ec_matches_callback_type) (PlannerInfo *root, RelOptInfo *rel, EquivalenceClass *ec, EquivalenceMember *em, void *arg) |
◆ join_path_setup_hook_type
| typedef void(* join_path_setup_hook_type) (PlannerInfo *root, RelOptInfo *joinrel, RelOptInfo *outerrel, RelOptInfo *innerrel, JoinType jointype, JoinPathExtraData *extra) |
◆ join_search_hook_type
| typedef RelOptInfo *(* join_search_hook_type) (PlannerInfo *root, int levels_needed, List *initial_rels) |
◆ set_join_pathlist_hook_type
| typedef void(* set_join_pathlist_hook_type) (PlannerInfo *root, RelOptInfo *joinrel, RelOptInfo *outerrel, RelOptInfo *innerrel, JoinType jointype, JoinPathExtraData *extra) |
◆ set_rel_pathlist_hook_type
| typedef void(* set_rel_pathlist_hook_type) (PlannerInfo *root, RelOptInfo *rel, Index rti, RangeTblEntry *rte) |
Enumeration Type Documentation
◆ PathKeysComparison
| Enumerator | |
|---|---|
| PATHKEYS_EQUAL | |
| PATHKEYS_BETTER1 | |
| PATHKEYS_BETTER2 | |
| PATHKEYS_DIFFERENT | |
Definition at line 218 of file paths.h.
219{
224} PathKeysComparison;
Function Documentation
◆ add_child_join_rel_equivalences()
|
extern |
Definition at line 2940 of file equivclass.c.
2944{
2948 MemoryContext oldcontext;
2950
2952
2953 /* We need consider only ECs that mention the parent joinrel */
2955
2956 /*
2957 * If we're being called during GEQO join planning, we still have to
2958 * create any new EC members in the main planner context, to avoid having
2959 * a corrupt EC data structure after the GEQO context is reset. This is
2960 * problematic since we'll leak memory across repeated GEQO cycles. For
2961 * now, though, bloat is better than crash. If it becomes a real issue
2962 * we'll have to do something to avoid generating duplicate EC members.
2963 */
2965
2966 i = -1;
2968 {
2970
2971 /*
2972 * If this EC contains a volatile expression, then generating child
2973 * EMs would be downright dangerous, so skip it. We rely on a
2974 * volatile EC having only one EM.
2975 */
2977 continue;
2978
2979 /* Sanity check on get_eclass_indexes_for_relids result */
2981
2983 {
2985 continue; /* ignore consts here */
2986
2987 /* Child members should not exist in ec_members */
2989
2990 /*
2991 * We may ignore expressions that reference a single baserel,
2992 * because add_child_rel_equivalences should have handled them.
2993 */
2995 continue;
2996
2997 /* Does this member reference child's topmost parent rel? */
2999 {
3000 /* Yes, generate transformed child version */
3003
3005 {
3006 /* Simple single-level transformation */
3010 nappinfos, appinfos);
3011 }
3012 else
3013 {
3014 /* Must do multi-level transformation */
3019 child_joinrel,
3020 child_joinrel->top_parent);
3021 }
3022
3023 /*
3024 * Transform em_relids to match. Note we do *not* do
3025 * pull_varnos(child_expr) here, as for example the
3026 * transformation might have substituted a constant, but we
3027 * don't want the child member to be marked as constant.
3028 */
3030 top_parent_relids);
3032
3033 /*
3034 * Add new child member to the EquivalenceClass. Because this
3035 * is a RELOPT_OTHER_JOINREL which has multiple component
3036 * relids, there is no ideal place to store these members in
3037 * the class. Ordinarily, child members are stored in the
3038 * ec_childmembers[] array element corresponding to their
3039 * relid, however, here we have multiple component relids, so
3040 * there's no single ec_childmembers[] array element to store
3041 * this member. So that we still correctly find this member
3042 * in loops iterating over an EquivalenceMemberIterator, we
3043 * opt to store the member in the ec_childmembers array in
3044 * only the first component relid slot of the array. This
3045 * allows the member to be found, providing callers of
3046 * setup_eclass_member_iterator() specify all the component
3047 * relids for the RELOPT_OTHER_JOINREL, which they do. If we
3048 * opted to store the member in each ec_childmembers[] element
3049 * for all the component relids, then that would just result
3050 * in eclass_member_iterator_next() finding the member
3051 * multiple times, which is a waste of effort.
3052 */
3054 cur_ec,
3055 -1,
3056 child_expr,
3057 new_relids,
3058 cur_em->em_jdomain,
3059 cur_em,
3060 cur_em->em_datatype,
3062 }
3063 }
3064 }
3065
3066 MemoryContextSwitchTo(oldcontext);
3067}
Node * adjust_appendrel_attrs(PlannerInfo *root, Node *node, int nappinfos, AppendRelInfo **appinfos)
Definition appendinfo.c:200
Node * adjust_appendrel_attrs_multilevel(PlannerInfo *root, Node *node, RelOptInfo *childrel, RelOptInfo *parentrel)
Definition appendinfo.c:592
Bitmapset * bms_difference(const Bitmapset *a, const Bitmapset *b)
Definition bitmapset.c:346
Bitmapset * bms_add_members(Bitmapset *a, const Bitmapset *b)
Definition bitmapset.c:916
static EquivalenceMember * add_child_eq_member(PlannerInfo *root, EquivalenceClass *ec, int ec_index, Expr *expr, Relids relids, JoinDomain *jdomain, EquivalenceMember *parent_em, Oid datatype, Index child_relid)
Definition equivclass.c:661
static Bitmapset * get_eclass_indexes_for_relids(PlannerInfo *root, Relids relids)
Definition equivclass.c:3612
static MemoryContext MemoryContextSwitchTo(MemoryContext context)
Definition palloc.h:124
Definition bitmapset.h:50
Definition pathnodes.h:1634
Definition pathnodes.h:1695
Definition primnodes.h:189
Definition memnodes.h:118
Definition nodes.h:135
References add_child_eq_member(), adjust_appendrel_attrs(), adjust_appendrel_attrs_multilevel(), Assert, bms_add_members(), bms_difference(), bms_membership(), BMS_MULTIPLE, bms_next_member(), bms_overlap(), fb(), foreach_node, get_eclass_indexes_for_relids(), i, IS_JOIN_REL, list_nth(), MemoryContextSwitchTo(), RELOPT_JOINREL, RELOPT_OTHER_JOINREL, and root.
Referenced by build_child_join_rel().
◆ add_child_rel_equivalences()
|
extern |
Definition at line 2832 of file equivclass.c.
2836{
2840
2841 /*
2842 * EC merging should be complete already, so we can use the parent rel's
2843 * eclass_indexes to avoid searching all of root->eq_classes.
2844 */
2847
2848 i = -1;
2850 {
2852
2853 /*
2854 * If this EC contains a volatile expression, then generating child
2855 * EMs would be downright dangerous, so skip it. We rely on a
2856 * volatile EC having only one EM.
2857 */
2859 continue;
2860
2861 /* Sanity check eclass_indexes only contain ECs for parent_rel */
2863
2865 {
2867 continue; /* ignore consts here */
2868
2869 /* Child members should not exist in ec_members */
2871
2872 /*
2873 * Consider only members that reference and can be computed at
2874 * child's topmost parent rel. In particular we want to exclude
2875 * parent-rel Vars that have nonempty varnullingrels. Translating
2876 * those might fail, if the transformed expression wouldn't be a
2877 * simple Var; and in any case it wouldn't produce a member that
2878 * has any use in creating plans for the child rel.
2879 */
2882 {
2883 /* OK, generate transformed child version */
2886
2888 {
2889 /* Simple single-level transformation */
2893 1, &appinfo);
2894 }
2895 else
2896 {
2897 /* Must do multi-level transformation */
2901 child_rel,
2902 child_rel->top_parent);
2903 }
2904
2905 /*
2906 * Transform em_relids to match. Note we do *not* do
2907 * pull_varnos(child_expr) here, as for example the
2908 * transformation might have substituted a constant, but we
2909 * don't want the child member to be marked as constant.
2910 */
2912 top_parent_relids);
2914
2916 cur_ec,
2917 i,
2918 child_expr,
2919 new_relids,
2920 cur_em->em_jdomain,
2921 cur_em,
2922 cur_em->em_datatype,
2923 child_rel->relid);
2924 }
2925 }
2926 }
2927}
References add_child_eq_member(), adjust_appendrel_attrs(), adjust_appendrel_attrs_multilevel(), Assert, bms_add_members(), bms_difference(), bms_is_empty, bms_is_subset(), bms_next_member(), fb(), foreach_node, i, IS_SIMPLE_REL, list_nth(), RELOPT_BASEREL, and root.
Referenced by set_append_rel_size().
◆ add_outer_joins_to_relids()
|
extern |
Definition at line 800 of file joinrels.c.
803{
804 /* Nothing to do if this isn't an outer join with an assigned relid. */
807
808 /*
809 * If it's not a left join, we have no rules that would permit executing
810 * it in non-syntactic order, so just form the syntactic relid set. (This
811 * is just a quick-exit test; we'd come to the same conclusion anyway,
812 * since its commute_below_l and commute_above_l sets must be empty.)
813 */
816
817 /*
818 * We cannot add the OJ relid if this join has been pushed into the RHS of
819 * a syntactically-lower left join per OJ identity 3. (If it has, then we
820 * cannot claim that its outputs represent the final state of its RHS.)
821 * There will not be any other OJs that can be added either, so we're
822 * done.
823 */
826
827 /* OK to add OJ's own relid */
829
830 /*
831 * Contrariwise, if we are now forming the final result of such a commuted
832 * pair of OJs, it's time to add the relid(s) of the pushed-down join(s).
833 * We can skip this if this join was never a candidate to be pushed up.
834 */
836 {
839
840 /*
841 * The current join could complete the nulling of more than one
842 * pushed-down join, so we have to examine all the SpecialJoinInfos.
843 * Because join_info_list was built in bottom-up order, it's
844 * sufficient to traverse it once: an ojrelid we add in one loop
845 * iteration would not have affected decisions of earlier iterations.
846 */
848 {
850
853 continue; /* definitely not interesting */
854
856 continue;
857
858 /* Add it if not already present but conditions now satisfied */
863 {
865 /* report such pushed down outer joins, if asked */
868
869 /*
870 * We must also check any joins that othersj potentially
871 * commutes with. They likewise must appear later in
872 * join_info_list than othersj itself, so we can visit them
873 * later in this loop.
874 */
876 othersj->commute_above_l);
877 }
878 }
879 }
880
882}
Definition pathnodes.h:3191
Definition pg_list.h:46
References bms_add_member(), bms_add_members(), bms_copy(), bms_is_member(), bms_is_subset(), SpecialJoinInfo::commute_above_l, SpecialJoinInfo::commute_below_l, fb(), JOIN_LEFT, SpecialJoinInfo::jointype, lappend(), lfirst, SpecialJoinInfo::ojrelid, and root.
Referenced by generate_join_implied_equalities(), and make_join_rel().
◆ add_paths_to_append_rel()
|
extern |
Definition at line 1404 of file allpaths.c.
1406{
1418 ListCell *l;
1420
1421 /* If appropriate, consider parallel append */
1423
1424 /*
1425 * For every non-dummy child, remember the cheapest path. Also, identify
1426 * all pathkeys (orderings) and parameterizations (required_outer sets)
1427 * available for the non-dummy member relations.
1428 */
1430 {
1434
1435 /*
1436 * If child has an unparameterized cheapest-total path, add that to
1437 * the unparameterized Append path we are constructing for the parent.
1438 * If not, there's no workable unparameterized path.
1439 *
1440 * With partitionwise aggregates, the child rel's pathlist may be
1441 * empty, so don't assume that a path exists here.
1442 */
1446 &subpaths, NULL);
1447 else
1449
1450 /*
1451 * When the planner is considering cheap startup plans, we'll also
1452 * collect all the cheapest_startup_paths (if set) and build an
1453 * AppendPath containing those as subpaths.
1454 */
1456 {
1458
1459 /*
1460 * With an indication of how many tuples the query should provide,
1461 * the optimizer tries to choose the path optimal for that
1462 * specific number of tuples.
1463 */
1465 cheapest_path =
1467 root->tuple_fraction);
1468 else
1470
1471 /* cheapest_startup_path must not be a parameterized path. */
1474 &startup_subpaths,
1475 NULL);
1476 }
1477 else
1479
1480
1481 /* Same idea, but for a partial plan. */
1483 {
1487 }
1488 else
1490
1491 /*
1492 * Same idea, but for a parallel append mixing partial and non-partial
1493 * paths.
1494 */
1496 {
1498
1499 nppath =
1501
1503 {
1504 /* Neither a partial nor a parallel-safe path? Forget it. */
1506 }
1510 {
1511 /* Partial path is cheaper or the only option. */
1514 &pa_partial_subpaths,
1515 &pa_nonpartial_subpaths);
1516 }
1517 else
1518 {
1519 /*
1520 * Either we've got only a non-partial path, or we think that
1521 * a single backend can execute the best non-partial path
1522 * faster than all the parallel backends working together can
1523 * execute the best partial path.
1524 *
1525 * It might make sense to be more aggressive here. Even if
1526 * the best non-partial path is more expensive than the best
1527 * partial path, it could still be better to choose the
1528 * non-partial path if there are several such paths that can
1529 * be given to different workers. For now, we don't try to
1530 * figure that out.
1531 */
1533 &pa_nonpartial_subpaths,
1534 NULL);
1535 }
1536 }
1537
1538 /*
1539 * Collect lists of all the available path orderings and
1540 * parameterizations for all the children. We use these as a
1541 * heuristic to indicate which sort orderings and parameterizations we
1542 * should build Append and MergeAppend paths for.
1543 */
1545 {
1549
1550 /* Unsorted paths don't contribute to pathkey list */
1552 {
1554 bool found = false;
1555
1556 /* Have we already seen this ordering? */
1558 {
1560
1563 {
1564 found = true;
1565 break;
1566 }
1567 }
1568 if (!found)
1569 {
1570 /* No, so add it to all_child_pathkeys */
1572 childkeys);
1573 }
1574 }
1575
1576 /* Unparameterized paths don't contribute to param-set list */
1578 {
1580 bool found = false;
1581
1582 /* Have we already seen this param set? */
1584 {
1586
1588 {
1589 found = true;
1590 break;
1591 }
1592 }
1593 if (!found)
1594 {
1595 /* No, so add it to all_child_outers */
1597 childouter);
1598 }
1599 }
1600 }
1601 }
1602
1603 /*
1604 * If we found unparameterized paths for all children, build an unordered,
1605 * unparameterized Append path for the rel. (Note: this is correct even
1606 * if we have zero or one live subpath due to constraint exclusion.)
1607 */
1611 -1));
1612
1613 /* build an AppendPath for the cheap startup paths, if valid */
1617
1618 /*
1619 * Consider an append of unordered, unparameterized partial paths. Make
1620 * it parallel-aware if possible.
1621 */
1623 {
1626 int parallel_workers = 0;
1627
1628 /* Find the highest number of workers requested for any subpath. */
1630 {
1632
1634 }
1635 Assert(parallel_workers > 0);
1636
1637 /*
1638 * If the use of parallel append is permitted, always request at least
1639 * log2(# of children) workers. We assume it can be useful to have
1640 * extra workers in this case because they will be spread out across
1641 * the children. The precise formula is just a guess, but we don't
1642 * want to end up with a radically different answer for a table with N
1643 * partitions vs. an unpartitioned table with the same data, so the
1644 * use of some kind of log-scaling here seems to make some sense.
1645 */
1647 {
1648 parallel_workers = Max(parallel_workers,
1650 parallel_workers = Min(parallel_workers,
1652 }
1653 Assert(parallel_workers > 0);
1654
1655 /* Generate a partial append path. */
1658 enable_parallel_append,
1659 -1);
1660
1661 /*
1662 * Make sure any subsequent partial paths use the same row count
1663 * estimate.
1664 */
1666
1667 /* Add the path. */
1669 }
1670
1671 /*
1672 * Consider a parallel-aware append using a mix of partial and non-partial
1673 * paths. (This only makes sense if there's at least one child which has
1674 * a non-partial path that is substantially cheaper than any partial path;
1675 * otherwise, we should use the append path added in the previous step.)
1676 */
1678 {
1681 int parallel_workers = 0;
1682
1683 /*
1684 * Find the highest number of workers requested for any partial
1685 * subpath.
1686 */
1688 {
1690
1692 }
1693
1694 /*
1695 * Same formula here as above. It's even more important in this
1696 * instance because the non-partial paths won't contribute anything to
1697 * the planned number of parallel workers.
1698 */
1699 parallel_workers = Max(parallel_workers,
1701 parallel_workers = Min(parallel_workers,
1703 Assert(parallel_workers > 0);
1704
1706 pa_partial_subpaths,
1708 partial_rows);
1710 }
1711
1712 /*
1713 * Also build unparameterized ordered append paths based on the collected
1714 * list of child pathkeys.
1715 */
1718 all_child_pathkeys);
1719
1720 /*
1721 * Build Append paths for each parameterization seen among the child rels.
1722 * (This may look pretty expensive, but in most cases of practical
1723 * interest, the child rels will expose mostly the same parameterizations,
1724 * so that not that many cases actually get considered here.)
1725 *
1726 * The Append node itself cannot enforce quals, so all qual checking must
1727 * be done in the child paths. This means that to have a parameterized
1728 * Append path, we must have the exact same parameterization for each
1729 * child path; otherwise some children might be failing to check the
1730 * moved-down quals. To make them match up, we can try to increase the
1731 * parameterization of lesser-parameterized paths.
1732 */
1734 {
1737
1738 /* Select the child paths for an Append with this parameterization */
1739 subpaths = NIL;
1742 {
1745
1747 {
1748 /* failed to make a suitable path for this child */
1750 break;
1751 }
1752
1754 childrel,
1755 required_outer);
1757 {
1758 /* failed to make a suitable path for this child */
1760 break;
1761 }
1763 }
1764
1769 -1));
1770 }
1771
1772 /*
1773 * When there is only a single child relation, the Append path can inherit
1774 * any ordering available for the child rel's path, so that it's useful to
1775 * consider ordered partial paths. Above we only considered the cheapest
1776 * partial path for each child, but let's also make paths using any
1777 * partial paths that have pathkeys.
1778 */
1780 {
1782
1783 /* skip the cheapest partial path, since we already used that above */
1785 {
1788
1789 /* skip paths with no pathkeys. */
1791 continue;
1792
1796 partial_rows);
1798 }
1799 }
1800}
static Path * get_cheapest_parameterized_child_path(PlannerInfo *root, RelOptInfo *rel, Relids required_outer)
Definition allpaths.c:2138
static void generate_orderedappend_paths(PlannerInfo *root, RelOptInfo *rel, List *live_childrels, List *all_child_pathkeys)
Definition allpaths.c:1832
static void accumulate_append_subpath(Path *path, List **subpaths, List **special_subpaths)
Definition allpaths.c:2226
PathKeysComparison compare_pathkeys(List *keys1, List *keys2)
Definition pathkeys.c:304
Path * get_cheapest_parallel_safe_total_inner(List *paths)
Definition pathkeys.c:699
void add_partial_path(RelOptInfo *parent_rel, Path *new_path)
Definition pathnode.c:793
AppendPath * create_append_path(PlannerInfo *root, RelOptInfo *rel, List *subpaths, List *partial_subpaths, List *pathkeys, Relids required_outer, int parallel_workers, bool parallel_aware, double rows)
Definition pathnode.c:1299
Path * get_cheapest_fractional_path(RelOptInfo *rel, double tuple_fraction)
Definition planner.c:6655
Definition pathnodes.h:2256
Definition pg_list.h:54
Definition pathnodes.h:1945
Definition pathnodes.h:992
References accumulate_append_subpath(), add_partial_path(), add_path(), Assert, bms_equal(), compare_pathkeys(), RelOptInfo::consider_parallel, RelOptInfo::consider_startup, create_append_path(), enable_parallel_append, fb(), for_each_from, generate_orderedappend_paths(), get_cheapest_fractional_path(), get_cheapest_parallel_safe_total_inner(), get_cheapest_parameterized_child_path(), lappend(), lfirst, linitial, list_length(), list_make1, Max, max_parallel_workers_per_gather, Min, NIL, Path::parallel_workers, PATH_REQ_OUTER, Path::pathkeys, PATHKEYS_EQUAL, pg_leftmost_one_pos32(), root, and subpath().
Referenced by apply_scanjoin_target_to_paths(), create_partitionwise_grouping_paths(), generate_partitionwise_join_paths(), and set_append_rel_pathlist().
◆ add_paths_to_joinrel()
|
extern |
Definition at line 123 of file joinpath.c.
130{
132 JoinPathExtraData extra;
136
137 /*
138 * PlannerInfo doesn't contain the SpecialJoinInfos created for joins
139 * between child relations, even if there is a SpecialJoinInfo node for
140 * the join between the topmost parents. So, while calculating Relids set
141 * representing the restriction, consider relids of topmost parent of
142 * partitions.
143 */
146 else
148
149 extra.restrictlist = restrictlist;
151 extra.sjinfo = sjinfo;
154
155 /*
156 * Give extensions a chance to take control. In particular, an extension
157 * might want to modify extra.pgs_mask. It's possible to override pgs_mask
158 * on a query-wide basis using join_search_hook, or for a particular
159 * relation using joinrel_setup_hook, but extensions that want to provide
160 * different advice for the same joinrel based on the choice of innerrel
161 * and outerrel will need to use this hook.
162 *
163 * A very simple way for an extension to use this hook is to set
164 * extra.pgs_mask &= ~PGS_JOIN_ANY, if it simply doesn't want any of the
165 * paths generated by this call to add_paths_to_joinrel() to be selected.
166 * An extension could use this technique to constrain the join order,
167 * since it could thereby arrange to reject all paths from join orders
168 * that it does not like. An extension can also selectively clear bits
169 * from extra.pgs_mask to rule out specific techniques for specific joins,
170 * or could even set additional bits to re-allow methods disabled at some
171 * higher level.
172 *
173 * NB: Below this point, this function should be careful to reference
174 * extra.pgs_mask rather than rel->pgs_mask to avoid disregarding any
175 * changes made by the hook we're about to call.
176 */
179 jointype, &extra);
180
181 /*
182 * See if the inner relation is provably unique for this outer rel.
183 *
184 * We have some special cases: for JOIN_SEMI, it doesn't matter since the
185 * executor can make the equivalent optimization anyway. It also doesn't
186 * help enable use of Memoize, since a semijoin with a provably unique
187 * inner side should have been reduced to an inner join in that case.
188 * Therefore, we need not expend planner cycles on proofs. (For
189 * JOIN_ANTI, although it doesn't help the executor for the same reason,
190 * it can benefit Memoize paths.) For JOIN_UNIQUE_INNER, we must be
191 * considering a semijoin whose inner side is not provably unique (else
192 * reduce_unique_semijoins would've simplified it), so there's no point in
193 * calling innerrel_is_unique. However, if the LHS covers all of the
194 * semijoin's min_lefthand, then it's appropriate to set inner_unique
195 * because the unique relation produced by create_unique_paths will be
196 * unique relative to the LHS. (If we have an LHS that's only part of the
197 * min_lefthand, that is *not* true.) For JOIN_UNIQUE_OUTER, pass
198 * JOIN_INNER to avoid letting that value escape this module.
199 */
200 switch (jointype)
201 {
204 break;
207 outerrel->relids);
208 break;
211 joinrel->relids,
212 outerrel->relids,
213 innerrel,
214 JOIN_INNER,
215 restrictlist,
216 false);
217 break;
218 default:
220 joinrel->relids,
221 outerrel->relids,
222 innerrel,
223 jointype,
224 restrictlist,
225 false);
226 break;
227 }
228
229 /*
230 * If the outer or inner relation has been unique-ified, handle as a plain
231 * inner join.
232 */
234 jointype = JOIN_INNER;
235
236 /*
237 * Find potential mergejoin clauses. We can skip this if we are not
238 * interested in doing a mergejoin. However, mergejoin may be our only
239 * way of implementing a full outer join, so in that case we don't care
240 * whether mergejoins are disabled.
241 */
244 joinrel,
245 outerrel,
246 innerrel,
247 restrictlist,
248 jointype,
249 &mergejoin_allowed);
250
251 /*
252 * If it's SEMI, ANTI, or inner_unique join, compute correction factors
253 * for cost estimation. These will be the same for all paths.
254 */
257 jointype, sjinfo, restrictlist,
258 &extra.semifactors);
259
260 /*
261 * Decide whether it's sensible to generate parameterized paths for this
262 * joinrel, and if so, which relations such paths should require. There
263 * is usually no need to create a parameterized result path unless there
264 * is a join order restriction that prevents joining one of our input rels
265 * directly to the parameter source rel instead of joining to the other
266 * input rel. (But see allow_star_schema_join().) This restriction
267 * reduces the number of parameterized paths we have to deal with at
268 * higher join levels, without compromising the quality of the resulting
269 * plan. We express the restriction as a Relids set that must overlap the
270 * parameterization of any proposed join path. Note: param_source_rels
271 * should contain only baserels, not OJ relids, so starting from
272 * all_baserels not all_query_rels is correct.
273 */
275 {
277
278 /*
279 * SJ is relevant to this join if we have some part of its RHS
280 * (possibly not all of it), and haven't yet joined to its LHS. (This
281 * test is pretty simplistic, but should be sufficient considering the
282 * join has already been proven legal.) If the SJ is relevant, it
283 * presents constraints for joining to anything not in its RHS.
284 */
289 sjinfo2->min_righthand));
290
291 /* full joins constrain both sides symmetrically */
297 sjinfo2->min_lefthand));
298 }
299
300 /*
301 * However, when a LATERAL subquery is involved, there will simply not be
302 * any paths for the joinrel that aren't parameterized by whatever the
303 * subquery is parameterized by, unless its parameterization is resolved
304 * within the joinrel. So we might as well allow additional dependencies
305 * on whatever residual lateral dependencies the joinrel will have.
306 */
308 joinrel->lateral_relids);
309
310 /*
311 * 1. Consider mergejoin paths where both relations must be explicitly
312 * sorted. Skip this if we can't mergejoin.
313 */
316 jointype, &extra);
317
318 /*
319 * 2. Consider paths where the outer relation need not be explicitly
320 * sorted. This includes both nestloops and mergejoins where the outer
321 * path is already ordered. Again, skip this if we can't mergejoin.
322 * (That's okay because we know that nestloop can't handle
323 * right/right-anti/right-semi/full joins at all, so it wouldn't work in
324 * the prohibited cases either.)
325 */
328 jointype, &extra);
329
330#ifdef NOT_USED
331
332 /*
333 * 3. Consider paths where the inner relation need not be explicitly
334 * sorted. This includes mergejoins only (nestloops were already built in
335 * match_unsorted_outer).
336 *
337 * Diked out as redundant 2/13/2000 -- tgl. There isn't any really
338 * significant difference between the inner and outer side of a mergejoin,
339 * so match_unsorted_inner creates no paths that aren't equivalent to
340 * those made by match_unsorted_outer when add_paths_to_joinrel() is
341 * invoked with the two rels given in the other order.
342 */
345 jointype, &extra);
346#endif
347
348 /*
349 * 4. Consider paths where both outer and inner relations must be hashed
350 * before being joined. As above, when it's a full join, we must try this
351 * even when the path type is disabled, because it may be our only option.
352 */
355 jointype, &extra);
356
357 /*
358 * 5. If inner and outer relations are foreign tables (or joins) belonging
359 * to the same server and assigned to the same user to check access
360 * permissions as, give the FDW a chance to push down joins.
361 */
363 joinrel->fdwroutine->GetForeignJoinPaths)
364 joinrel->fdwroutine->GetForeignJoinPaths(root, joinrel,
365 outerrel, innerrel,
366 save_jointype, &extra);
367
368 /*
369 * 6. Finally, give extensions a chance to manipulate the path list. They
370 * could add new paths (such as CustomPaths) by calling add_path(), or
371 * add_partial_path() if parallel aware.
372 *
373 * In theory, extensions could also use this hook to delete or modify
374 * paths added by the core code, but in practice this is difficult to make
375 * work, since it's too late to get back any paths that have already been
376 * discarded by add_path() or add_partial_path(). If you're trying to
377 * suppress paths, consider using join_path_setup_hook instead.
378 */
381 save_jointype, &extra);
382}
bool innerrel_is_unique(PlannerInfo *root, Relids joinrelids, Relids outerrelids, RelOptInfo *innerrel, JoinType jointype, List *restrictlist, bool force_cache)
Definition analyzejoins.c:1310
void compute_semi_anti_join_factors(PlannerInfo *root, RelOptInfo *joinrel, RelOptInfo *outerrel, RelOptInfo *innerrel, JoinType jointype, SpecialJoinInfo *sjinfo, List *restrictlist, SemiAntiJoinFactors *semifactors)
Definition costsize.c:5261
static List * select_mergejoin_clauses(PlannerInfo *root, RelOptInfo *joinrel, RelOptInfo *outerrel, RelOptInfo *innerrel, List *restrictlist, JoinType jointype, bool *mergejoin_allowed)
Definition joinpath.c:2395
static void sort_inner_and_outer(PlannerInfo *root, RelOptInfo *joinrel, RelOptInfo *outerrel, RelOptInfo *innerrel, JoinType jointype, JoinPathExtraData *extra)
Definition joinpath.c:1402
static void hash_inner_and_outer(PlannerInfo *root, RelOptInfo *joinrel, RelOptInfo *outerrel, RelOptInfo *innerrel, JoinType jointype, JoinPathExtraData *extra)
Definition joinpath.c:2168
static void match_unsorted_outer(PlannerInfo *root, RelOptInfo *joinrel, RelOptInfo *outerrel, RelOptInfo *innerrel, JoinType jointype, JoinPathExtraData *extra)
Definition joinpath.c:1826
Definition pathnodes.h:3574
References bms_add_members(), bms_difference(), bms_is_subset(), bms_join(), bms_overlap(), compute_semi_anti_join_factors(), fb(), hash_inner_and_outer(), JoinPathExtraData::inner_unique, innerrel_is_unique(), JOIN_ANTI, JOIN_FULL, JOIN_INNER, join_path_setup_hook, JOIN_SEMI, JOIN_UNIQUE_INNER, JOIN_UNIQUE_OUTER, RelOptInfo::lateral_relids, lfirst, match_unsorted_outer(), JoinPathExtraData::mergeclause_list, SpecialJoinInfo::min_lefthand, NIL, JoinPathExtraData::param_source_rels, PGS_FOREIGNJOIN, PGS_HASHJOIN, RelOptInfo::pgs_mask, JoinPathExtraData::pgs_mask, PGS_MERGEJOIN_ANY, RelOptInfo::relids, RELOPT_OTHER_JOINREL, RelOptInfo::reloptkind, JoinPathExtraData::restrictlist, root, select_mergejoin_clauses(), JoinPathExtraData::semifactors, set_join_pathlist_hook, JoinPathExtraData::sjinfo, sort_inner_and_outer(), and RelOptInfo::top_parent_relids.
Referenced by populate_joinrel_with_paths().
◆ add_setop_child_rel_equivalences()
|
extern |
Definition at line 3083 of file equivclass.c.
3085{
3088
3090 {
3094
3096 continue;
3097
3100
3103
3104 /*
3105 * We can safely pass the parent member as the first member in the
3106 * ec_members list as this is added first in generate_union_paths,
3107 * likewise, the JoinDomain can be that of the initial member of the
3108 * Pathkey's EquivalenceClass. We pass -1 for ec_index since we
3109 * maintain the eclass_indexes for the child_rel after the loop.
3110 */
3112 pk->pk_eclass,
3113 -1,
3114 tle->expr,
3115 child_rel->relids,
3116 parent_em->em_jdomain,
3117 parent_em,
3119 child_rel->relid);
3120
3122 }
3123
3124 /*
3125 * transformSetOperationStmt() ensures that the targetlist never contains
3126 * any resjunk columns, so all eclasses that exist in 'root' must have
3127 * received a new member in the loop above. Add them to the child_rel's
3128 * eclass_indexes.
3129 */
3132}
Bitmapset * bms_add_range(Bitmapset *a, int lower, int upper)
Definition bitmapset.c:1018
Definition pathnodes.h:1787
Definition primnodes.h:2236
References add_child_eq_member(), bms_add_range(), elog, ERROR, exprType(), fb(), lfirst_node, linitial, list_head(), list_length(), lnext(), and root.
Referenced by build_setop_child_paths().
◆ append_pathkeys()
Definition at line 107 of file pathkeys.c.
108{
110
112
114 {
116
119 }
120 return target;
121}
static bool pathkey_is_redundant(PathKey *new_pathkey, List *pathkeys)
Definition pathkeys.c:159
References Assert, fb(), lappend(), lfirst_node, NIL, pathkey_is_redundant(), and source.
Referenced by adjust_group_pathkeys_for_groupagg(), and make_pathkeys_for_window().
◆ build_expression_pathkey()
|
extern |
Definition at line 1000 of file pathkeys.c.
1005{
1006 List *pathkeys;
1007 Oid opfamily,
1008 opcintype;
1009 CompareType cmptype;
1011
1012 /* Find the operator in pg_amop --- failure shouldn't happen */
1014 &opfamily, &opcintype, &cmptype))
1016 opno);
1017
1019 expr,
1020 opfamily,
1021 opcintype,
1023 (cmptype == COMPARE_GT),
1024 (cmptype == COMPARE_GT),
1025 0,
1026 rel,
1027 create_it);
1028
1031 else
1032 pathkeys = NIL;
1033
1034 return pathkeys;
1035}
bool get_ordering_op_properties(Oid opno, Oid *opfamily, Oid *opcintype, CompareType *cmptype)
Definition lsyscache.c:259
static PathKey * make_pathkey_from_sortinfo(PlannerInfo *root, Expr *expr, Oid opfamily, Oid opcintype, Oid collation, bool reverse_sort, bool nulls_first, Index sortref, Relids rel, bool create_it)
Definition pathkeys.c:198
References COMPARE_GT, elog, ERROR, exprCollation(), fb(), get_ordering_op_properties(), list_make1, make_pathkey_from_sortinfo(), NIL, and root.
Referenced by set_function_pathlist().
◆ build_index_pathkeys()
|
extern |
Definition at line 740 of file pathkeys.c.
743{
747
750
751 i = 0;
753 {
756 bool reverse_sort;
757 bool nulls_first;
759
760 /*
761 * INCLUDE columns are stored in index unordered, so they don't
762 * support ordered index scan.
763 */
765 break;
766
767 /* We assume we don't need to make a copy of the tlist item */
769
771 {
774 }
775 else
776 {
779 }
780
781 /*
782 * OK, try to make a canonical pathkey for this sort key.
783 */
785 indexkey,
789 reverse_sort,
790 nulls_first,
791 0,
792 index->rel->relids,
793 false);
794
796 {
797 /*
798 * We found the sort key in an EquivalenceClass, so it's relevant
799 * for this query. Add it to list, unless it's redundant.
800 */
803 }
804 else
805 {
806 /*
807 * Boolean index keys might be redundant even if they do not
808 * appear in an EquivalenceClass, because of our special treatment
809 * of boolean equality conditions --- see the comment for
810 * indexcol_is_bool_constant_for_query(). If that applies, we can
811 * continue to examine lower-order index columns. Otherwise, the
812 * sort key is not an interesting sort order for this query, so we
813 * should stop considering index columns; any lower-order sort
814 * keys won't be useful either.
815 */
817 break;
818 }
819
820 i++;
821 }
822
823 return retval;
824}
bool indexcol_is_bool_constant_for_query(PlannerInfo *root, IndexOptInfo *index, int indexcol)
Definition indxpath.c:4303
References fb(), i, indexcol_is_bool_constant_for_query(), lappend(), lfirst, make_pathkey_from_sortinfo(), NIL, pathkey_is_redundant(), root, and ScanDirectionIsBackward.
Referenced by build_index_paths().
◆ build_join_pathkeys()
|
extern |
Definition at line 1295 of file pathkeys.c.
1299{
1300 /* RIGHT_SEMI should not come here */
1302
1304 jointype == JOIN_RIGHT ||
1305 jointype == JOIN_RIGHT_ANTI)
1307
1308 /*
1309 * This used to be quite a complex bit of code, but now that all pathkey
1310 * sublists start out life canonicalized, we don't have to do a darn thing
1311 * here!
1312 *
1313 * We do, however, need to truncate the pathkeys list, since it may
1314 * contain pathkeys that were useful for forming this joinrel but are
1315 * uninteresting to higher levels.
1316 */
1318}
List * truncate_useless_pathkeys(PlannerInfo *root, RelOptInfo *rel, List *pathkeys)
Definition pathkeys.c:2200
References Assert, fb(), JOIN_FULL, JOIN_RIGHT, JOIN_RIGHT_ANTI, JOIN_RIGHT_SEMI, NIL, root, and truncate_useless_pathkeys().
Referenced by consider_parallel_mergejoin(), consider_parallel_nestloop(), match_unsorted_outer(), and sort_inner_and_outer().
◆ build_partition_pathkeys()
|
extern |
Definition at line 919 of file pathkeys.c.
921{
925
928 /* For now, we can only cope with baserels */
930
932 {
935
936 /*
937 * Try to make a canonical pathkey for this partkey.
938 *
939 * We assume the PartitionDesc lists any NULL partition last, so we
940 * treat the scan like a NULLS LAST index: we have nulls_first for
941 * backwards scan only.
942 */
944 keyCol,
950 0,
951 partrel->relids,
952 false);
953
954
956 {
957 /*
958 * We found the sort key in an EquivalenceClass, so it's relevant
959 * for this query. Add it to list, unless it's redundant.
960 */
963 }
964 else
965 {
966 /*
967 * Boolean partition keys might be redundant even if they do not
968 * appear in an EquivalenceClass, because of our special treatment
969 * of boolean equality conditions --- see the comment for
970 * partkey_is_bool_constant_for_query(). If that applies, we can
971 * continue to examine lower-order partition keys. Otherwise, the
972 * sort key is not an interesting sort order for this query, so we
973 * should stop considering partition columns; any lower-order sort
974 * keys won't be useful either.
975 */
977 {
979 return retval;
980 }
981 }
982 }
983
985 return retval;
986}
bool partitions_are_ordered(PartitionBoundInfo boundinfo, Bitmapset *live_parts)
Definition partbounds.c:2845
static bool partkey_is_bool_constant_for_query(RelOptInfo *partrel, int partkeycol)
Definition pathkeys.c:844
Definition pathnodes.h:705
References Assert, fb(), i, IS_SIMPLE_REL, lappend(), linitial, RelOptInfo::live_parts, make_pathkey_from_sortinfo(), NIL, partitions_are_ordered(), partkey_is_bool_constant_for_query(), pathkey_is_redundant(), RelOptInfo::relids, root, and ScanDirectionIsBackward.
Referenced by generate_orderedappend_paths().
◆ canonicalize_ec_expression()
Definition at line 545 of file equivclass.c.
546{
548
549 /*
550 * For a polymorphic-input-type opclass, just keep the same exposed type.
551 * RECORD opclasses work like polymorphic-type ones for this purpose.
552 */
555
556 /*
557 * No work if the expression exposes the right type/collation already.
558 */
561 {
562 /*
563 * If we have to change the type of the expression, set typmod to -1,
564 * since the new type may not have the same typmod interpretation.
565 * When we only have to change collation, preserve the exposed typmod.
566 */
568
570 req_typmod = -1;
571 else
573
574 /*
575 * Use applyRelabelType so that we preserve const-flatness. This is
576 * important since eval_const_expressions has already been applied.
577 */
581 }
582
583 return expr;
584}
Node * applyRelabelType(Node *arg, Oid rtype, int32 rtypmod, Oid rcollid, CoercionForm rformat, int rlocation, bool overwrite_ok)
Definition nodeFuncs.c:636
References applyRelabelType(), COERCE_IMPLICIT_CAST, exprCollation(), exprType(), exprTypmod(), and fb().
Referenced by convert_subquery_pathkeys(), get_eclass_for_sort_expr(), and process_equivalence().
◆ check_index_predicates()
|
extern |
Definition at line 3941 of file indxpath.c.
3942{
3948
3949 /* Indexes are available only on base or "other" member relations. */
3951
3952 /*
3953 * Initialize the indrestrictinfo lists to be identical to
3954 * baserestrictinfo, and check whether there are any partial indexes. If
3955 * not, this is all we need to do.
3956 */
3959 {
3961
3965 }
3967 return;
3968
3969 /*
3970 * Construct a list of clauses that we can assume true for the purpose of
3971 * proving the index(es) usable. Restriction clauses for the rel are
3972 * always usable, and so are any join clauses that are "movable to" this
3973 * rel. Also, we can consider any EC-derivable join clauses (which must
3974 * be "movable to" this rel, by definition).
3975 */
3977
3978 /* Scan the rel's join clauses */
3980 {
3982
3983 /* Check if clause can be moved to this rel */
3985 continue;
3986
3988 }
3989
3990 /*
3991 * Add on any equivalence-derivable join clauses. Computing the correct
3992 * relid sets for generate_join_implied_equalities is slightly tricky
3993 * because the rel could be a child rel rather than a true baserel, and in
3994 * that case we must subtract its parents' relid(s) from all_query_rels.
3995 * Additionally, we mustn't consider clauses that are only computable
3996 * after outer joins that can null the rel.
3997 */
4001 else
4004
4006 clauselist =
4010 otherrels),
4011 otherrels,
4012 rel,
4013 NULL));
4014
4015 /*
4016 * Normally we remove quals that are implied by a partial index's
4017 * predicate from indrestrictinfo, indicating that they need not be
4018 * checked explicitly by an indexscan plan using this index. However, if
4019 * the rel is a target relation of UPDATE/DELETE/MERGE/SELECT FOR UPDATE,
4020 * we cannot remove such quals from the plan, because they need to be in
4021 * the plan so that they will be properly rechecked by EvalPlanQual
4022 * testing. Some day we might want to remove such quals from the main
4023 * plan anyway and pass them through to EvalPlanQual via a side channel;
4024 * but for now, we just don't remove implied quals at all for target
4025 * relations.
4026 */
4029
4030 /*
4031 * Now try to prove each index predicate true, and compute the
4032 * indrestrictinfo lists for partial indexes. Note that we compute the
4033 * indrestrictinfo list even for non-predOK indexes; this might seem
4034 * wasteful, but we may be able to use such indexes in OR clauses, cf
4035 * generate_bitmap_or_paths().
4036 */
4038 {
4041
4043 continue; /* ignore non-partial indexes here */
4044
4047 false);
4048
4049 /* If rel is an update target, leave indrestrictinfo as set above */
4051 continue;
4052
4053 /*
4054 * If index is !amoptionalkey, also leave indrestrictinfo as set
4055 * above. Otherwise we risk removing all quals for the first index
4056 * key and then not being able to generate an indexscan at all. It
4057 * would be better to be more selective, but we've not yet identified
4058 * which if any of the quals match the first index key.
4059 */
4061 continue;
4062
4063 /* Else compute indrestrictinfo as the non-implied quals */
4066 {
4068
4069 /* predicate_implied_by() assumes first arg is immutable */
4074 }
4075 }
4076}
Bitmapset * bms_del_members(Bitmapset *a, const Bitmapset *b)
Definition bitmapset.c:1160
List * generate_join_implied_equalities(PlannerInfo *root, Relids join_relids, Relids outer_relids, RelOptInfo *inner_rel, SpecialJoinInfo *sjinfo)
Definition equivclass.c:1549
bool predicate_implied_by(List *predicate_list, List *clause_list, bool weak)
Definition predtest.c:152
PlanRowMark * get_plan_rowmark(List *rowmarks, Index rtindex)
Definition preptlist.c:526
Relids find_childrel_parents(PlannerInfo *root, RelOptInfo *rel)
Definition relnode.c:1657
bool join_clause_is_movable_to(RestrictInfo *rinfo, RelOptInfo *baserel)
Definition restrictinfo.c:575
Definition pathnodes.h:1329
Definition pathnodes.h:2864
References Assert, RelOptInfo::baserestrictinfo, bms_del_members(), bms_difference(), bms_is_empty, bms_is_member(), bms_union(), RestrictInfo::clause, contain_mutable_functions(), fb(), find_childrel_parents(), generate_join_implied_equalities(), get_plan_rowmark(), RelOptInfo::indexlist, IS_SIMPLE_REL, join_clause_is_movable_to(), RelOptInfo::joininfo, lappend(), lfirst, list_concat(), list_copy(), list_make1, NIL, RelOptInfo::nulling_relids, predicate_implied_by(), RelOptInfo::relid, RelOptInfo::relids, RELOPT_OTHER_MEMBER_REL, RelOptInfo::reloptkind, and root.
Referenced by set_plain_rel_size(), and set_tablesample_rel_size().
◆ compare_pathkeys()
|
extern |
Definition at line 304 of file pathkeys.c.
305{
307 *key2;
308
309 /*
310 * Fall out quickly if we are passed two identical lists. This mostly
311 * catches the case where both are NIL, but that's common enough to
312 * warrant the test.
313 */
316
318 {
321
324 }
325
326 /*
327 * If we reached the end of only one list, the other is longer and
328 * therefore not a subset.
329 */
335}
References fb(), forboth, lfirst, PATHKEYS_BETTER1, PATHKEYS_BETTER2, PATHKEYS_DIFFERENT, and PATHKEYS_EQUAL.
Referenced by add_partial_path(), add_partial_path_precheck(), add_path(), add_path_precheck(), add_paths_to_append_rel(), adjust_group_pathkeys_for_groupagg(), get_useful_group_keys_orderings(), get_useful_pathkeys_for_distinct(), pathkeys_contained_in(), and set_cheapest().
◆ compute_parallel_worker()
|
extern |
Definition at line 4726 of file allpaths.c.
4728{
4729 int parallel_workers = 0;
4730
4731 /*
4732 * If the user has set the parallel_workers reloption, use that; otherwise
4733 * select a default number of workers.
4734 */
4736 parallel_workers = rel->rel_parallel_workers;
4737 else
4738 {
4739 /*
4740 * If the number of pages being scanned is insufficient to justify a
4741 * parallel scan, just return zero ... unless it's an inheritance
4742 * child. In that case, we want to generate a parallel path here
4743 * anyway. It might not be worthwhile just for this relation, but
4744 * when combined with all of its inheritance siblings it may well pay
4745 * off.
4746 */
4750 return 0;
4751
4753 {
4756
4757 /*
4758 * Select the number of workers based on the log of the size of
4759 * the relation. This probably needs to be a good deal more
4760 * sophisticated, but we need something here for now. Note that
4761 * the upper limit of the min_parallel_table_scan_size GUC is
4762 * chosen to prevent overflow here.
4763 */
4766 {
4767 heap_parallel_workers++;
4768 heap_parallel_threshold *= 3;
4770 break; /* avoid overflow */
4771 }
4772
4773 parallel_workers = heap_parallel_workers;
4774 }
4775
4777 {
4780
4781 /* same calculation as for heap_pages above */
4784 {
4785 index_parallel_workers++;
4786 index_parallel_threshold *= 3;
4788 break; /* avoid overflow */
4789 }
4790
4791 if (parallel_workers > 0)
4793 else
4794 parallel_workers = index_parallel_workers;
4795 }
4796 }
4797
4798 /* In no case use more than caller supplied maximum number of workers */
4800
4801 return parallel_workers;
4802}
References fb(), Max, Min, min_parallel_index_scan_size, min_parallel_table_scan_size, RelOptInfo::rel_parallel_workers, RELOPT_BASEREL, and RelOptInfo::reloptkind.
Referenced by cost_index(), create_partial_bitmap_paths(), create_plain_partial_paths(), create_tidscan_paths(), and plan_create_index_workers().
◆ convert_subquery_pathkeys()
|
extern |
Definition at line 1054 of file pathkeys.c.
1057{
1062
1064 {
1068
1070 {
1071 /*
1072 * If the sub_pathkey's EquivalenceClass is volatile, then it must
1073 * have come from an ORDER BY clause, and we have to match it to
1074 * that same targetlist entry.
1075 */
1078
1083 /* Is TLE actually available to the outer query? */
1086 {
1087 /* We can represent this sub_pathkey */
1090
1093
1094 /*
1095 * Note: it might look funny to be setting sortref = 0 for a
1096 * reference to a volatile sub_eclass. However, the
1097 * expression is *not* volatile in the outer query: it's just
1098 * a Var referencing whatever the subquery emitted. (IOW, the
1099 * outer query isn't going to re-execute the volatile
1100 * expression itself.) So this is okay.
1101 */
1102 outer_ec =
1105 sub_eclass->ec_opfamilies,
1106 sub_member->em_datatype,
1107 sub_eclass->ec_collation,
1108 0,
1109 rel->relids,
1110 false);
1111
1112 /*
1113 * If we don't find a matching EC, sub-pathkey isn't
1114 * interesting to the outer query
1115 */
1117 best_pathkey =
1119 outer_ec,
1120 sub_pathkey->pk_opfamily,
1121 sub_pathkey->pk_cmptype,
1122 sub_pathkey->pk_nulls_first);
1123 }
1124 }
1125 else
1126 {
1127 /*
1128 * Otherwise, the sub_pathkey's EquivalenceClass could contain
1129 * multiple elements (representing knowledge that multiple items
1130 * are effectively equal). Each element might match none, one, or
1131 * more of the output columns that are visible to the outer query.
1132 * This means we may have multiple possible representations of the
1133 * sub_pathkey in the context of the outer query. Ideally we
1134 * would generate them all and put them all into an EC of the
1135 * outer query, thereby propagating equality knowledge up to the
1136 * outer query. Right now we cannot do so, because the outer
1137 * query's EquivalenceClasses are already frozen when this is
1138 * called. Instead we prefer the one that has the highest "score"
1139 * (number of EC peers, plus one if it matches the outer
1140 * query_pathkeys). This is the most likely to be useful in the
1141 * outer query.
1142 */
1145
1146 /* Ignore children here */
1148 {
1153 ListCell *k;
1154
1155 /* Child members should not exist in ec_members */
1157
1159 {
1166
1167 /* Is TLE actually available to the outer query? */
1170 continue;
1171
1172 /*
1173 * The targetlist entry is considered to match if it
1174 * matches after sort-key canonicalization. That is
1175 * needed since the sub_expr has been through the same
1176 * process.
1177 */
1179 sub_expr_type,
1180 sub_expr_coll);
1182 continue;
1183
1184 /* See if we have a matching EC for the TLE */
1187 sub_eclass->ec_opfamilies,
1188 sub_expr_type,
1189 sub_expr_coll,
1190 0,
1191 rel->relids,
1192 false);
1193
1194 /*
1195 * If we don't find a matching EC, this sub-pathkey isn't
1196 * interesting to the outer query
1197 */
1199 continue;
1200
1202 outer_ec,
1203 sub_pathkey->pk_opfamily,
1204 sub_pathkey->pk_cmptype,
1205 sub_pathkey->pk_nulls_first);
1206 /* score = # of equivalence peers */
1208 /* +1 if it matches the proper query_pathkeys item */
1211 score++;
1213 {
1216 }
1217 }
1218 }
1219 }
1220
1221 /*
1222 * If we couldn't find a representation of this sub_pathkey, we're
1223 * done (we can't use the ones to its right, either).
1224 */
1226 break;
1227
1228 /*
1229 * Eliminate redundant ordering info; could happen if outer query
1230 * equivalences subquery keys...
1231 */
1233 {
1235 retvallen++;
1236 }
1237 }
1238
1239 return retval;
1240}
EquivalenceClass * get_eclass_for_sort_expr(PlannerInfo *root, Expr *expr, List *opfamilies, Oid opcintype, Oid collation, Index sortref, Relids rel, bool create_it)
Definition equivclass.c:736
Expr * canonicalize_ec_expression(Expr *expr, Oid req_type, Oid req_collation)
Definition equivclass.c:545
PathKey * make_canonical_pathkey(PlannerInfo *root, EquivalenceClass *eclass, Oid opfamily, CompareType cmptype, bool nulls_first)
Definition pathkeys.c:56
static Var * find_var_for_subquery_tle(RelOptInfo *rel, TargetEntry *tle)
Definition pathkeys.c:1252
Definition primnodes.h:262
TargetEntry * get_sortgroupref_tle(Index sortref, List *targetList)
Definition tlist.c:354
References Assert, canonicalize_ec_expression(), elog, equal(), ERROR, fb(), find_var_for_subquery_tle(), get_eclass_for_sort_expr(), get_sortgroupref_tle(), i, j, lappend(), lfirst, linitial, list_length(), list_nth(), make_canonical_pathkey(), NIL, pathkey_is_redundant(), RelOptInfo::relids, and root.
Referenced by build_setop_child_paths(), set_cte_pathlist(), and set_subquery_pathlist().
◆ create_index_paths()
|
extern |
Definition at line 240 of file indxpath.c.
241{
250
251 /* Skip the whole mess if no indexes */
253 return;
254
255 /* Bitmap paths are collected and then dealt with at the end */
257
258 /* Examine each index in turn */
260 {
262
263 /* Protect limited-size array in IndexClauseSets */
265
266 /*
267 * Ignore partial indexes that do not match the query.
268 * (generate_bitmap_or_paths() might be able to do something with
269 * them, but that's of no concern here.)
270 */
272 continue;
273
274 /*
275 * Identify the restriction clauses that can match the index.
276 */
279
280 /*
281 * Build index paths from the restriction clauses. These will be
282 * non-parameterized paths. Plain paths go directly to add_path(),
283 * bitmap paths are added to bitindexpaths to be handled below.
284 */
286 &bitindexpaths);
287
288 /*
289 * Identify the join clauses that can match the index. For the moment
290 * we keep them separate from the restriction clauses. Note that this
291 * step finds only "loose" join clauses that have not been merged into
292 * EquivalenceClasses. Also, collect join OR clauses for later.
293 */
297
298 /*
299 * Look for EquivalenceClasses that can generate joinclauses matching
300 * the index.
301 */
304 &eclauseset);
305
306 /*
307 * If we found any plain or eclass join clauses, build parameterized
308 * index paths using them.
309 */
312 &rclauseset,
313 &jclauseset,
314 &eclauseset,
315 &bitjoinpaths);
316 }
317
318 /*
319 * Generate BitmapOrPaths for any suitable OR-clauses present in the
320 * restriction list. Add these to bitindexpaths.
321 */
325
326 /*
327 * Likewise, generate BitmapOrPaths for any suitable OR-clauses present in
328 * the joinclause list. Add these to bitjoinpaths.
329 */
333
334 /*
335 * If we found anything usable, generate a BitmapHeapPath for the most
336 * promising combination of restriction bitmap index paths. Note there
337 * will be only one such path no matter how many indexes exist. This
338 * should be sufficient since there's basically only one figure of merit
339 * (total cost) for such a path.
340 */
342 {
343 Path *bitmapqual;
345
348 rel->lateral_relids, 1.0, 0);
350
351 /* create a partial bitmap heap path */
354 }
355
356 /*
357 * Likewise, if we found anything usable, generate BitmapHeapPaths for the
358 * most promising combinations of join bitmap index paths. Our strategy
359 * is to generate one such path for each distinct parameterization seen
360 * among the available bitmap index paths. This may look pretty
361 * expensive, but usually there won't be very many distinct
362 * parameterizations. (This logic is quite similar to that in
363 * consider_index_join_clauses, but we're working with whole paths not
364 * individual clauses.)
365 */
367 {
369
370 /* Identify each distinct parameterization seen in bitjoinpaths */
373 {
376
378 required_outer);
379 }
380
381 /* Now, for each distinct parameterization set ... */
383 {
386 Path *bitmapqual;
391
392 /* Identify all the bitmap join paths needing no more than that */
395 {
397
400 }
401
402 /*
403 * Add in restriction bitmap paths, since they can be used
404 * together with any join paths.
405 */
407
408 /* Select best AND combination for this parameterization */
410
411 /* And push that path into the mix */
417 }
418 }
419}
void create_partial_bitmap_paths(PlannerInfo *root, RelOptInfo *rel, Path *bitmapqual)
Definition allpaths.c:4690
static Path * choose_bitmap_and(PlannerInfo *root, RelOptInfo *rel, List *paths)
Definition indxpath.c:1785
static void match_join_clauses_to_index(PlannerInfo *root, RelOptInfo *rel, IndexOptInfo *index, IndexClauseSet *clauseset, List **joinorclauses)
Definition indxpath.c:2481
static void match_eclass_clauses_to_index(PlannerInfo *root, IndexOptInfo *index, IndexClauseSet *clauseset)
Definition indxpath.c:2515
static void get_index_paths(PlannerInfo *root, RelOptInfo *rel, IndexOptInfo *index, IndexClauseSet *clauses, List **bitindexpaths)
Definition indxpath.c:716
static double get_loop_count(PlannerInfo *root, Index cur_relid, Relids outer_relids)
Definition indxpath.c:2326
static void consider_index_join_clauses(PlannerInfo *root, RelOptInfo *rel, IndexOptInfo *index, IndexClauseSet *rclauseset, IndexClauseSet *jclauseset, IndexClauseSet *eclauseset, List **bitindexpaths)
Definition indxpath.c:437
static void match_restriction_clauses_to_index(PlannerInfo *root, IndexOptInfo *index, IndexClauseSet *clauseset)
Definition indxpath.c:2465
static List * generate_bitmap_or_paths(PlannerInfo *root, RelOptInfo *rel, List *clauses, List *other_clauses)
Definition indxpath.c:1629
BitmapHeapPath * create_bitmap_heap_path(PlannerInfo *root, RelOptInfo *rel, Path *bitmapqual, Relids required_outer, double loop_count, int parallel_degree)
Definition pathnode.c:1096
Definition pathnodes.h:2109
Definition indxpath.c:53
References add_path(), Assert, RelOptInfo::baserestrictinfo, bms_is_subset(), choose_bitmap_and(), consider_index_join_clauses(), RelOptInfo::consider_parallel, create_bitmap_heap_path(), create_partial_bitmap_paths(), fb(), generate_bitmap_or_paths(), get_index_paths(), get_loop_count(), INDEX_MAX_KEYS, RelOptInfo::indexlist, lappend(), RelOptInfo::lateral_relids, lfirst, list_append_unique(), list_concat(), match_eclass_clauses_to_index(), match_join_clauses_to_index(), match_restriction_clauses_to_index(), MemSet, NIL, PATH_REQ_OUTER, RelOptInfo::relid, and root.
Referenced by set_plain_rel_pathlist().
◆ create_partial_bitmap_paths()
|
extern |
Definition at line 4690 of file allpaths.c.
4692{
4693 int parallel_workers;
4695
4696 /* Compute heap pages for bitmap heap scan */
4699
4702
4703 if (parallel_workers <= 0)
4704 return;
4705
4707 bitmapqual, rel->lateral_relids, 1.0, parallel_workers));
4708}
int compute_parallel_worker(RelOptInfo *rel, double heap_pages, double index_pages, int max_workers)
Definition allpaths.c:4726
double compute_bitmap_pages(PlannerInfo *root, RelOptInfo *baserel, Path *bitmapqual, double loop_count, Cost *cost_p, double *tuples_p)
Definition costsize.c:6661
References add_partial_path(), compute_bitmap_pages(), compute_parallel_worker(), create_bitmap_heap_path(), fb(), RelOptInfo::lateral_relids, max_parallel_workers_per_gather, and root.
Referenced by create_index_paths().
◆ create_tidscan_paths()
|
extern |
Definition at line 497 of file tidpath.c.
498{
499 List *tidquals;
500 List *tidrangequals;
503
504 /*
505 * If any suitable quals exist in the rel's baserestrict list, generate a
506 * plain (unparameterized) TidPath with them.
507 *
508 * We skip this when TID scans are disabled, except when the qual is
509 * CurrentOfExpr. In that case, a TID scan is the only correct path.
510 */
512 &isCurrentOf);
513
515 {
516 /*
517 * This path uses no join clauses, but it could still have required
518 * parameterization due to LATERAL refs in its tlist.
519 */
521
523 required_outer));
524
525 /*
526 * When the qual is CurrentOfExpr, the path that we just added is the
527 * only one the executor can handle, so we should return before adding
528 * any others. Returning true lets the caller know not to add any
529 * others, either.
530 */
532 return true;
533 }
534
535 /* Skip the rest if TID scans are disabled. */
536 if (!enabled)
537 return false;
538
539 /*
540 * If there are range quals in the baserestrict list, generate a
541 * TidRangePath.
542 */
544 rel);
545
547 {
548 /*
549 * This path uses no join clauses, but it could still have required
550 * parameterization due to LATERAL refs in its tlist.
551 */
553
555 tidrangequals,
556 required_outer,
557 0));
558
559 /* If appropriate, consider parallel tid range scan. */
561 {
562 int parallel_workers;
563
566
567 if (parallel_workers > 0)
569 rel,
570 tidrangequals,
571 required_outer,
572 parallel_workers));
573 }
574 }
575
576 /*
577 * Try to generate parameterized TidPaths using equality clauses extracted
578 * from EquivalenceClasses. (This is important since simple "t1.ctid =
579 * t2.ctid" clauses will turn into ECs.)
580 */
582 {
583 List *clauses;
584
585 /* Generate clauses, skipping any that join to lateral_referencers */
587 rel,
589 NULL,
590 rel->lateral_referencers);
591
592 /* Generate a path for each usable join clause */
594 }
595
596 /*
597 * Also consider parameterized TidPaths using "loose" join quals. Quals
598 * of the form "t1.ctid = t2.ctid" would turn into these if they are outer
599 * join quals, for example.
600 */
602
603 return false;
604}
List * generate_implied_equalities_for_column(PlannerInfo *root, RelOptInfo *rel, ec_matches_callback_type callback, void *callback_arg, Relids prohibited_rels)
Definition equivclass.c:3238
TidRangePath * create_tidrangescan_path(PlannerInfo *root, RelOptInfo *rel, List *tidrangequals, Relids required_outer, int parallel_workers)
Definition pathnode.c:1262
TidPath * create_tidscan_path(PlannerInfo *root, RelOptInfo *rel, List *tidquals, Relids required_outer)
Definition pathnode.c:1233
static List * TidQualFromRestrictInfoList(PlannerInfo *root, List *rlist, RelOptInfo *rel, bool *isCurrentOf)
Definition tidpath.c:281
static void BuildParameterizedTidPaths(PlannerInfo *root, RelOptInfo *rel, List *clauses)
Definition tidpath.c:426
static List * TidRangeQualFromRestrictInfoList(List *rlist, RelOptInfo *rel)
Definition tidpath.c:398
static bool ec_member_matches_ctid(PlannerInfo *root, RelOptInfo *rel, EquivalenceClass *ec, EquivalenceMember *em, void *arg)
Definition tidpath.c:481
References add_partial_path(), add_path(), RelOptInfo::baserestrictinfo, BuildParameterizedTidPaths(), compute_parallel_worker(), RelOptInfo::consider_parallel, create_tidrangescan_path(), create_tidscan_path(), ec_member_matches_ctid(), fb(), generate_implied_equalities_for_column(), RelOptInfo::has_eclass_joins, RelOptInfo::joininfo, RelOptInfo::lateral_referencers, RelOptInfo::lateral_relids, max_parallel_workers_per_gather, NIL, RelOptInfo::pages, RelOptInfo::pgs_mask, PGS_TIDSCAN, root, TidQualFromRestrictInfoList(), and TidRangeQualFromRestrictInfoList().
Referenced by set_plain_rel_pathlist().
◆ ec_clear_derived_clauses()
|
extern |
Definition at line 3830 of file equivclass.c.
3831{
3834
3836 {
3839 }
3840}
References EquivalenceClass::ec_derives_hash, EquivalenceClass::ec_derives_list, fb(), list_free(), and NIL.
Referenced by process_equivalence(), remove_rel_from_eclass(), and update_eclasses().
◆ eclass_member_iterator_next()
|
extern |
Definition at line 3174 of file equivclass.c.
3175{
3177 {
3179 {
3181
3182 nextcell:
3186 }
3187
3188 /* Search for the next list to return members from */
3190 {
3191 /*
3192 * Be paranoid in case we're given relids above what we've sized
3193 * the ec_childmembers array to.
3194 */
3197
3199
3200 /* If there are members in this list, use it. */
3202 {
3203 /* point current_cell to the head of this list */
3206 }
3207 }
3209 }
3210
3212}
References bms_next_member(), fb(), lfirst_node, list_head(), lnext(), and NIL.
Referenced by find_computable_ec_member(), find_ec_member_matching_expr(), find_em_for_rel(), generate_implied_equalities_for_column(), generate_join_implied_equalities_normal(), get_eclass_for_sort_expr(), and match_pathkeys_to_index().
◆ eclass_useful_for_merging()
|
extern |
Definition at line 3489 of file equivclass.c.
3492{
3493 Relids relids;
3495
3497
3498 /*
3499 * Won't generate joinclauses if const or single-member (the latter test
3500 * covers the volatile case too)
3501 */
3503 return false;
3504
3505 /*
3506 * Note we don't test ec_broken; if we did, we'd need a separate code path
3507 * to look through ec_sources. Checking the members anyway is OK as a
3508 * possibly-overoptimistic heuristic.
3509 */
3510
3511 /* If specified rel is a child, we must consider the topmost parent rel */
3513 {
3515 relids = rel->top_parent_relids;
3516 }
3517 else
3518 relids = rel->relids;
3519
3520 /* If rel already includes all members of eclass, no point in searching */
3522 return false;
3523
3524 /*
3525 * To join, we need a member not in the given rel. Ignore children here.
3526 */
3528 {
3530
3531 /* Child members should not exist in ec_members */
3533
3535 return true;
3536 }
3537
3538 return false;
3539}
References Assert, bms_is_empty, bms_is_subset(), bms_overlap(), eclass(), fb(), IS_OTHER_REL, lfirst, list_length(), RelOptInfo::relids, and RelOptInfo::top_parent_relids.
Referenced by get_useful_ecs_for_relation(), and pathkeys_useful_for_merging().
◆ exprs_known_equal()
|
extern |
Definition at line 2647 of file equivclass.c.
2648{
2650
2652 {
2657
2658 /* Never match to a volatile EC */
2660 continue;
2661
2662 /*
2663 * It's okay to consider ec_broken ECs here. Brokenness just means we
2664 * couldn't derive all the implied clauses we'd have liked to; it does
2665 * not invalidate our knowledge that the members are equal.
2666 */
2667
2668 /* Ignore if this EC doesn't use specified opfamily */
2671 continue;
2672
2673 /* Ignore children here */
2675 {
2677
2678 /* Child members should not exist in ec_members */
2684 /* Exit as soon as equality is proven */
2686 return true;
2687 }
2688 }
2689 return false;
2690}
References Assert, EquivalenceClass::ec_has_volatile, EquivalenceClass::ec_members, EquivalenceClass::ec_opfamilies, equal(), fb(), lfirst, list_member_oid(), OidIsValid, and root.
Referenced by add_unique_group_var(), and have_partkey_equi_join().
◆ find_computable_ec_member()
|
extern |
Definition at line 991 of file equivclass.c.
996{
1000
1001 /*
1002 * Pull out the Vars and quasi-Vars present in "exprs". In the typical
1003 * non-appendrel case, this is just another representation of the same
1004 * list. However, it does remove the distinction between the case of a
1005 * list of plain expressions and a list of TargetEntrys.
1006 */
1008 PVC_INCLUDE_AGGREGATES |
1009 PVC_INCLUDE_WINDOWFUNCS |
1010 PVC_INCLUDE_PLACEHOLDERS);
1011
1014 {
1017
1018 /*
1019 * We shouldn't be trying to sort by an equivalence class that
1020 * contains a constant, so no need to consider such cases any further.
1021 */
1023 continue;
1024
1025 /*
1026 * Ignore child members unless they belong to the requested rel.
1027 */
1030 continue;
1031
1032 /*
1033 * Match if all Vars and quasi-Vars are present in "exprs".
1034 */
1036 PVC_INCLUDE_AGGREGATES |
1037 PVC_INCLUDE_WINDOWFUNCS |
1038 PVC_INCLUDE_PLACEHOLDERS);
1040 {
1042 break;
1043 }
1046 continue; /* we hit a non-available Var */
1047
1048 /*
1049 * If requested, reject expressions that are not parallel-safe. We
1050 * check this last because it's a rather expensive test.
1051 */
1054 continue;
1055
1057 }
1058
1060}
void setup_eclass_member_iterator(EquivalenceMemberIterator *it, EquivalenceClass *ec, Relids child_relids)
Definition equivclass.c:3155
EquivalenceMember * eclass_member_iterator_next(EquivalenceMemberIterator *it)
Definition equivclass.c:3174
Definition pathnodes.h:1760
References bms_is_subset(), eclass_member_iterator_next(), fb(), is_parallel_safe(), lfirst, list_free(), list_member(), pull_var_clause(), PVC_INCLUDE_AGGREGATES, PVC_INCLUDE_PLACEHOLDERS, PVC_INCLUDE_WINDOWFUNCS, root, and setup_eclass_member_iterator().
Referenced by prepare_sort_from_pathkeys(), and relation_can_be_sorted_early().
◆ find_derived_clause_for_ec_member()
|
extern |
Definition at line 2803 of file equivclass.c.
2806{
2809
2811}
static RestrictInfo * ec_search_derived_clause_for_ems(PlannerInfo *root, EquivalenceClass *ec, EquivalenceMember *leftem, EquivalenceMember *rightem, EquivalenceClass *parent_ec)
Definition equivclass.c:3892
References Assert, EquivalenceClass::ec_has_const, ec_search_derived_clause_for_ems(), fb(), and root.
Referenced by get_foreign_key_join_selectivity().
◆ find_ec_member_matching_expr()
|
extern |
Definition at line 916 of file equivclass.c.
919{
922
923 /* We ignore binary-compatible relabeling on both ends */
925 expr = ((RelabelType *) expr)->arg;
926
929 {
931
932 /*
933 * We shouldn't be trying to sort by an equivalence class that
934 * contains a constant, so no need to consider such cases any further.
935 */
937 continue;
938
939 /*
940 * Ignore child members unless they belong to the requested rel.
941 */
944 continue;
945
946 /*
947 * Match if same expression (after stripping relabel).
948 */
952
955 }
956
958}
Definition primnodes.h:1215
References bms_is_subset(), eclass_member_iterator_next(), equal(), fb(), IsA, and setup_eclass_member_iterator().
Referenced by make_unique_from_pathkeys(), prepare_sort_from_pathkeys(), and relation_can_be_sorted_early().
◆ find_mergeclauses_for_outer_pathkeys()
|
extern |
Definition at line 1544 of file pathkeys.c.
1547{
1550
1551 /* make sure we have eclasses cached in the clauses */
1553 {
1555
1557 }
1558
1560 {
1565
1566 /*----------
1567 * A mergejoin clause matches a pathkey if it has the same EC.
1568 * If there are multiple matching clauses, take them all. In plain
1569 * inner-join scenarios we expect only one match, because
1570 * equivalence-class processing will have removed any redundant
1571 * mergeclauses. However, in outer-join scenarios there might be
1572 * multiple matches. An example is
1573 *
1574 * select * from a full join b
1575 * on a.v1 = b.v1 and a.v2 = b.v2 and a.v1 = b.v2;
1576 *
1577 * Given the pathkeys ({a.v1}, {a.v2}) it is okay to return all three
1578 * clauses (in the order a.v1=b.v1, a.v1=b.v2, a.v2=b.v2) and indeed
1579 * we *must* do so or we will be unable to form a valid plan.
1580 *
1581 * We expect that the given pathkeys list is canonical, which means
1582 * no two members have the same EC, so it's not possible for this
1583 * code to enter the same mergeclause into the result list twice.
1584 *
1585 * It's possible that multiple matching clauses might have different
1586 * ECs on the other side, in which case the order we put them into our
1587 * result makes a difference in the pathkeys required for the inner
1588 * input rel. However this routine hasn't got any info about which
1589 * order would be best, so we don't worry about that.
1590 *
1591 * It's also possible that the selected mergejoin clauses produce
1592 * a noncanonical ordering of pathkeys for the inner side, ie, we
1593 * might select clauses that reference b.v1, b.v2, b.v1 in that
1594 * order. This is not harmful in itself, though it suggests that
1595 * the clauses are partially redundant. Since the alternative is
1596 * to omit mergejoin clauses and thereby possibly fail to generate a
1597 * plan altogether, we live with it. make_inner_pathkeys_for_merge()
1598 * has to delete duplicates when it constructs the inner pathkeys
1599 * list, and we also have to deal with such cases specially in
1600 * create_mergejoin_plan().
1601 *----------
1602 */
1604 {
1607
1608 clause_ec = rinfo->outer_is_left ?
1609 rinfo->left_ec : rinfo->right_ec;
1612 }
1613
1614 /*
1615 * If we didn't find a mergeclause, we're done --- any additional
1616 * sort-key positions in the pathkeys are useless. (But we can still
1617 * mergejoin if we found at least one mergeclause.)
1618 */
1620 break;
1621
1622 /*
1623 * If we did find usable mergeclause(s) for this sort-key position,
1624 * add them to result list.
1625 */
1627 }
1628
1629 return mergeclauses;
1630}
void update_mergeclause_eclasses(PlannerInfo *root, RestrictInfo *restrictinfo)
Definition pathkeys.c:1510
References fb(), i, j, lappend(), lfirst, list_concat(), NIL, root, and update_mergeclause_eclasses().
Referenced by generate_mergejoin_paths(), and sort_inner_and_outer().
◆ generate_base_implied_equalities()
|
extern |
Definition at line 1187 of file equivclass.c.
1188{
1191
1192 /*
1193 * At this point, we're done absorbing knowledge of equivalences in the
1194 * query, so no further EC merging should happen, and ECs remaining in the
1195 * eq_classes list can be considered canonical. (But note that it's still
1196 * possible for new single-member ECs to be added through
1197 * get_eclass_for_sort_expr().)
1198 */
1200
1201 ec_index = 0;
1203 {
1207
1210
1211 /*
1212 * Generate implied equalities that are restriction clauses.
1213 * Single-member ECs won't generate any deductions, either here or at
1214 * the join level.
1215 */
1217 {
1220 else
1222
1223 /* Recover if we failed to generate required derived clauses */
1226
1227 /* Detect whether this EC might generate join clauses */
1228 can_generate_joinclause =
1230 }
1231
1232 /*
1233 * Mark the base rels cited in each eclass (which should all exist by
1234 * now) with the eq_classes indexes of all eclasses mentioning them.
1235 * This will let us avoid searching in subsequent lookups. While
1236 * we're at it, we can mark base rels that have pending eclass joins;
1237 * this is a cheap version of has_relevant_eclass_joinclause().
1238 */
1239 i = -1;
1241 {
1243
1244 /* ignore the RTE_GROUP RTE */
1246 continue;
1247
1249 {
1251 continue;
1252 }
1253
1255
1257 ec_index);
1258
1261 }
1262
1263 ec_index++;
1264 }
1265}
static void generate_base_implied_equalities_broken(PlannerInfo *root, EquivalenceClass *ec)
Definition equivclass.c:1486
static void generate_base_implied_equalities_no_const(PlannerInfo *root, EquivalenceClass *ec)
Definition equivclass.c:1370
static void generate_base_implied_equalities_const(PlannerInfo *root, EquivalenceClass *ec)
Definition equivclass.c:1271
References Assert, bms_add_member(), bms_is_member(), bms_membership(), BMS_MULTIPLE, bms_next_member(), EquivalenceClass::ec_broken, EquivalenceClass::ec_has_const, EquivalenceClass::ec_members, EquivalenceClass::ec_merged, EquivalenceClass::ec_relids, RelOptInfo::eclass_indexes, fb(), generate_base_implied_equalities_broken(), generate_base_implied_equalities_const(), generate_base_implied_equalities_no_const(), RelOptInfo::has_eclass_joins, i, lfirst, list_length(), RELOPT_BASEREL, RelOptInfo::reloptkind, and root.
Referenced by query_planner().
◆ generate_gather_paths()
|
extern |
Definition at line 3188 of file allpaths.c.
3189{
3193 double rows;
3195
3196 /* If there are no partial paths, there's nothing to do here. */
3198 return;
3199
3200 /* Should we override the rel's rowcount estimate? */
3202 rowsp = &rows;
3203
3204 /*
3205 * The output of Gather is always unsorted, so there's only one partial
3206 * path of interest: the cheapest one. That will be the one at the front
3207 * of partial_pathlist because of the way add_partial_path works.
3208 */
3215
3216 /*
3217 * For each useful ordering, we can consider an order-preserving Gather
3218 * Merge.
3219 */
3221 {
3223 GatherMergePath *path;
3224
3226 continue;
3227
3232 }
3233}
GatherMergePath * create_gather_merge_path(PlannerInfo *root, RelOptInfo *rel, Path *subpath, PathTarget *target, List *pathkeys, Relids required_outer, double *rows)
Definition pathnode.c:1757
GatherPath * create_gather_path(PlannerInfo *root, RelOptInfo *rel, Path *subpath, PathTarget *target, Relids required_outer, double *rows)
Definition pathnode.c:1809
Definition pathnodes.h:2352
References add_path(), compute_gather_rows(), create_gather_merge_path(), create_gather_path(), fb(), lfirst, linitial, NIL, RelOptInfo::partial_pathlist, GatherMergePath::path, RelOptInfo::reltarget, root, and subpath().
Referenced by generate_useful_gather_paths().
◆ generate_grouped_paths()
|
extern |
Definition at line 3442 of file allpaths.c.
3444{
3454
3456 {
3457 mark_dummy_rel(grouped_rel);
3458 return;
3459 }
3460
3461 /*
3462 * We push partial aggregation only to the lowest possible level in the
3463 * join tree that is deemed useful.
3464 */
3466 !agg_info->agg_useful)
3467 return;
3468
3471
3472 /*
3473 * Determine whether it's possible to perform sort-based implementations
3474 * of grouping, and generate the pathkeys that represent the grouping
3475 * requirements in that case.
3476 */
3479 {
3482
3484 rel->top_parent->grouped_rel : grouped_rel;
3485 top_group_tlist =
3487
3488 group_pathkeys =
3490 top_group_tlist);
3491 }
3492
3493 /*
3494 * Determine whether we should consider hash-based implementations of
3495 * grouping.
3496 */
3500
3501 /*
3502 * Consider whether we should generate partially aggregated non-partial
3503 * paths. We can only do this if we have a non-partial path.
3504 */
3506 {
3507 cheapest_total_path = rel->cheapest_total_path;
3509 }
3510
3511 /*
3512 * If parallelism is possible for grouped_rel, then we should consider
3513 * generating partially-grouped partial paths. However, if the ungrouped
3514 * rel has no partial paths, then we can't.
3515 */
3517 {
3520 }
3521
3522 /* Estimate number of partial groups. */
3525 agg_info->group_exprs,
3526 cheapest_total_path->rows,
3530 agg_info->group_exprs,
3531 cheapest_partial_path->rows,
3533
3535 {
3537
3538 /*
3539 * Use any available suitably-sorted path as input, and also consider
3540 * sorting the cheapest-total path and incremental sort on any paths
3541 * with presorted keys.
3542 *
3543 * To save planning time, we ignore parameterized input paths unless
3544 * they are the cheapest-total path.
3545 */
3547 {
3549 Path *path;
3551 int presorted_keys;
3552
3553 /*
3554 * Ignore parameterized paths that are not the cheapest-total
3555 * path.
3556 */
3558 input_path != cheapest_total_path)
3559 continue;
3560
3562 input_path->pathkeys,
3563 &presorted_keys);
3564
3565 /*
3566 * Ignore paths that are not suitably or partially sorted, unless
3567 * they are the cheapest total path (no need to deal with paths
3568 * which have presorted keys when incremental sort is disabled).
3569 */
3571 (presorted_keys == 0 || !enable_incremental_sort))
3572 continue;
3573
3574 /*
3575 * Since the path originates from a non-grouped relation that is
3576 * not aware of eager aggregation, we must ensure that it provides
3577 * the correct input for partial aggregation.
3578 */
3580 grouped_rel,
3581 input_path,
3582 agg_info->agg_input);
3583
3585 {
3586 /*
3587 * We've no need to consider both a sort and incremental sort.
3588 * We'll just do a sort if there are no presorted keys and an
3589 * incremental sort when there are presorted keys.
3590 */
3593 grouped_rel,
3594 path,
3595 group_pathkeys,
3596 -1.0);
3597 else
3599 grouped_rel,
3600 path,
3601 group_pathkeys,
3602 presorted_keys,
3603 -1.0);
3604 }
3605
3606 /*
3607 * qual is NIL because the HAVING clause cannot be evaluated until
3608 * the final value of the aggregate is known.
3609 */
3611 grouped_rel,
3612 path,
3613 agg_info->target,
3614 AGG_SORTED,
3615 AGGSPLIT_INITIAL_SERIAL,
3616 agg_info->group_clauses,
3617 NIL,
3618 &agg_costs,
3619 dNumGroups);
3620
3621 add_path(grouped_rel, path);
3622 }
3623 }
3624
3626 {
3628
3629 /* Similar to above logic, but for partial paths. */
3631 {
3633 Path *path;
3635 int presorted_keys;
3636
3638 input_path->pathkeys,
3639 &presorted_keys);
3640
3641 /*
3642 * Ignore paths that are not suitably or partially sorted, unless
3643 * they are the cheapest partial path (no need to deal with paths
3644 * which have presorted keys when incremental sort is disabled).
3645 */
3647 (presorted_keys == 0 || !enable_incremental_sort))
3648 continue;
3649
3650 /*
3651 * Since the path originates from a non-grouped relation that is
3652 * not aware of eager aggregation, we must ensure that it provides
3653 * the correct input for partial aggregation.
3654 */
3656 grouped_rel,
3657 input_path,
3658 agg_info->agg_input);
3659
3661 {
3662 /*
3663 * We've no need to consider both a sort and incremental sort.
3664 * We'll just do a sort if there are no presorted keys and an
3665 * incremental sort when there are presorted keys.
3666 */
3669 grouped_rel,
3670 path,
3671 group_pathkeys,
3672 -1.0);
3673 else
3675 grouped_rel,
3676 path,
3677 group_pathkeys,
3678 presorted_keys,
3679 -1.0);
3680 }
3681
3682 /*
3683 * qual is NIL because the HAVING clause cannot be evaluated until
3684 * the final value of the aggregate is known.
3685 */
3687 grouped_rel,
3688 path,
3689 agg_info->target,
3690 AGG_SORTED,
3691 AGGSPLIT_INITIAL_SERIAL,
3692 agg_info->group_clauses,
3693 NIL,
3694 &agg_costs,
3695 dNumPartialGroups);
3696
3697 add_partial_path(grouped_rel, path);
3698 }
3699 }
3700
3701 /*
3702 * Add a partially-grouped HashAgg Path where possible
3703 */
3705 {
3706 Path *path;
3707
3708 /*
3709 * Since the path originates from a non-grouped relation that is not
3710 * aware of eager aggregation, we must ensure that it provides the
3711 * correct input for partial aggregation.
3712 */
3714 grouped_rel,
3715 cheapest_total_path,
3716 agg_info->agg_input);
3717
3718 /*
3719 * qual is NIL because the HAVING clause cannot be evaluated until the
3720 * final value of the aggregate is known.
3721 */
3723 grouped_rel,
3724 path,
3725 agg_info->target,
3726 AGG_HASHED,
3727 AGGSPLIT_INITIAL_SERIAL,
3728 agg_info->group_clauses,
3729 NIL,
3730 &agg_costs,
3731 dNumGroups);
3732
3733 add_path(grouped_rel, path);
3734 }
3735
3736 /*
3737 * Now add a partially-grouped HashAgg partial Path where possible
3738 */
3740 {
3741 Path *path;
3742
3743 /*
3744 * Since the path originates from a non-grouped relation that is not
3745 * aware of eager aggregation, we must ensure that it provides the
3746 * correct input for partial aggregation.
3747 */
3749 grouped_rel,
3750 cheapest_partial_path,
3751 agg_info->agg_input);
3752
3753 /*
3754 * qual is NIL because the HAVING clause cannot be evaluated until the
3755 * final value of the aggregate is known.
3756 */
3758 grouped_rel,
3759 path,
3760 agg_info->target,
3761 AGG_HASHED,
3762 AGGSPLIT_INITIAL_SERIAL,
3763 agg_info->group_clauses,
3764 NIL,
3765 &agg_costs,
3766 dNumPartialGroups);
3767
3768 add_partial_path(grouped_rel, path);
3769 }
3770}
bool pathkeys_count_contained_in(List *keys1, List *keys2, int *n_common)
Definition pathkeys.c:558
List * make_pathkeys_for_sortclauses(PlannerInfo *root, List *sortclauses, List *tlist)
Definition pathkeys.c:1336
ProjectionPath * create_projection_path(PlannerInfo *root, RelOptInfo *rel, Path *subpath, PathTarget *target)
Definition pathnode.c:2531
IncrementalSortPath * create_incremental_sort_path(PlannerInfo *root, RelOptInfo *rel, Path *subpath, List *pathkeys, int presorted_keys, double limit_tuples)
Definition pathnode.c:2799
SortPath * create_sort_path(PlannerInfo *root, RelOptInfo *rel, Path *subpath, List *pathkeys, double limit_tuples)
Definition pathnode.c:2848
AggPath * create_agg_path(PlannerInfo *root, RelOptInfo *rel, Path *subpath, PathTarget *target, AggStrategy aggstrategy, AggSplit aggsplit, List *groupClause, List *qual, const AggClauseCosts *aggcosts, double numGroups)
Definition pathnode.c:3001
void get_agg_clause_costs(PlannerInfo *root, AggSplit aggsplit, AggClauseCosts *costs)
Definition prepagg.c:559
double estimate_num_groups(PlannerInfo *root, List *groupExprs, double input_rows, List **pgset, EstimationInfo *estinfo)
Definition selfuncs.c:3771
Definition pathnodes.h:132
Definition pathnodes.h:1267
List * make_tlist_from_pathtarget(PathTarget *target)
Definition tlist.c:633
References add_partial_path(), add_path(), AGG_HASHED, RelOptInfo::agg_info, RelAggInfo::agg_input, AGG_SORTED, RelAggInfo::agg_useful, AGGSPLIT_INITIAL_SERIAL, RelAggInfo::apply_agg_at, Assert, bms_equal(), RelOptInfo::cheapest_total_path, RelOptInfo::consider_parallel, create_agg_path(), create_incremental_sort_path(), create_projection_path(), create_sort_path(), enable_incremental_sort, estimate_num_groups(), fb(), get_agg_clause_costs(), RelAggInfo::group_clauses, RelAggInfo::group_exprs, RelOptInfo::grouped_rel, grouping_is_hashable(), grouping_is_sortable(), IS_DUMMY_REL, IS_OTHER_REL, lfirst, linitial, make_pathkeys_for_sortclauses(), make_tlist_from_pathtarget(), mark_dummy_rel(), MemSet, NIL, RelOptInfo::partial_pathlist, pathkeys_count_contained_in(), RelOptInfo::pathlist, RelOptInfo::relids, root, Path::rows, and RelAggInfo::target.
Referenced by generate_partitionwise_join_paths(), merge_clump(), set_grouped_rel_pathlist(), and standard_join_search().
◆ generate_implied_equalities_for_column()
|
extern |
Definition at line 3238 of file equivclass.c.
3243{
3248
3249 /* Should be OK to rely on eclass_indexes */
3251
3252 /* Indexes are available only on base or "other" member relations. */
3254
3255 /* If it's a child rel, we'll need to know what its parent(s) are */
3258 else
3260
3261 i = -1;
3263 {
3268
3269 /* Sanity check eclass_indexes only contain ECs for rel */
3271
3272 /*
3273 * Won't generate joinclauses if const or single-member (the latter
3274 * test covers the volatile case too)
3275 */
3277 continue;
3278
3279 /*
3280 * Scan members, looking for a match to the target column. Note that
3281 * child EC members are considered, but only when they belong to the
3282 * target relation. (Unlike regular members, the same expression
3283 * could be a child member of more than one EC. Therefore, it's
3284 * potentially order-dependent which EC a child relation's target
3285 * column gets matched to. This is annoying but it only happens in
3286 * corner cases, so for now we live with just reporting the first
3287 * match. See also get_eclass_for_sort_expr.)
3288 */
3291 {
3294 break;
3295 }
3296
3298 continue;
3299
3300 /*
3301 * Found our match. Scan the other EC members and attempt to generate
3302 * joinclauses. Ignore children here.
3303 */
3305 {
3308 RestrictInfo *rinfo;
3309
3310 /* Child members should not exist in ec_members */
3312
3313 /* Make sure it'll be a join to a different rel */
3316 continue;
3317
3318 /* Forget it if caller doesn't want joins to this rel */
3320 continue;
3321
3322 /*
3323 * Also, if this is a child rel, avoid generating a useless join
3324 * to its parent rel(s).
3325 */
3328 continue;
3329
3331 cur_em->em_datatype,
3332 other_em->em_datatype);
3334 continue;
3335
3336 /* set parent_ec to mark as redundant with other joinclauses */
3339 cur_ec);
3340
3341 result = lappend(result, rinfo);
3342 }
3343
3344 /*
3345 * If somehow we failed to create any join clauses, we might as well
3346 * keep scanning the ECs for another match. But if we did make any,
3347 * we're done, because we don't want to return non-redundant clauses.
3348 */
3349 if (result)
3350 break;
3351 }
3352
3353 return result;
3354}
static RestrictInfo * create_join_clause(PlannerInfo *root, EquivalenceClass *ec, Oid opno, EquivalenceMember *leftem, EquivalenceMember *rightem, EquivalenceClass *parent_ec)
Definition equivclass.c:1982
static Oid select_equality_operator(EquivalenceClass *ec, Oid lefttype, Oid righttype)
Definition equivclass.c:1947
static void callback(struct sockaddr *addr, struct sockaddr *mask, void *unused)
Definition test_ifaddrs.c:46
References Assert, bms_equal(), bms_is_subset(), bms_next_member(), bms_overlap(), callback(), create_join_clause(), RelOptInfo::eclass_indexes, eclass_member_iterator_next(), fb(), find_childrel_parents(), i, IS_SIMPLE_REL, lappend(), lfirst, list_length(), list_nth(), NIL, OidIsValid, RelOptInfo::relids, RELOPT_OTHER_MEMBER_REL, RelOptInfo::reloptkind, root, select_equality_operator(), and setup_eclass_member_iterator().
Referenced by create_tidscan_paths(), match_eclass_clauses_to_index(), and postgresGetForeignPaths().
◆ generate_join_implied_equalities()
|
extern |
Definition at line 1549 of file equivclass.c.
1554{
1561
1562 /* If inner rel is a child, extra setup work is needed */
1564 {
1566
1567 /* Fetch relid set for the topmost parent rel */
1569 /* ECs will be marked with the parent's relid, not the child's */
1572 nominal_join_relids,
1573 sjinfo,
1574 NULL);
1575 }
1576 else
1577 {
1579 nominal_join_relids = join_relids;
1580 }
1581
1582 /*
1583 * Examine all potentially-relevant eclasses.
1584 *
1585 * If we are considering an outer join, we must include "join" clauses
1586 * that mention either input rel plus the outer join's relid; these
1587 * represent post-join filter clauses that have to be applied at this
1588 * join. We don't have infrastructure that would let us identify such
1589 * eclasses cheaply, so just fall back to considering all eclasses
1590 * mentioning anything in nominal_join_relids.
1591 *
1592 * At inner joins, we can be smarter: only consider eclasses mentioning
1593 * both input rels.
1594 */
1597 else
1599 outer_relids);
1600
1601 i = -1;
1603 {
1606
1607 /* ECs containing consts do not need any further enforcement */
1609 continue;
1610
1611 /* Single-member ECs won't generate any deductions */
1613 continue;
1614
1615 /* Sanity check that this eclass overlaps the join */
1617
1620 ec,
1621 join_relids,
1622 outer_relids,
1623 inner_relids);
1624
1625 /* Recover if we failed to generate required derived clauses */
1628 ec,
1629 nominal_join_relids,
1630 outer_relids,
1631 nominal_inner_relids,
1632 inner_rel);
1633
1635 }
1636
1637 return result;
1638}
static List * generate_join_implied_equalities_normal(PlannerInfo *root, EquivalenceClass *ec, Relids join_relids, Relids outer_relids, Relids inner_relids)
Definition equivclass.c:1720
static Bitmapset * get_common_eclass_indexes(PlannerInfo *root, Relids relids1, Relids relids2)
Definition equivclass.c:3646
static List * generate_join_implied_equalities_broken(PlannerInfo *root, EquivalenceClass *ec, Relids nominal_join_relids, Relids outer_relids, Relids nominal_inner_relids, RelOptInfo *inner_rel)
Definition equivclass.c:1898
Relids add_outer_joins_to_relids(PlannerInfo *root, Relids input_relids, SpecialJoinInfo *sjinfo, List **pushed_down_joins)
Definition joinrels.c:800
References add_outer_joins_to_relids(), Assert, bms_is_empty, bms_next_member(), bms_overlap(), bms_union(), EquivalenceClass::ec_broken, EquivalenceClass::ec_has_const, EquivalenceClass::ec_members, EquivalenceClass::ec_relids, fb(), generate_join_implied_equalities_broken(), generate_join_implied_equalities_normal(), get_common_eclass_indexes(), get_eclass_indexes_for_relids(), i, IS_OTHER_REL, list_concat(), list_length(), list_nth(), NIL, SpecialJoinInfo::ojrelid, and root.
Referenced by build_joinrel_restrictlist(), check_index_predicates(), get_baserel_parampathinfo(), get_joinrel_parampathinfo(), reduce_unique_semijoins(), and remove_self_joins_one_group().
◆ generate_join_implied_equalities_for_ecs()
|
extern |
Definition at line 1649 of file equivclass.c.
1654{
1660
1661 /* If inner rel is a child, extra setup work is needed */
1663 {
1665
1666 /* Fetch relid set for the topmost parent rel */
1668 /* ECs will be marked with the parent's relid, not the child's */
1670 }
1671 else
1672 {
1674 nominal_join_relids = join_relids;
1675 }
1676
1678 {
1681
1682 /* ECs containing consts do not need any further enforcement */
1684 continue;
1685
1686 /* Single-member ECs won't generate any deductions */
1688 continue;
1689
1690 /* We can quickly ignore any that don't overlap the join, too */
1692 continue;
1693
1696 ec,
1697 join_relids,
1698 outer_relids,
1699 inner_relids);
1700
1701 /* Recover if we failed to generate required derived clauses */
1704 ec,
1705 nominal_join_relids,
1706 outer_relids,
1707 nominal_inner_relids,
1708 inner_rel);
1709
1711 }
1712
1713 return result;
1714}
References Assert, bms_is_empty, bms_overlap(), bms_union(), EquivalenceClass::ec_broken, EquivalenceClass::ec_has_const, EquivalenceClass::ec_members, EquivalenceClass::ec_relids, fb(), generate_join_implied_equalities_broken(), generate_join_implied_equalities_normal(), IS_OTHER_REL, lfirst, list_concat(), list_length(), NIL, and root.
Referenced by get_joinrel_parampathinfo().
◆ generate_partitionwise_join_paths()
|
extern |
Definition at line 4814 of file allpaths.c.
4815{
4820
4821 /* Handle only join relations here. */
4823 return;
4824
4825 /* We've nothing to do if the relation is not partitioned. */
4827 return;
4828
4829 /* The relation should have consider_partitionwise_join set. */
4831
4832 /* Guard against stack overflow due to overly deep partition hierarchy. */
4833 check_stack_depth();
4834
4836 part_rels = rel->part_rels;
4837
4838 /* Collect non-dummy child-joins. */
4840 {
4842
4843 /* If it's been pruned entirely, it's certainly dummy. */
4845 continue;
4846
4847 /* Make partitionwise join paths for this partitioned child-join. */
4849
4850 /* If we failed to make any path for this child, we must give up. */
4852 {
4853 /*
4854 * Mark the parent joinrel as unpartitioned so that later
4855 * functions treat it correctly.
4856 */
4857 rel->nparts = 0;
4858 return;
4859 }
4860
4861 /* Else, identify the cheapest path for it. */
4863
4864 /* Dummy children need not be scanned, so ignore those. */
4866 continue;
4867
4868 /*
4869 * Except for the topmost scan/join rel, consider generating partial
4870 * aggregation paths for the grouped relation on top of the paths of
4871 * this partitioned child-join. After that, we're done creating paths
4872 * for the grouped relation, so run set_cheapest().
4873 */
4876 rel->top_parent_relids : rel->relids,
4877 root->all_query_rels))
4878 {
4880
4882
4884 set_cheapest(grouped_rel);
4885 }
4886
4887#ifdef OPTIMIZER_DEBUG
4889#endif
4890
4892 }
4893
4894 /* If all child-joins are dummy, parent join is also dummy. */
4896 {
4897 mark_dummy_rel(rel);
4898 return;
4899 }
4900
4901 /* Build additional paths for this rel from child-join paths. */
4904}
void generate_partitionwise_join_paths(PlannerInfo *root, RelOptInfo *rel)
Definition allpaths.c:4814
void generate_grouped_paths(PlannerInfo *root, RelOptInfo *grouped_rel, RelOptInfo *rel)
Definition allpaths.c:3442
void add_paths_to_append_rel(PlannerInfo *root, RelOptInfo *rel, List *live_childrels)
Definition allpaths.c:1404
References add_paths_to_append_rel(), Assert, bms_equal(), check_stack_depth(), RelOptInfo::consider_partitionwise_join, fb(), generate_grouped_paths(), generate_partitionwise_join_paths(), RelOptInfo::grouped_rel, IS_DUMMY_REL, IS_GROUPED_REL, IS_JOIN_REL, IS_OTHER_REL, IS_PARTITIONED_REL, lappend(), list_free(), mark_dummy_rel(), NIL, RelOptInfo::nparts, pprint(), RelOptInfo::relids, root, set_cheapest(), and RelOptInfo::top_parent_relids.
Referenced by generate_partitionwise_join_paths(), merge_clump(), and standard_join_search().
◆ generate_useful_gather_paths()
|
extern |
Definition at line 3325 of file allpaths.c.
3326{
3328 double rows;
3332
3333 /* If there are no partial paths, there's nothing to do here. */
3335 return;
3336
3337 /* Should we override the rel's rowcount estimate? */
3339 rowsp = &rows;
3340
3341 /* generate the regular gather (merge) paths */
3343
3344 /* consider incremental sort for interesting orderings */
3346
3347 /* used for explicit (full) sort paths */
3349
3350 /*
3351 * Consider sorted paths for each interesting ordering. We generate both
3352 * incremental and full sort.
3353 */
3355 {
3359 int presorted_keys;
3360
3362 {
3364 GatherMergePath *path;
3365
3367 subpath->pathkeys,
3368 &presorted_keys);
3369
3370 /*
3371 * We don't need to consider the case where a subpath is already
3372 * fully sorted because generate_gather_paths already creates a
3373 * gather merge path for every subpath that has pathkeys present.
3374 *
3375 * But since the subpath is already sorted, we know we don't need
3376 * to consider adding a sort (full or incremental) on top of it,
3377 * so we can continue here.
3378 */
3380 continue;
3381
3382 /*
3383 * Try at least sorting the cheapest path and also try
3384 * incrementally sorting any path which is partially sorted
3385 * already (no need to deal with paths which have presorted keys
3386 * when incremental sort is disabled unless it's the cheapest
3387 * input path).
3388 */
3390 (presorted_keys == 0 || !enable_incremental_sort))
3391 continue;
3392
3393 /*
3394 * Consider regular sort for any path that's not presorted or if
3395 * incremental sort is disabled. We've no need to consider both
3396 * sort and incremental sort on the same path. We assume that
3397 * incremental sort is always faster when there are presorted
3398 * keys.
3399 *
3400 * This is not redundant with the gather paths created in
3401 * generate_gather_paths, because that doesn't generate ordered
3402 * output. Here we add an explicit sort to match the useful
3403 * ordering.
3404 */
3406 {
3408 rel,
3409 subpath,
3410 useful_pathkeys,
3411 -1.0);
3412 }
3413 else
3415 rel,
3416 subpath,
3417 useful_pathkeys,
3418 presorted_keys,
3419 -1);
3422 subpath,
3423 rel->reltarget,
3424 subpath->pathkeys,
3425 NULL,
3426 rowsp);
3427
3429 }
3430 }
3431}
static List * get_useful_pathkeys_for_relation(PlannerInfo *root, RelOptInfo *rel, bool require_parallel_safe)
Definition allpaths.c:3257
void generate_gather_paths(PlannerInfo *root, RelOptInfo *rel, bool override_rows)
Definition allpaths.c:3188
References add_path(), compute_gather_rows(), create_gather_merge_path(), create_incremental_sort_path(), create_sort_path(), enable_incremental_sort, fb(), generate_gather_paths(), get_useful_pathkeys_for_relation(), lfirst, linitial, NIL, RelOptInfo::partial_pathlist, GatherMergePath::path, pathkeys_count_contained_in(), RelOptInfo::reltarget, root, and subpath().
Referenced by apply_scanjoin_target_to_paths(), create_partial_distinct_paths(), create_partial_unique_paths(), gather_grouping_paths(), merge_clump(), set_rel_pathlist(), and standard_join_search().
◆ get_cheapest_fractional_path_for_pathkeys()
|
extern |
Definition at line 666 of file pathkeys.c.
670{
672 ListCell *l;
673
674 foreach(l, paths)
675 {
677
678 /*
679 * Since cost comparison is a lot cheaper than pathkey comparison, do
680 * that first. (XXX is that still true?)
681 */
684 continue;
685
688 matched_path = path;
689 }
691}
int compare_fractional_path_costs(Path *path1, Path *path2, double fraction)
Definition pathnode.c:123
References bms_is_subset(), compare_fractional_path_costs(), fb(), lfirst, PATH_REQ_OUTER, Path::pathkeys, and pathkeys_contained_in().
Referenced by build_minmax_path(), and generate_orderedappend_paths().
◆ get_cheapest_parallel_safe_total_inner()
Definition at line 699 of file pathkeys.c.
References bms_is_empty, fb(), lfirst, and PATH_REQ_OUTER.
Referenced by add_paths_to_append_rel(), hash_inner_and_outer(), match_unsorted_outer(), and sort_inner_and_outer().
◆ get_cheapest_path_for_pathkeys()
|
extern |
Definition at line 620 of file pathkeys.c.
624{
626 ListCell *l;
627
628 foreach(l, paths)
629 {
631
632 /* If required, reject paths that are not parallel-safe */
634 continue;
635
636 /*
637 * Since cost comparison is a lot cheaper than pathkey comparison, do
638 * that first. (XXX is that still true?)
639 */
642 continue;
643
646 matched_path = path;
647 }
649}
int compare_path_costs(Path *path1, Path *path2, CostSelector criterion)
Definition pathnode.c:68
References bms_is_subset(), compare_path_costs(), fb(), lfirst, Path::parallel_safe, PATH_REQ_OUTER, Path::pathkeys, and pathkeys_contained_in().
Referenced by generate_mergejoin_paths(), generate_nonunion_paths(), generate_orderedappend_paths(), generate_union_paths(), and get_cheapest_parameterized_child_path().
◆ get_eclass_for_sort_expr()
|
extern |
Definition at line 736 of file equivclass.c.
744{
745 JoinDomain *jdomain;
750 MemoryContext oldcontext;
751
752 /*
753 * Ensure the expression exposes the correct type and collation.
754 */
755 expr = canonicalize_ec_expression(expr, opcintype, collation);
756
757 /*
758 * Since SortGroupClause nodes are top-level expressions (GROUP BY, ORDER
759 * BY, etc), they can be presumed to belong to the top JoinDomain.
760 */
762
763 /*
764 * Scan through the existing EquivalenceClasses for a match
765 */
767 {
771
772 /*
773 * Never match to a volatile EC, except when we are looking at another
774 * reference to the same volatile SortGroupClause.
775 */
778 continue;
779
781 continue;
783 continue;
784
787 {
788 /*
789 * Ignore child members unless they match the request.
790 */
793 continue;
794
795 /*
796 * Match constants only within the same JoinDomain (see
797 * optimizer/README).
798 */
800 continue;
801
805 }
806 }
807
808 /* No match; does caller want a NULL result? */
811
812 /*
813 * OK, build a new single-member EC
814 *
815 * Here, we must be sure that we construct the EC in the right context.
816 */
818
821 newec->ec_collation = collation;
822 newec->ec_childmembers_size = 0;
834 newec->ec_max_security = 0;
836
839
840 /*
841 * Get the precise set of relids appearing in the expression.
842 */
844
846 jdomain, opcintype);
847
848 /*
849 * add_eq_member doesn't check for volatile functions, set-returning
850 * functions, aggregates, or window functions, but such could appear in
851 * sort expressions; so we have to check whether its const-marking was
852 * correct.
853 */
855 {
860 {
863 }
864 }
865
867
868 /*
869 * If EC merging is already complete, we have to mop up by adding the new
870 * EC to the eclass_indexes of the relation(s) mentioned in it.
871 */
873 {
876
878 {
880
881 /* ignore the RTE_GROUP RTE */
883 continue;
884
886 {
888 continue;
889 }
890
892
894 ec_index);
895 }
896 }
897
898 MemoryContextSwitchTo(oldcontext);
899
901}
static EquivalenceMember * add_eq_member(EquivalenceClass *ec, Expr *expr, Relids relids, JoinDomain *jdomain, Oid datatype)
Definition equivclass.c:628
Definition pathnodes.h:1542
References add_eq_member(), Assert, bms_add_member(), bms_equal(), bms_is_member(), bms_next_member(), canonicalize_ec_expression(), contain_agg_clause(), contain_volatile_functions(), contain_window_function(), copyObject, RelOptInfo::eclass_indexes, eclass_member_iterator_next(), elog, equal(), ERROR, expression_returns_set(), fb(), i, lappend(), lfirst, linitial_node, list_copy(), list_length(), makeNode, MemoryContextSwitchTo(), NIL, pull_varnos(), RELOPT_BASEREL, RelOptInfo::reloptkind, root, and setup_eclass_member_iterator().
Referenced by convert_subquery_pathkeys(), get_eclass_for_sortgroupclause(), initialize_mergeclause_eclasses(), and make_pathkey_from_sortinfo().
◆ get_useful_group_keys_orderings()
|
extern |
Definition at line 467 of file pathkeys.c.
468{
471 GroupByOrdering *info;
472
475
476 /* always return at least the original pathkeys/clauses */
478 info->pathkeys = pathkeys;
479 info->clauses = clauses;
481
482 /*
483 * Should we try generating alternative orderings of the group keys? If
484 * not, we produce only the order specified in the query, i.e. the
485 * optimization is effectively disabled.
486 */
489
490 /*
491 * Grouping sets have own and more complex logic to decide the ordering.
492 */
495
496 /*
497 * If the path is sorted in some way, try reordering the group keys to
498 * match the path as much of the ordering as possible. Then thanks to
499 * incremental sort we would get this sort as cheap as possible.
500 */
503 {
504 int n;
505
507 root->num_groupby_pathkeys);
508
509 if (n > 0 &&
512 {
514 info->pathkeys = pathkeys;
515 info->clauses = clauses;
516
518 }
519 }
520
521#ifdef USE_ASSERT_CHECKING
522 {
525
526 /* Test consistency of info structures */
528 {
530 *lc2;
531
533
538
540 {
543
545 }
546 }
547 }
548#endif
550}
List * list_difference_ptr(const List *list1, const List *list2)
Definition list.c:1263
static int group_keys_reorder_by_pathkeys(List *pathkeys, List **group_pathkeys, List **group_clauses, int num_groupby_pathkeys)
Definition pathkeys.c:370
Definition pathnodes.h:1809
Definition parsenodes.h:118
Definition parsenodes.h:1494
References Assert, GroupByOrdering::clauses, compare_pathkeys(), enable_group_by_reordering, enable_incremental_sort, fb(), for_each_from, forboth, group_keys_reorder_by_pathkeys(), lappend(), lfirst_node, linitial_node, list_difference(), list_difference_ptr(), list_length(), makeNode, NIL, parse(), GroupByOrdering::pathkeys, Path::pathkeys, pathkeys_contained_in(), PATHKEYS_EQUAL, and root.
Referenced by add_paths_to_grouping_rel(), and create_partial_grouping_paths().
◆ has_relevant_eclass_joinclause()
|
extern |
Definition at line 3445 of file equivclass.c.
3446{
3449
3450 /* Examine only eclasses mentioning rel1 */
3452
3453 i = -1;
3455 {
3457 i);
3458
3459 /*
3460 * Won't generate joinclauses if single-member (this test covers the
3461 * volatile case too)
3462 */
3464 continue;
3465
3466 /*
3467 * Per the comment in have_relevant_eclass_joinclause, it's sufficient
3468 * to find an EC that mentions both this rel and some other rel.
3469 */
3471 return true;
3472 }
3473
3474 return false;
3475}
References bms_is_subset(), bms_next_member(), EquivalenceClass::ec_members, EquivalenceClass::ec_relids, fb(), get_eclass_indexes_for_relids(), i, list_length(), list_nth(), and root.
Referenced by build_join_rel().
◆ has_useful_pathkeys()
|
extern |
Definition at line 2291 of file pathkeys.c.
2292{
2294 return true; /* might be able to use pathkeys for merging */
2296 return true; /* the upper planner might need them */
2297
2298 return false; /* definitely useless */
2299}
References RelOptInfo::has_eclass_joins, RelOptInfo::joininfo, NIL, and root.
Referenced by build_child_join_rel(), build_index_paths(), and set_append_rel_size().
◆ have_join_order_restriction()
|
extern |
Definition at line 1254 of file joinrels.c.
1256{
1257 bool result = false;
1258 ListCell *l;
1259
1260 /*
1261 * If either side has a direct lateral reference to the other, attempt the
1262 * join regardless of outer-join considerations.
1263 */
1266 return true;
1267
1268 /*
1269 * Likewise, if both rels are needed to compute some PlaceHolderVar,
1270 * attempt the join regardless of outer-join considerations. (This is not
1271 * very desirable, because a PHV with a large eval_at set will cause a lot
1272 * of probably-useless joins to be considered, but failing to do this can
1273 * cause us to fail to construct a plan at all.)
1274 */
1276 {
1278
1281 return true;
1282 }
1283
1284 /*
1285 * It's possible that the rels correspond to the left and right sides of a
1286 * degenerate outer join, that is, one with no joinclause mentioning the
1287 * non-nullable side; in which case we should force the join to occur.
1288 *
1289 * Also, the two rels could represent a clauseless join that has to be
1290 * completed to build up the LHS or RHS of an outer join.
1291 */
1293 {
1295
1296 /* ignore full joins --- other mechanisms handle them */
1298 continue;
1299
1300 /* Can we perform the SJ with these rels? */
1303 {
1304 result = true;
1305 break;
1306 }
1309 {
1310 result = true;
1311 break;
1312 }
1313
1314 /*
1315 * Might we need to join these rels to complete the RHS? We have to
1316 * use "overlap" tests since either rel might include a lower SJ that
1317 * has been proven to commute with this one.
1318 */
1321 {
1322 result = true;
1323 break;
1324 }
1325
1326 /* Likewise for the LHS. */
1329 {
1330 result = true;
1331 break;
1332 }
1333 }
1334
1335 /*
1336 * We do not force the join to occur if either input rel can legally be
1337 * joined to anything else using joinclauses. This essentially means that
1338 * clauseless bushy joins are put off as long as possible. The reason is
1339 * that when there is a join order restriction high up in the join tree
1340 * (that is, with many rels inside the LHS or RHS), we would otherwise
1341 * expend lots of effort considering very stupid join combinations within
1342 * its LHS or RHS.
1343 */
1344 if (result)
1345 {
1348 result = false;
1349 }
1350
1351 return result;
1352}
static bool has_legal_joinclause(PlannerInfo *root, RelOptInfo *rel)
Definition joinrels.c:1423
Definition pathnodes.h:3374
References bms_is_subset(), bms_overlap(), fb(), has_legal_joinclause(), JOIN_FULL, SpecialJoinInfo::jointype, lfirst, SpecialJoinInfo::min_lefthand, SpecialJoinInfo::min_righthand, and root.
Referenced by desirable_join(), join_search_one_level(), and make_rels_by_clause_joins().
◆ have_relevant_eclass_joinclause()
|
extern |
Definition at line 3369 of file equivclass.c.
3371{
3374
3375 /*
3376 * Examine only eclasses mentioning both rel1 and rel2.
3377 *
3378 * Note that we do not consider the possibility of an eclass generating
3379 * "join" clauses that mention just one of the rels plus an outer join
3380 * that could be formed from them. Although such clauses must be
3381 * correctly enforced when we form the outer join, they don't seem like
3382 * sufficient reason to prioritize this join over other ones. The join
3383 * ordering rules will force the join to be made when necessary.
3384 */
3386 rel2->relids);
3387
3388 i = -1;
3390 {
3392 i);
3393
3394 /*
3395 * Sanity check that get_common_eclass_indexes gave only ECs
3396 * containing both rels.
3397 */
3400
3401 /*
3402 * Won't generate joinclauses if single-member (this test covers the
3403 * volatile case too)
3404 */
3406 continue;
3407
3408 /*
3409 * We do not need to examine the individual members of the EC, because
3410 * all that we care about is whether each rel overlaps the relids of
3411 * at least one member, and get_common_eclass_indexes() and the single
3412 * member check above are sufficient to prove that. (As with
3413 * have_relevant_joinclause(), it is not necessary that the EC be able
3414 * to form a joinclause relating exactly the two given rels, only that
3415 * it be able to form a joinclause mentioning both, and this will
3416 * surely be true if both of them overlap ec_relids.)
3417 *
3418 * Note we don't test ec_broken; if we did, we'd need a separate code
3419 * path to look through ec_sources. Checking the membership anyway is
3420 * OK as a possibly-overoptimistic heuristic.
3421 *
3422 * We don't test ec_has_const either, even though a const eclass won't
3423 * generate real join clauses. This is because if we had "WHERE a.x =
3424 * b.y and a.x = 42", it is worth considering a join between a and b,
3425 * since the join result is likely to be small even though it'll end
3426 * up being an unqualified nestloop.
3427 */
3428
3429 return true;
3430 }
3431
3432 return false;
3433}
References Assert, bms_next_member(), bms_overlap(), EquivalenceClass::ec_members, EquivalenceClass::ec_relids, fb(), get_common_eclass_indexes(), i, list_length(), list_nth(), and root.
Referenced by have_relevant_joinclause().
◆ indexcol_is_bool_constant_for_query()
|
extern |
Definition at line 4303 of file indxpath.c.
4306{
4308
4309 /* If the index isn't boolean, we can't possibly get a match */
4311 return false;
4312
4313 /* Check each restriction clause for the index's rel */
4315 {
4317
4318 /*
4319 * As in match_clause_to_indexcol, never match pseudoconstants to
4320 * indexes. (It might be semantically okay to do so here, but the
4321 * odds of getting a match are negligible, so don't waste the cycles.)
4322 */
4323 if (rinfo->pseudoconstant)
4324 continue;
4325
4326 /* See if we can match the clause's expression to the index column */
4328 return true;
4329 }
4330
4331 return false;
4332}
static IndexClause * match_boolean_index_clause(PlannerInfo *root, RestrictInfo *rinfo, int indexcol, IndexOptInfo *index)
Definition indxpath.c:2816
References fb(), IsBooleanOpfamily(), lfirst, match_boolean_index_clause(), and root.
Referenced by build_index_pathkeys().
◆ init_dummy_sjinfo()
|
extern |
Definition at line 664 of file joinrels.c.
666{
667 sjinfo->type = T_SpecialJoinInfo;
673 sjinfo->ojrelid = 0;
678 /* we don't bother trying to make the remaining fields valid */
684}
References SpecialJoinInfo::commute_above_l, SpecialJoinInfo::commute_above_r, SpecialJoinInfo::commute_below_l, SpecialJoinInfo::commute_below_r, fb(), JOIN_INNER, SpecialJoinInfo::jointype, SpecialJoinInfo::lhs_strict, SpecialJoinInfo::min_lefthand, SpecialJoinInfo::min_righthand, NIL, SpecialJoinInfo::ojrelid, SpecialJoinInfo::semi_can_btree, SpecialJoinInfo::semi_can_hash, SpecialJoinInfo::semi_operators, SpecialJoinInfo::semi_rhs_exprs, SpecialJoinInfo::syn_lefthand, and SpecialJoinInfo::syn_righthand.
Referenced by approx_tuple_count(), build_child_join_sjinfo(), compute_semi_anti_join_factors(), consider_new_or_clause(), and make_join_rel().
◆ initialize_mergeclause_eclasses()
|
extern |
Definition at line 1463 of file pathkeys.c.
1464{
1466 Oid lefttype,
1467 righttype;
1468
1469 /* Should be a mergeclause ... */
1471 /* ... with links not yet set */
1474
1475 /* Need the declared input types of the operator */
1477
1478 /* Find or create a matching EquivalenceClass for each side */
1479 restrictinfo->left_ec =
1482 restrictinfo->mergeopfamilies,
1483 lefttype,
1484 ((OpExpr *) clause)->inputcollid,
1485 0,
1486 NULL,
1487 true);
1488 restrictinfo->right_ec =
1491 restrictinfo->mergeopfamilies,
1492 righttype,
1493 ((OpExpr *) clause)->inputcollid,
1494 0,
1495 NULL,
1496 true);
1497}
void op_input_types(Oid opno, Oid *lefttype, Oid *righttype)
Definition lsyscache.c:1508
Definition primnodes.h:846
References Assert, fb(), get_eclass_for_sort_expr(), get_leftop(), get_rightop(), NIL, op_input_types(), and root.
Referenced by distribute_qual_to_rels().
◆ is_redundant_derived_clause()
|
extern |
Definition at line 3549 of file equivclass.c.
3550{
3551 EquivalenceClass *parent_ec = rinfo->parent_ec;
3553
3554 /* Fail if it's not a potentially-redundant clause from some EC */
3556 return false;
3557
3559 {
3561
3563 return true;
3564 }
3565
3566 return false;
3567}
Referenced by create_tidscan_plan().
◆ is_redundant_with_indexclauses()
|
extern |
Definition at line 3576 of file equivclass.c.
3577{
3578 EquivalenceClass *parent_ec = rinfo->parent_ec;
3580
3582 {
3585
3586 /* If indexclause is lossy, it won't enforce the condition exactly */
3588 continue;
3589
3590 /* Match if it's same clause (pointer equality should be enough) */
3592 return true;
3593 /* Match if derived from same EC */
3595 return true;
3596
3597 /*
3598 * No need to look at the derived clauses in iclause->indexquals; they
3599 * couldn't match if the parent clause didn't.
3600 */
3601 }
3602
3603 return false;
3604}
Definition pathnodes.h:2080
References fb(), and lfirst_node.
Referenced by create_indexscan_plan(), extract_nonindex_conditions(), and has_indexed_join_quals().
◆ join_search_one_level()
|
extern |
Definition at line 78 of file joinrels.c.
79{
81 ListCell *r;
82 int k;
83
85
86 /* Set join_cur_level so that new joinrels are added to proper list */
87 root->join_cur_level = level;
88
89 /*
90 * First, consider left-sided and right-sided plans, in which rels of
91 * exactly level-1 member relations are joined against initial relations.
92 * We prefer to join using join clauses, but if we find a rel of level-1
93 * members that has no join clauses, we will generate Cartesian-product
94 * joins against all initial rels not already contained in it.
95 */
97 {
99
102 {
104
105 /*
106 * There are join clauses or join order restrictions relevant to
107 * this rel, so consider joins between this rel and (only) those
108 * initial rels it is linked to by a clause or restriction.
109 *
110 * At level 2 this condition is symmetric, so there is no need to
111 * look at initial rels before this one in the list; we already
112 * considered such joins when we were at the earlier rel. (The
113 * mirror-image joins are handled automatically by make_join_rel.)
114 * In later passes (level > 2), we join rels of the previous level
115 * to each initial rel they don't already include but have a join
116 * clause or restriction with.
117 */
118 if (level == 2) /* consider remaining initial rels */
120 else
121 first_rel = 0;
122
124 }
125 else
126 {
127 /*
128 * Oops, we have a relation that is not joined to any other
129 * relation, either directly or by join-order restrictions.
130 * Cartesian product time.
131 *
132 * We consider a cartesian product with each not-already-included
133 * initial rel, whether it has other join clauses or not. At
134 * level 2, if there are two or more clauseless initial rels, we
135 * will redundantly consider joining them in both directions; but
136 * such cases aren't common enough to justify adding complexity to
137 * avoid the duplicated effort.
138 */
140 old_rel,
141 joinrels[1]);
142 }
143 }
144
145 /*
146 * Now, consider "bushy plans" in which relations of k initial rels are
147 * joined to relations of level-k initial rels, for 2 <= k <= level-2.
148 *
149 * We only consider bushy-plan joins for pairs of rels where there is a
150 * suitable join clause (or join order restriction), in order to avoid
151 * unreasonable growth of planning time.
152 */
153 for (k = 2;; k++)
154 {
156
157 /*
158 * Since make_join_rel(x, y) handles both x,y and y,x cases, we only
159 * need to go as far as the halfway point.
160 */
162 break;
163
165 {
169
170 /*
171 * We can ignore relations without join clauses here, unless they
172 * participate in join-order restrictions --- then we might have
173 * to force a bushy join plan.
174 */
177 continue;
178
181 else
182 first_rel = 0;
183
185 {
187
189 {
190 /*
191 * OK, we can build a rel of the right level from this
192 * pair of rels. Do so if there is at least one relevant
193 * join clause or join order restriction.
194 */
197 {
199 }
200 }
201 }
202 }
203 }
204
205 /*----------
206 * Last-ditch effort: if we failed to find any usable joins so far, force
207 * a set of cartesian-product joins to be generated. This handles the
208 * special case where all the available rels have join clauses but we
209 * cannot use any of those clauses yet. This can only happen when we are
210 * considering a join sub-problem (a sub-joinlist) and all the rels in the
211 * sub-problem have only join clauses with rels outside the sub-problem.
212 * An example is
213 *
214 * SELECT ... FROM a INNER JOIN b ON TRUE, c, d, ...
215 * WHERE a.w = c.x and b.y = d.z;
216 *
217 * If the "a INNER JOIN b" sub-problem does not get flattened into the
218 * upper level, we must be willing to make a cartesian join of a and b;
219 * but the code above will not have done so, because it thought that both
220 * a and b have joinclauses. We consider only left-sided and right-sided
221 * cartesian joins in this case (no bushy).
222 *----------
223 */
225 {
226 /*
227 * This loop is just like the first one, except we always call
228 * make_rels_by_clauseless_joins().
229 */
231 {
233
235 old_rel,
236 joinrels[1]);
237 }
238
239 /*----------
240 * When special joins are involved, there may be no legal way
241 * to make an N-way join for some values of N. For example consider
242 *
243 * SELECT ... FROM t1 WHERE
244 * x IN (SELECT ... FROM t2,t3 WHERE ...) AND
245 * y IN (SELECT ... FROM t4,t5 WHERE ...)
246 *
247 * We will flatten this query to a 5-way join problem, but there are
248 * no 4-way joins that join_is_legal() will consider legal. We have
249 * to accept failure at level 4 and go on to discover a workable
250 * bushy plan at level 5.
251 *
252 * However, if there are no special joins and no lateral references
253 * then join_is_legal() should never fail, and so the following sanity
254 * check is useful.
255 *----------
256 */
259 !root->hasLateralRTEs)
261 }
262}
bool have_relevant_joinclause(PlannerInfo *root, RelOptInfo *rel1, RelOptInfo *rel2)
Definition joininfo.c:39
static void make_rels_by_clauseless_joins(PlannerInfo *root, RelOptInfo *old_rel, List *other_rels)
Definition joinrels.c:319
RelOptInfo * make_join_rel(PlannerInfo *root, RelOptInfo *rel1, RelOptInfo *rel2)
Definition joinrels.c:699
bool have_join_order_restriction(PlannerInfo *root, RelOptInfo *rel1, RelOptInfo *rel2)
Definition joinrels.c:1254
static bool has_join_restriction(PlannerInfo *root, RelOptInfo *rel)
Definition joinrels.c:1367
static void make_rels_by_clause_joins(PlannerInfo *root, RelOptInfo *old_rel, List *other_rels, int first_rel_idx)
Definition joinrels.c:285
References Assert, bms_overlap(), elog, ERROR, fb(), for_each_from, foreach_current_index, has_join_restriction(), have_join_order_restriction(), have_relevant_joinclause(), lfirst, make_join_rel(), make_rels_by_clause_joins(), make_rels_by_clauseless_joins(), NIL, and root.
Referenced by standard_join_search().
◆ make_canonical_pathkey()
|
extern |
Definition at line 56 of file pathkeys.c.
59{
62 MemoryContext oldcontext;
63
64 /* Can't make canonical pathkeys if the set of ECs might still change */
67
68 /* The passed eclass might be non-canonical, so chase up to the top */
71
73 {
76 opfamily == pk->pk_opfamily &&
77 cmptype == pk->pk_cmptype &&
78 nulls_first == pk->pk_nulls_first)
80 }
81
82 /*
83 * Be sure canonical pathkeys are allocated in the main planning context.
84 * Not an issue in normal planning, but it is for GEQO.
85 */
87
90 pk->pk_opfamily = opfamily;
91 pk->pk_cmptype = cmptype;
92 pk->pk_nulls_first = nulls_first;
93
95
96 MemoryContextSwitchTo(oldcontext);
97
99}
References eclass(), elog, ERROR, fb(), lappend(), lfirst, makeNode, MemoryContextSwitchTo(), and root.
Referenced by convert_subquery_pathkeys(), get_useful_pathkeys_for_relation(), make_inner_pathkeys_for_merge(), make_pathkey_from_sortinfo(), and select_outer_pathkeys_for_merge().
◆ make_inner_pathkeys_for_merge()
|
extern |
Definition at line 1858 of file pathkeys.c.
1861{
1867
1871
1873 {
1878
1880
1881 if (rinfo->outer_is_left)
1882 {
1883 oeclass = rinfo->left_ec;
1884 ieclass = rinfo->right_ec;
1885 }
1886 else
1887 {
1888 oeclass = rinfo->right_ec;
1889 ieclass = rinfo->left_ec;
1890 }
1891
1892 /* outer eclass should match current or next pathkeys */
1893 /* we check this carefully for debugging reasons */
1895 {
1903 }
1904
1905 /*
1906 * Often, we'll have same EC on both sides, in which case the outer
1907 * pathkey is also canonical for the inner side, and we can skip a
1908 * useless search.
1909 */
1912 else
1914 ieclass,
1915 opathkey->pk_opfamily,
1916 opathkey->pk_cmptype,
1917 opathkey->pk_nulls_first);
1918
1919 /*
1920 * Don't generate redundant pathkeys (which can happen if multiple
1921 * mergeclauses refer to the same EC). Because we do this, the output
1922 * pathkey list isn't necessarily ordered like the mergeclauses, which
1923 * complicates life for create_mergejoin_plan(). But if we didn't,
1924 * we'd have a noncanonical sort key list, which would be bad; for one
1925 * reason, it certainly wouldn't match any available sort order for
1926 * the input relation.
1927 */
1930 }
1931
1932 return pathkeys;
1933}
References elog, ERROR, fb(), lappend(), lfirst, list_head(), lnext(), make_canonical_pathkey(), NIL, pathkey_is_redundant(), root, and update_mergeclause_eclasses().
Referenced by generate_mergejoin_paths(), and sort_inner_and_outer().
◆ make_join_rel()
|
extern |
Definition at line 699 of file joinrels.c.
700{
702 SpecialJoinInfo *sjinfo;
706 RelOptInfo *joinrel;
707 List *restrictlist;
708
709 /* We should never try to join two overlapping sets of rels. */
711
712 /* Construct Relids set that identifies the joinrel (without OJ as yet). */
714
715 /* Check validity and determine join type. */
717 &sjinfo, &reversed))
718 {
719 /* invalid join path */
722 }
723
724 /*
725 * Add outer join relid(s) to form the canonical relids. Any added outer
726 * joins besides sjinfo itself are appended to pushed_down_joins.
727 */
729 &pushed_down_joins);
730
731 /* Swap rels if needed to match the join info. */
733 {
735
738 }
739
740 /*
741 * If it's a plain inner join, then we won't have found anything in
742 * join_info_list. Make up a SpecialJoinInfo so that selectivity
743 * estimation functions will know what's being joined.
744 */
746 {
747 sjinfo = &sjinfo_data;
749 }
750
751 /*
752 * Find or build the join RelOptInfo, and compute the restrictlist that
753 * goes with this particular joining.
754 */
756 sjinfo, pushed_down_joins,
757 &restrictlist);
758
759 /*
760 * If we've already proven this join is empty, we needn't consider any
761 * more paths for it.
762 */
764 {
766 return joinrel;
767 }
768
769 /* Build a grouped join relation for 'joinrel' if possible. */
771 restrictlist);
772
773 /* Add paths to the join relation. */
775 restrictlist);
776
778
779 return joinrel;
780}
static void populate_joinrel_with_paths(PlannerInfo *root, RelOptInfo *rel1, RelOptInfo *rel2, RelOptInfo *joinrel, SpecialJoinInfo *sjinfo, List *restrictlist)
Definition joinrels.c:1072
void init_dummy_sjinfo(SpecialJoinInfo *sjinfo, Relids left_relids, Relids right_relids)
Definition joinrels.c:664
static void make_grouped_join_rel(PlannerInfo *root, RelOptInfo *rel1, RelOptInfo *rel2, RelOptInfo *joinrel, SpecialJoinInfo *sjinfo, List *restrictlist)
Definition joinrels.c:916
static bool join_is_legal(PlannerInfo *root, RelOptInfo *rel1, RelOptInfo *rel2, Relids joinrelids, SpecialJoinInfo **sjinfo_p, bool *reversed_p)
Definition joinrels.c:355
RelOptInfo * build_join_rel(PlannerInfo *root, Relids joinrelids, RelOptInfo *outer_rel, RelOptInfo *inner_rel, SpecialJoinInfo *sjinfo, List *pushed_down_joins, List **restrictlist_ptr)
Definition relnode.c:784
References add_outer_joins_to_relids(), Assert, bms_free(), bms_overlap(), bms_union(), build_join_rel(), fb(), init_dummy_sjinfo(), is_dummy_rel(), join_is_legal(), make_grouped_join_rel(), NIL, populate_joinrel_with_paths(), and root.
Referenced by join_search_one_level(), make_rels_by_clause_joins(), make_rels_by_clauseless_joins(), and merge_clump().
◆ make_one_rel()
|
extern |
Definition at line 177 of file allpaths.c.
178{
179 RelOptInfo *rel;
180 Index rti;
182
183 /* Mark base rels as to whether we care about fast-start plans */
185
186 /*
187 * Compute size estimates and consider_parallel flags for each base rel.
188 */
190
191 /*
192 * Build grouped relations for simple rels (i.e., base or "other" member
193 * relations) where possible.
194 */
196
197 /*
198 * We should now have size estimates for every actual table involved in
199 * the query, and we also know which if any have been deleted from the
200 * query by join removal, pruned by partition pruning, or eliminated by
201 * constraint exclusion. So we can now compute total_table_pages.
202 *
203 * Note that appendrels are not double-counted here, even though we don't
204 * bother to distinguish RelOptInfos for appendrel parents, because the
205 * parents will have pages = 0.
206 *
207 * XXX if a table is self-joined, we will count it once per appearance,
208 * which perhaps is the wrong thing ... but that's not completely clear,
209 * and detecting self-joins here is difficult, so ignore it for now.
210 */
211 total_pages = 0;
213 {
215
216 /* there may be empty slots corresponding to non-baserel RTEs */
218 continue;
219
221
223 continue;
224
227 }
229
230 /*
231 * Generate access paths for each base rel.
232 */
234
235 /*
236 * Generate access paths for the entire join tree.
237 */
239
240 /*
241 * The result should join all and only the query's base + outer-join rels.
242 */
244
245 return rel;
246}
static void set_base_rel_consider_startup(PlannerInfo *root)
Definition allpaths.c:259
static void set_base_rel_pathlists(PlannerInfo *root)
Definition allpaths.c:378
static RelOptInfo * make_rel_from_joinlist(PlannerInfo *root, List *joinlist)
Definition allpaths.c:3780
static void setup_simple_grouped_rels(PlannerInfo *root)
Definition allpaths.c:344
References Assert, bms_equal(), fb(), IS_DUMMY_REL, IS_SIMPLE_REL, make_rel_from_joinlist(), RelOptInfo::relids, root, set_base_rel_consider_startup(), set_base_rel_pathlists(), set_base_rel_sizes(), and setup_simple_grouped_rels().
Referenced by query_planner().
◆ make_pathkeys_for_sortclauses()
|
extern |
Definition at line 1336 of file pathkeys.c.
1339{
1340 List *result;
1342
1344 &sortclauses,
1345 tlist,
1346 false,
1347 false,
1348 &sortable,
1349 false);
1350 /* It's caller error if not all clauses were sortable */
1352 return result;
1353}
List * make_pathkeys_for_sortclauses_extended(PlannerInfo *root, List **sortclauses, List *tlist, bool remove_redundant, bool remove_group_rtindex, bool *sortable, bool set_ec_sortref)
Definition pathkeys.c:1381
References Assert, fb(), make_pathkeys_for_sortclauses_extended(), and root.
Referenced by adjust_group_pathkeys_for_groupagg(), create_unique_paths(), generate_grouped_paths(), generate_nonunion_paths(), generate_union_paths(), grouping_planner(), make_pathkeys_for_window(), minmax_qp_callback(), and standard_qp_callback().
◆ make_pathkeys_for_sortclauses_extended()
|
extern |
Definition at line 1381 of file pathkeys.c.
1388{
1390 ListCell *l;
1391
1394 {
1398
1401 {
1403 continue;
1404 }
1406 {
1411 NULL);
1412 }
1414 sortkey,
1415 sortcl->sortop,
1416 sortcl->reverse_sort,
1417 sortcl->nulls_first,
1418 sortcl->tleSortGroupRef,
1419 true);
1421 {
1422 /*
1423 * Copy the sortref if it hasn't been set yet. That may happen if
1424 * the EquivalenceClass was constructed from a WHERE clause, i.e.
1425 * it doesn't have a target reference at all.
1426 */
1428 }
1429
1430 /* Canonical form eliminates redundant ordering keys */
1435 }
1436 return pathkeys;
1437}
static PathKey * make_pathkey_from_sortop(PlannerInfo *root, Expr *expr, Oid ordering_op, bool reverse_sort, bool nulls_first, Index sortref, bool create_it)
Definition pathkeys.c:256
Node * remove_nulling_relids(Node *node, const Bitmapset *removable_relids, const Bitmapset *except_relids)
Definition rewriteManip.c:1328
Node * get_sortgroupclause_expr(SortGroupClause *sgClause, List *targetList)
Definition tlist.c:388
References Assert, bms_make_singleton(), fb(), foreach_delete_current, get_sortgroupclause_expr(), lappend(), lfirst, make_pathkey_from_sortop(), NIL, OidIsValid, pathkey_is_redundant(), remove_nulling_relids(), and root.
Referenced by make_pathkeys_for_sortclauses(), make_pathkeys_for_window(), and standard_qp_callback().
◆ mark_dummy_rel()
|
extern |
Definition at line 1513 of file joinrels.c.
1514{
1515 MemoryContext oldcontext;
1516
1517 /* Already marked? */
1519 return;
1520
1521 /* No, so choose correct context to make the dummy path in */
1523
1524 /* Set dummy size estimate */
1525 rel->rows = 0;
1526
1527 /* Evict any previously chosen paths */
1530
1531 /* Set up the dummy path */
1534 0, false, -1));
1535
1536 /* Set or update cheapest_total_path and related fields */
1537 set_cheapest(rel);
1538
1539 MemoryContextSwitchTo(oldcontext);
1540}
References add_path(), create_append_path(), fb(), GetMemoryChunkContext(), is_dummy_rel(), RelOptInfo::lateral_relids, MemoryContextSwitchTo(), NIL, RelOptInfo::partial_pathlist, RelOptInfo::pathlist, RelOptInfo::rows, and set_cheapest().
Referenced by build_setop_child_paths(), build_simple_rel(), generate_grouped_paths(), generate_nonunion_paths(), generate_partitionwise_join_paths(), generate_union_paths(), and populate_joinrel_with_paths().
◆ match_eclasses_to_foreign_key_col()
|
extern |
Definition at line 2709 of file equivclass.c.
2712{
2723
2724 /* Consider only eclasses mentioning both relations */
2729 rel2->eclass_indexes);
2730
2731 i = -1;
2733 {
2735 i);
2739
2740 /* Never match to a volatile EC */
2742 continue;
2743
2744 /*
2745 * It's okay to consider "broken" ECs here, see exprs_known_equal.
2746 * Ignore children here.
2747 */
2749 {
2751 Var *var;
2752
2753 /* Child members should not exist in ec_members */
2755
2756 /* EM must be a Var, possibly with RelabelType */
2761 continue;
2762
2763 /* Match? */
2768
2769 /* Have we found both PK and FK column in this EC? */
2771 {
2772 /*
2773 * Succeed if eqop matches EC's opfamilies. We could test
2774 * this before scanning the members, but it's probably cheaper
2775 * to test for member matches first.
2776 */
2780 {
2781 fkinfo->eclass[colno] = ec;
2783 return ec;
2784 }
2785 /* Otherwise, done with this EC, move on to the next */
2786 break;
2787 }
2788 }
2789 }
2791}
Bitmapset * bms_intersect(const Bitmapset *a, const Bitmapset *b)
Definition bitmapset.c:292
References arg, Assert, bms_intersect(), bms_next_member(), EquivalenceClass::ec_has_volatile, EquivalenceClass::ec_members, EquivalenceClass::ec_opfamilies, equal(), fb(), get_mergejoin_opfamilies(), i, IS_SIMPLE_REL, IsA, lfirst, list_nth(), NIL, root, Var::varattno, and Var::varno.
Referenced by match_foreign_keys_to_quals().
◆ match_index_to_operand()
|
extern |
Definition at line 4354 of file indxpath.c.
4357{
4359
4360 /*
4361 * Ignore any PlaceHolderVar node contained in the operand. This is
4362 * needed to be able to apply indexscanning in cases where the operand (or
4363 * a subtree) has been wrapped in PlaceHolderVars to enforce separate
4364 * identity or as a result of outer joins.
4365 */
4366 operand = strip_phvs_in_index_operand(operand);
4367
4368 /*
4369 * Ignore any RelabelType node above the operand. This is needed to be
4370 * able to apply indexscanning in binary-compatible-operator cases.
4371 *
4372 * Note: we must handle nested RelabelType nodes here. While
4373 * eval_const_expressions() will have simplified them to at most one
4374 * layer, our prior stripping of PlaceHolderVars may have brought separate
4375 * RelabelTypes into adjacency.
4376 */
4379
4382 {
4383 /*
4384 * Simple index column; operand must be a matching Var.
4385 */
4390 return true;
4391 }
4392 else
4393 {
4394 /*
4395 * Index expression; find the correct expression. (This search could
4396 * be avoided, at the cost of complicating all the callers of this
4397 * routine; doesn't seem worth it.)
4398 */
4402
4405 {
4407 {
4411 }
4412 }
4416
4417 /*
4418 * Does it match the operand? Again, strip any relabeling.
4419 */
4422
4424 return true;
4425 }
4426
4427 return false;
4428}
Node * strip_phvs_in_index_operand(Node *operand)
Definition indxpath.c:4449
References arg, elog, equal(), ERROR, fb(), i, IsA, lfirst, list_head(), lnext(), and strip_phvs_in_index_operand().
Referenced by ec_member_matches_indexcol(), expand_indexqual_rowcompare(), get_actual_variable_range(), group_similar_or_args(), match_boolean_index_clause(), match_clause_to_indexcol(), match_clause_to_ordering_op(), match_funcclause_to_indexcol(), match_opclause_to_indexcol(), match_orclause_to_indexcol(), match_rowcompare_to_indexcol(), match_saopclause_to_indexcol(), and relation_has_unique_index_for().
◆ pathkeys_contained_in()
Definition at line 343 of file pathkeys.c.
344{
346 {
349 return true;
350 default:
351 break;
352 }
353 return false;
354}
References compare_pathkeys(), fb(), PATHKEYS_BETTER2, and PATHKEYS_EQUAL.
Referenced by add_paths_with_pathkeys_for_rel(), adjust_foreign_grouping_path_cost(), consider_groupingsets_paths(), create_gather_merge_path(), create_gather_merge_plan(), create_mergejoin_plan(), generate_mergejoin_paths(), generate_nonunion_paths(), generate_orderedappend_paths(), get_cheapest_fractional_path_for_pathkeys(), get_cheapest_path_for_pathkeys(), get_useful_group_keys_orderings(), GetExistingLocalJoinPath(), initial_cost_mergejoin(), try_mergejoin_path(), and try_partial_mergejoin_path().
◆ pathkeys_count_contained_in()
Definition at line 558 of file pathkeys.c.
559{
560 int n = 0;
562 *key2;
563
564 /*
565 * See if we can avoiding looping through both lists. This optimization
566 * gains us several percent in planning time in a worst-case test.
567 */
569 {
571 return true;
572 }
574 {
575 *n_common = 0;
576 return true;
577 }
579 {
580 *n_common = 0;
581 return false;
582 }
583
584 /*
585 * If both lists are non-empty, iterate through both to find out how many
586 * items are shared.
587 */
589 {
592
594 {
595 *n_common = n;
596 return false;
597 }
598 n++;
599 }
600
601 /* If we ended with a null value, then we've processed the whole list. */
602 *n_common = n;
604}
References fb(), forboth, lfirst, list_length(), and NIL.
Referenced by build_setop_child_paths(), cost_append(), count_common_leading_pathkeys_ordered(), create_append_plan(), create_final_unique_paths(), create_merge_append_path(), create_merge_append_plan(), create_one_window_path(), create_ordered_paths(), create_partial_unique_paths(), create_window_paths(), gather_grouping_paths(), generate_grouped_paths(), generate_useful_gather_paths(), GetExistingLocalJoinPath(), make_ordered_path(), try_mergejoin_path(), and try_partial_mergejoin_path().
◆ process_equivalence()
|
extern |
Definition at line 179 of file equivclass.c.
182{
185 Oid opno,
186 collation,
187 item1_type,
188 item2_type;
192 item2_relids;
195 *ec2;
196 EquivalenceMember *em1,
197 *em2;
200
201 /* Should not already be marked as having generated an eclass */
204
205 /* Reject if it is potentially postponable by security considerations */
207 return false;
208
209 /* Extract info from given clause */
211 opno = ((OpExpr *) clause)->opno;
212 collation = ((OpExpr *) clause)->inputcollid;
217
218 /*
219 * Ensure both input expressions expose the desired collation (their types
220 * should be OK already); see comments for canonicalize_ec_expression.
221 */
224 collation);
227 collation);
228
229 /*
230 * Clauses of the form X=X cannot be translated into EquivalenceClasses.
231 * We'd either end up with a single-entry EC, losing the knowledge that
232 * the clause was present at all, or else make an EC with duplicate
233 * entries, causing other issues.
234 */
236 {
237 /*
238 * If the operator is strict, then the clause can be treated as just
239 * "X IS NOT NULL". (Since we know we are considering a top-level
240 * qual, we can ignore the difference between FALSE and NULL results.)
241 * It's worth making the conversion because we'll typically get a much
242 * better selectivity estimate than we would for X=X.
243 *
244 * If the operator is not strict, we can't be sure what it will do
245 * with NULLs, so don't attempt to optimize it.
246 */
249 {
251
255 ntest->location = -1;
256
257 *p_restrictinfo =
260 restrictinfo->is_pushed_down,
261 restrictinfo->has_clone,
262 restrictinfo->is_clone,
263 restrictinfo->pseudoconstant,
264 restrictinfo->security_level,
265 NULL,
266 restrictinfo->incompatible_relids,
267 restrictinfo->outer_relids);
268 }
269 return false;
270 }
271
272 /*
273 * We use the declared input types of the operator, not exprType() of the
274 * inputs, as the nominal datatypes for opfamily lookup. This presumes
275 * that btree operators are always registered with amoplefttype and
276 * amoprighttype equal to their declared input types. We will need this
277 * info anyway to build EquivalenceMember nodes, and by extracting it now
278 * we can use type comparisons to short-circuit some equal() tests.
279 */
281
283
284 /*
285 * Sweep through the existing EquivalenceClasses looking for matches to
286 * item1 and item2. These are the possible outcomes:
287 *
288 * 1. We find both in the same EC. The equivalence is already known, so
289 * there's nothing to do.
290 *
291 * 2. We find both in different ECs. Merge the two ECs together.
292 *
293 * 3. We find just one. Add the other to its EC.
294 *
295 * 4. We find neither. Make a new, two-entry EC.
296 *
297 * Note: since all ECs are built through this process or the similar
298 * search in get_eclass_for_sort_expr(), it's impossible that we'd match
299 * an item in more than one existing nonvolatile EC. So it's okay to stop
300 * at the first match.
301 */
303 em1 = em2 = NULL;
304 ec2_idx = -1;
306 {
309
310 /* Never match to a volatile EC */
312 continue;
313
314 /*
315 * The collation has to match; check this first since it's cheaper
316 * than the opfamily comparison.
317 */
319 continue;
320
321 /*
322 * A "match" requires matching sets of btree opfamilies. Use of
323 * equal() for this test has implications discussed in the comments
324 * for get_mergejoin_opfamilies().
325 */
327 continue;
328
329 /* We don't expect any children yet */
331
333 {
335
336 /* Child members should not exist in ec_members */
338
339 /*
340 * Match constants only within the same JoinDomain (see
341 * optimizer/README).
342 */
344 continue;
345
349 {
351 em1 = cur_em;
353 break;
354 }
355
359 {
362 em2 = cur_em;
364 break;
365 }
366 }
367
369 break;
370 }
371
372 /* Sweep finished, what did we find? */
373
375 {
376 /* If case 1, nothing to do, except add to sources */
378 {
381 restrictinfo->security_level);
383 restrictinfo->security_level);
384 /* mark the RI as associated with this eclass */
387 /* mark the RI as usable with this pair of EMs */
388 restrictinfo->left_em = em1;
389 restrictinfo->right_em = em2;
390 return true;
391 }
392
393 /*
394 * Case 2: need to merge ec1 and ec2. This should never happen after
395 * the ECs have reached canonical state; otherwise, pathkeys could be
396 * rendered non-canonical by the merge, and relation eclass indexes
397 * would get broken by removal of an eq_classes list entry.
398 */
401
402 /*
403 * We add ec2's items to ec1, then set ec2's ec_merged link to point
404 * to ec1 and remove ec2 from the eq_classes list. We cannot simply
405 * delete ec2 because that could leave dangling pointers in existing
406 * PathKeys. We leave it behind with a link so that the merged EC can
407 * be found.
408 */
411
412 /*
413 * Appends ec2's derived clauses to ec1->ec_derives_list and adds them
414 * to ec1->ec_derives_hash if present.
415 */
419 /* can't need to set has_volatile */
421 ec2->ec_min_security);
423 ec2->ec_max_security);
426 /* just to avoid debugging confusion w/ dangling pointers: */
433 restrictinfo->security_level);
435 restrictinfo->security_level);
436 /* mark the RI as associated with this eclass */
439 /* mark the RI as usable with this pair of EMs */
440 restrictinfo->left_em = em1;
441 restrictinfo->right_em = em2;
442 }
444 {
445 /* Case 3: add item2 to ec1 */
447 jdomain, item2_type);
450 restrictinfo->security_level);
452 restrictinfo->security_level);
453 /* mark the RI as associated with this eclass */
456 /* mark the RI as usable with this pair of EMs */
457 restrictinfo->left_em = em1;
458 restrictinfo->right_em = em2;
459 }
461 {
462 /* Case 3: add item1 to ec2 */
464 jdomain, item1_type);
467 restrictinfo->security_level);
469 restrictinfo->security_level);
470 /* mark the RI as associated with this eclass */
473 /* mark the RI as usable with this pair of EMs */
474 restrictinfo->left_em = em1;
475 restrictinfo->right_em = em2;
476 }
477 else
478 {
479 /* Case 4: make a new, two-entry EC */
481
483 ec->ec_collation = collation;
484 ec->ec_childmembers_size = 0;
494 ec->ec_sortref = 0;
499 jdomain, item1_type);
501 jdomain, item2_type);
502
504
505 /* mark the RI as associated with this eclass */
506 restrictinfo->left_ec = ec;
507 restrictinfo->right_ec = ec;
508 /* mark the RI as usable with this pair of EMs */
509 restrictinfo->left_em = em1;
510 restrictinfo->right_em = em2;
511 }
512
513 return true;
514}
void ec_clear_derived_clauses(EquivalenceClass *ec)
Definition equivclass.c:3830
static void ec_add_derived_clauses(EquivalenceClass *ec, List *clauses)
Definition equivclass.c:3732
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
Definition primnodes.h:1981
References add_eq_member(), Assert, bms_join(), canonicalize_ec_expression(), ec_add_derived_clauses(), EquivalenceClass::ec_broken, EquivalenceClass::ec_childmembers, EquivalenceClass::ec_childmembers_size, ec_clear_derived_clauses(), EquivalenceClass::ec_collation, EquivalenceClass::ec_derives_hash, EquivalenceClass::ec_derives_list, EquivalenceClass::ec_has_const, EquivalenceClass::ec_has_volatile, EquivalenceClass::ec_max_security, EquivalenceClass::ec_members, EquivalenceClass::ec_merged, EquivalenceClass::ec_min_security, EquivalenceClass::ec_opfamilies, EquivalenceClass::ec_relids, EquivalenceClass::ec_sortref, EquivalenceClass::ec_sources, elog, equal(), ERROR, exprType(), fb(), foreach_current_index, func_strict(), get_leftop(), get_rightop(), IS_NOT_NULL, is_opclause(), lappend(), lfirst, list_concat(), list_delete_nth_cell(), list_make1, make_restrictinfo(), makeNode, Max, Min, NIL, op_input_types(), root, and set_opfuncid().
Referenced by distribute_qual_to_rels(), reconsider_full_join_clause(), and reconsider_outer_join_clause().
◆ rebuild_eclass_attr_needed()
|
extern |
Definition at line 2573 of file equivclass.c.
2574{
2576
2578 {
2580
2581 /*
2582 * We don't expect any EC child members to exist at this point. Ensure
2583 * that's the case, otherwise, we might be getting asked to do
2584 * something this function hasn't been coded for.
2585 */
2587
2588 /* Need do anything only for a multi-member, no-const EC. */
2590 {
2592
2594 {
2597 PVC_RECURSE_AGGREGATES |
2598 PVC_RECURSE_WINDOWFUNCS |
2599 PVC_INCLUDE_PLACEHOLDERS);
2600
2603 }
2604 }
2605 }
2606}
void add_vars_to_attr_needed(PlannerInfo *root, List *vars, Relids where_needed)
Definition initsplan.c:360
Definition regcomp.c:282
References add_vars_to_attr_needed(), Assert, EquivalenceClass::ec_childmembers, EquivalenceClass::ec_has_const, EquivalenceClass::ec_members, EquivalenceClass::ec_relids, fb(), lfirst, list_free(), list_length(), pull_var_clause(), PVC_INCLUDE_PLACEHOLDERS, PVC_RECURSE_AGGREGATES, PVC_RECURSE_WINDOWFUNCS, and root.
Referenced by remove_leftjoinrel_from_query(), and remove_self_join_rel().
◆ reconsider_outer_join_clauses()
|
extern |
Definition at line 2134 of file equivclass.c.
2135{
2136 bool found;
2137 ListCell *cell;
2138
2139 /* Outer loop repeats until we find no more deductions */
2140 do
2141 {
2142 found = false;
2143
2144 /* Process the LEFT JOIN clauses */
2146 {
2148
2150 {
2152
2153 found = true;
2154 /* remove it from the list */
2155 root->left_join_clauses =
2157 /* throw back a dummy replacement clause (see notes above) */
2160 rinfo->is_pushed_down,
2161 rinfo->has_clone,
2162 rinfo->is_clone,
2163 false, /* pseudoconstant */
2164 0, /* security_level */
2165 rinfo->required_relids,
2166 rinfo->incompatible_relids,
2167 rinfo->outer_relids);
2169 }
2170 }
2171
2172 /* Process the RIGHT JOIN clauses */
2174 {
2176
2178 {
2180
2181 found = true;
2182 /* remove it from the list */
2183 root->right_join_clauses =
2185 /* throw back a dummy replacement clause (see notes above) */
2188 rinfo->is_pushed_down,
2189 rinfo->has_clone,
2190 rinfo->is_clone,
2191 false, /* pseudoconstant */
2192 0, /* security_level */
2193 rinfo->required_relids,
2194 rinfo->incompatible_relids,
2195 rinfo->outer_relids);
2197 }
2198 }
2199
2200 /* Process the FULL JOIN clauses */
2202 {
2204
2206 {
2208
2209 found = true;
2210 /* remove it from the list */
2211 root->full_join_clauses =
2213 /* throw back a dummy replacement clause (see notes above) */
2216 rinfo->is_pushed_down,
2217 rinfo->has_clone,
2218 rinfo->is_clone,
2219 false, /* pseudoconstant */
2220 0, /* security_level */
2221 rinfo->required_relids,
2222 rinfo->incompatible_relids,
2223 rinfo->outer_relids);
2225 }
2226 }
2227 } while (found);
2228
2229 /* Now, any remaining clauses have to be thrown back */
2231 {
2233
2235 }
2237 {
2239
2241 }
2243 {
2245
2247 }
2248}
static bool reconsider_outer_join_clause(PlannerInfo *root, OuterJoinClauseInfo *ojcinfo, bool outer_on_left)
Definition equivclass.c:2256
static bool reconsider_full_join_clause(PlannerInfo *root, OuterJoinClauseInfo *ojcinfo)
Definition equivclass.c:2383
void distribute_restrictinfo_to_rels(PlannerInfo *root, RestrictInfo *restrictinfo)
Definition initsplan.c:3558
Definition pathnodes.h:3220
References distribute_restrictinfo_to_rels(), fb(), foreach_delete_current, RestrictInfo::has_clone, RestrictInfo::incompatible_relids, RestrictInfo::is_clone, RestrictInfo::is_pushed_down, lfirst, make_restrictinfo(), makeBoolConst(), RestrictInfo::outer_relids, reconsider_full_join_clause(), reconsider_outer_join_clause(), RestrictInfo::required_relids, and root.
Referenced by query_planner().
◆ relation_can_be_sorted_early()
|
extern |
Definition at line 1076 of file equivclass.c.
1078{
1082
1083 /*
1084 * Reject volatile ECs immediately; such sorts must always be postponed.
1085 */
1087 return false;
1088
1089 /*
1090 * Try to find an EM directly matching some reltarget member.
1091 */
1093 {
1095
1098 continue;
1099
1100 /*
1101 * Reject expressions involving set-returning functions, as those
1102 * can't be computed early either. (Note: this test and the following
1103 * one are effectively checking properties of targetexpr, so there's
1104 * no point in asking whether some other EC member would be better.)
1105 */
1107 continue;
1108
1109 /*
1110 * If requested, reject expressions that are not parallel-safe. We
1111 * check this last because it's a rather expensive test.
1112 */
1115 continue;
1116
1117 return true;
1118 }
1119
1120 /*
1121 * Try to find an expression computable from the reltarget.
1122 */
1124 require_parallel_safe);
1126 return false;
1127
1128 /*
1129 * Reject expressions involving set-returning functions, as those can't be
1130 * computed early either. (There's no point in looking for another EC
1131 * member in this case; since SRFs can't appear in WHERE, they cannot
1132 * belong to multi-member ECs.)
1133 */
1135 return false;
1136
1137 return true;
1138}
EquivalenceMember * find_ec_member_matching_expr(EquivalenceClass *ec, Expr *expr, Relids relids)
Definition equivclass.c:916
EquivalenceMember * find_computable_ec_member(PlannerInfo *root, EquivalenceClass *ec, List *exprs, Relids relids, bool require_parallel_safe)
Definition equivclass.c:991
Definition pathnodes.h:1852
References EquivalenceClass::ec_has_volatile, expression_returns_set(), PathTarget::exprs, fb(), find_computable_ec_member(), find_ec_member_matching_expr(), is_parallel_safe(), lfirst, RelOptInfo::relids, RelOptInfo::reltarget, and root.
Referenced by get_useful_pathkeys_for_relation().
◆ relation_has_unique_index_for()
|
extern |
Definition at line 4145 of file indxpath.c.
4147{
4149
4150 /* Short-circuit if no indexes... */
4152 return false;
4153
4154 /*
4155 * Examine the rel's restriction clauses for usable var = const clauses
4156 * that we can add to the restrictlist.
4157 */
4159 {
4161
4162 /*
4163 * Note: can_join won't be set for a restriction clause, but
4164 * mergeopfamilies will be if it has a mergejoinable operator and
4165 * doesn't contain volatile functions.
4166 */
4168 continue; /* not mergejoinable */
4169
4170 /*
4171 * The clause certainly doesn't refer to anything but the given rel.
4172 * If either side is pseudoconstant then we can use it.
4173 */
4175 {
4176 /* righthand side is inner */
4178 }
4180 {
4181 /* lefthand side is inner */
4183 }
4184 else
4185 continue;
4186
4187 /* OK, add to list */
4189 }
4190
4191 /* Short-circuit the easy case */
4193 return false;
4194
4195 /* Examine each index of the relation ... */
4197 {
4201
4202 /*
4203 * If the index is not unique, or not immediately enforced, or if it's
4204 * a partial index, it's useless here. We're unable to make use of
4205 * predOK partial unique indexes due to the fact that
4206 * check_index_predicates() also makes use of join predicates to
4207 * determine if the partial index is usable. Here we need proofs that
4208 * hold true before any joins are evaluated.
4209 */
4211 continue;
4212
4213 /*
4214 * Try to find each index column in the list of conditions. This is
4215 * O(N^2) or worse, but we expect all the lists to be short.
4216 */
4218 {
4220
4222 {
4224 Node *rexpr;
4225
4226 /*
4227 * The condition's equality operator must be a member of the
4228 * index opfamily, else it is not asserting the right kind of
4229 * equality behavior for this index. We check this first
4230 * since it's probably cheaper than match_index_to_operand().
4231 */
4233 continue;
4234
4235 /*
4236 * XXX at some point we may need to check collations here too.
4237 * For the moment we assume all collations reduce to the same
4238 * notion of equality.
4239 */
4240
4241 /* OK, see if the condition operand matches the index key */
4242 if (rinfo->outer_is_left)
4244 else
4246
4248 {
4250 {
4253
4254 /*
4255 * Add filter clause into a list allowing caller to
4256 * know if uniqueness have made not only by join
4257 * clauses.
4258 */
4260 bms_is_empty(rinfo->right_relids));
4261 if (extra_clauses)
4262 exprs = lappend(exprs, rinfo);
4264 }
4265
4266 break; /* found a match; column is unique */
4267 }
4268 }
4269
4271 break; /* no match; this index doesn't help us */
4272 }
4273
4274 /* Matched all key columns of this index? */
4276 {
4277 if (extra_clauses)
4278 *extra_clauses = exprs;
4279 return true;
4280 }
4281 }
4282
4283 return false;
4284}
bool match_index_to_operand(Node *operand, int indexcol, IndexOptInfo *index)
Definition indxpath.c:4354
Definition preproc-array_of_struct.c:43
References Assert, RelOptInfo::baserestrictinfo, bms_is_empty, bms_membership(), BMS_SINGLETON, RestrictInfo::clause, fb(), get_leftop(), get_rightop(), RelOptInfo::indexlist, lappend(), lfirst, list_member_oid(), match_index_to_operand(), MemoryContextSwitchTo(), NIL, and root.
Referenced by rel_is_distinct_for().
◆ select_outer_pathkeys_for_merge()
|
extern |
Definition at line 1659 of file pathkeys.c.
1662{
1670
1671 /* Might have no mergeclauses */
1674
1675 /*
1676 * Make arrays of the ECs used by the mergeclauses (dropping any
1677 * duplicates) and their "popularity" scores.
1678 */
1681 necs = 0;
1682
1684 {
1689
1690 /* get the outer eclass */
1692
1693 if (rinfo->outer_is_left)
1694 oeclass = rinfo->left_ec;
1695 else
1696 oeclass = rinfo->right_ec;
1697
1698 /* reject duplicates */
1700 {
1702 break;
1703 }
1705 continue;
1706
1707 /* compute score */
1708 score = 0;
1710 {
1712
1713 /* Child members should not exist in ec_members */
1715
1716 /* Potential future join partner? */
1719 score++;
1720 }
1721
1724 necs++;
1725 }
1726
1727 /*
1728 * Find out if we have all the ECs mentioned in query_pathkeys; if so we
1729 * can generate a sort order that's also useful for final output. If we
1730 * only have a prefix of the query_pathkeys, and that prefix is the entire
1731 * join condition, then it's useful to use the prefix as the pathkeys as
1732 * this increases the chances that an incremental sort will be able to be
1733 * used by the upper planner.
1734 */
1736 {
1738
1740 {
1743
1745 {
1747 break; /* found match */
1748 }
1750 break; /* didn't find match */
1751
1752 matches++;
1753 }
1754 /* if we got to the end of the list, we have them all */
1756 {
1757 /* copy query_pathkeys as starting point for our output */
1759 /* mark their ECs as already-emitted */
1761 {
1764
1766 {
1768 {
1770 break;
1771 }
1772 }
1773 }
1774 }
1775
1776 /*
1777 * If we didn't match to all of the query_pathkeys, but did match to
1778 * all of the join clauses then we'll make use of these as partially
1779 * sorted input is better than nothing for the upper planner as it may
1780 * lead to incremental sorts instead of full sorts.
1781 */
1783 {
1785
1786 /* we have all of the join pathkeys, so nothing more to do */
1789
1790 return pathkeys;
1791 }
1792 }
1793
1794 /*
1795 * Add remaining ECs to the list in popularity order, using a default sort
1796 * ordering. (We could use qsort() here, but the list length is usually
1797 * so small it's not worth it.)
1798 */
1799 for (;;)
1800 {
1803 EquivalenceClass *ec;
1805
1806 best_j = 0;
1809 {
1811 {
1814 }
1815 }
1817 break; /* all done */
1821 ec,
1823 COMPARE_LT,
1824 false);
1825 /* can't be redundant because no duplicate ECs */
1828 }
1829
1832
1833 return pathkeys;
1834}
References Assert, bms_overlap(), COMPARE_LT, EquivalenceClass::ec_opfamilies, fb(), j, lappend(), lfirst, linitial_oid, list_copy(), list_copy_head(), list_length(), make_canonical_pathkey(), NIL, palloc(), pathkey_is_redundant(), pfree(), RelOptInfo::relids, root, and update_mergeclause_eclasses().
Referenced by sort_inner_and_outer().
◆ setup_eclass_member_iterator()
|
extern |
Definition at line 3155 of file equivclass.c.
3157{
3158 it->ec = ec;
3159 /* no need to set this if the class has no child members array set */
3161 it->current_relid = -1;
3164}
References EquivalenceClass::ec_childmembers, EquivalenceClass::ec_members, fb(), and list_head().
Referenced by find_computable_ec_member(), find_ec_member_matching_expr(), find_em_for_rel(), generate_implied_equalities_for_column(), generate_join_implied_equalities_normal(), get_eclass_for_sort_expr(), and match_pathkeys_to_index().
◆ standard_join_search()
|
extern |
Definition at line 3885 of file allpaths.c.
3886{
3888 RelOptInfo *rel;
3889
3890 /*
3891 * This function cannot be invoked recursively within any one planning
3892 * problem, so join_rel_level[] can't be in use already.
3893 */
3895
3896 /*
3897 * We employ a simple "dynamic programming" algorithm: we first find all
3898 * ways to build joins of two jointree items, then all ways to build joins
3899 * of three items (from two-item joins and single items), then four-item
3900 * joins, and so on until we have considered all ways to join all the
3901 * items into one rel.
3902 *
3903 * root->join_rel_level[j] is a list of all the j-item rels. Initially we
3904 * set root->join_rel_level[1] to represent all the single-jointree-item
3905 * relations.
3906 */
3908
3909 root->join_rel_level[1] = initial_rels;
3910
3912 {
3914
3915 /*
3916 * Determine all possible pairs of relations to be joined at this
3917 * level, and build paths for making each one from every available
3918 * pair of lower-level relations.
3919 */
3921
3922 /*
3923 * Run generate_partitionwise_join_paths() and
3924 * generate_useful_gather_paths() for each just-processed joinrel. We
3925 * could not do this earlier because both regular and partial paths
3926 * can get added to a particular joinrel at multiple times within
3927 * join_search_one_level.
3928 *
3929 * After that, we're done creating paths for the joinrel, so run
3930 * set_cheapest().
3931 *
3932 * In addition, we also run generate_grouped_paths() for the grouped
3933 * relation of each just-processed joinrel, and run set_cheapest() for
3934 * the grouped relation afterwards.
3935 */
3937 {
3939
3941
3943
3944 /* Create paths for partitionwise joins. */
3946
3947 /*
3948 * Except for the topmost scan/join rel, consider gathering
3949 * partial paths. We'll do the same for the topmost scan/join rel
3950 * once we know the final targetlist (see grouping_planner's and
3951 * its call to apply_scanjoin_target_to_paths).
3952 */
3955
3956 /* Find and save the cheapest paths for this rel */
3957 set_cheapest(rel);
3958
3959 /*
3960 * Except for the topmost scan/join rel, consider generating
3961 * partial aggregation paths for the grouped relation on top of
3962 * the paths of this rel. After that, we're done creating paths
3963 * for the grouped relation, so run set_cheapest().
3964 */
3966 {
3968
3970
3972 set_cheapest(grouped_rel);
3973 }
3974
3975#ifdef OPTIMIZER_DEBUG
3976 pprint(rel);
3977#endif
3978 }
3979 }
3980
3981 /*
3982 * We should have a single rel at the final level.
3983 */
3987
3989
3991
3992 return rel;
3993}
void generate_useful_gather_paths(PlannerInfo *root, RelOptInfo *rel, bool override_rows)
Definition allpaths.c:3325
void join_search_one_level(PlannerInfo *root, int level)
Definition joinrels.c:78
References Assert, bms_equal(), elog, ERROR, fb(), generate_grouped_paths(), generate_partitionwise_join_paths(), generate_useful_gather_paths(), RelOptInfo::grouped_rel, IS_GROUPED_REL, join_search_one_level(), lfirst, linitial, list_length(), NIL, palloc0(), pprint(), RelOptInfo::relids, root, and set_cheapest().
Referenced by make_rel_from_joinlist().
◆ strip_phvs_in_index_operand()
Definition at line 4449 of file indxpath.c.
4450{
4451 /* Don't mutate/copy if no target PHVs exist */
4453 return operand;
4454
4456}
static Node * strip_phvs_in_index_operand_mutator(Node *node, void *context)
Definition indxpath.c:4492
static bool contain_strippable_phv_walker(Node *node, void *context)
Definition indxpath.c:4467
References contain_strippable_phv_walker(), fb(), and strip_phvs_in_index_operand_mutator().
Referenced by fix_indexqual_operand(), and match_index_to_operand().
◆ trim_mergeclauses_for_inner_pathkeys()
|
extern |
Definition at line 1961 of file pathkeys.c.
1964{
1971
1972 /* No pathkeys => no mergeclauses (though we don't expect this case) */
1975 /* Initialize to consider first pathkey */
1981
1982 /* Scan mergeclauses to see how many we can use */
1984 {
1987
1988 /* Assume we needn't do update_mergeclause_eclasses again here */
1989
1990 /* Check clause's inner-rel EC against current pathkey */
1991 clause_ec = rinfo->outer_is_left ?
1992 rinfo->right_ec : rinfo->left_ec;
1993
1994 /* If we don't have a match, attempt to advance to next pathkey */
1996 {
1997 /* If we had no clauses matching this inner pathkey, must stop */
1999 break;
2000
2001 /* Advance to next inner pathkey, if any */
2003 break;
2008 }
2009
2010 /* If mergeclause matches current inner pathkey, we can use it */
2012 {
2015 }
2016 else
2017 {
2018 /* Else, no hope of adding any more mergeclauses */
2019 break;
2020 }
2021 }
2022
2024}
References fb(), i, lappend(), lfirst, list_head(), lnext(), and NIL.
Referenced by generate_mergejoin_paths().
◆ truncate_useless_pathkeys()
|
extern |
Definition at line 2200 of file pathkeys.c.
2203{
2207
2208 /*
2209 * Here we determine how many items in 'pathkeys' might be useful for
2210 * various Path sort ordering requirements the planner has. Operations
2211 * such as ORDER BY require a Path's pathkeys to match the PathKeys of the
2212 * ORDER BY in the same order, however operations such as GROUP BY and
2213 * DISTINCT are less critical as a Unique or GroupAggregate only need to
2214 * care that all PathKeys exist in their subpath, and don't need to care
2215 * if they're in the same order as the clause in the query.
2216 */
2218 pathkeys);
2219
2220 /* Short-circuit at any point we discover *all* pathkeys are useful */
2222 return pathkeys;
2223
2225 pathkeys);
2227 return pathkeys;
2228
2231 pathkeys);
2233 return pathkeys;
2234
2236
2237 /*
2238 * Check if these pathkeys are useful for GROUP BY or DISTINCT. The order
2239 * of the pathkeys does not matter here as Unique and GroupAggregate for
2240 * these operations can take advantage of Paths presorted by any of the
2241 * GROUP BY/DISTINCT pathkeys.
2242 */
2244 pathkeys);
2246 return pathkeys;
2247
2250 pathkeys);
2251
2253 return pathkeys;
2254
2256
2257 /*
2258 * Finally, check how many PathKeys might be useful for Merge Joins. This
2259 * is a bit more expensive, so do it last and only if we've not figured
2260 * out that all the pathkeys are useful already.
2261 */
2264
2265 /*
2266 * Note: not safe to modify input list destructively, but we can avoid
2267 * copying the list if we're not actually going to change it
2268 */
2270 return pathkeys;
2271 else
2273}
static int count_common_leading_pathkeys_ordered(List *keys1, List *keys2)
Definition pathkeys.c:2154
static int count_common_leading_pathkeys_unordered(List *keys1, List *keys2)
Definition pathkeys.c:2169
static int pathkeys_useful_for_merging(PlannerInfo *root, RelOptInfo *rel, List *pathkeys)
Definition pathkeys.c:2056
References count_common_leading_pathkeys_ordered(), count_common_leading_pathkeys_unordered(), fb(), list_copy_head(), list_length(), Max, pathkeys_useful_for_merging(), and root.
Referenced by build_index_paths(), and build_join_pathkeys().
◆ update_mergeclause_eclasses()
|
extern |
Definition at line 1510 of file pathkeys.c.
1511{
1512 /* Should be a merge clause ... */
1514 /* ... with pointers already set */
1517
1518 /* Chase up to the top as needed */
1523}
References Assert, fb(), and NIL.
Referenced by find_mergeclauses_for_outer_pathkeys(), get_useful_ecs_for_relation(), make_inner_pathkeys_for_merge(), pathkeys_useful_for_merging(), select_mergejoin_clauses(), and select_outer_pathkeys_for_merge().
Variable Documentation
◆ enable_eager_aggregate
|
extern |
Definition at line 82 of file allpaths.c.
Referenced by setup_eager_aggregation().
◆ enable_geqo
|
extern |
Definition at line 81 of file allpaths.c.
Referenced by make_rel_from_joinlist().
◆ enable_group_by_reordering
|
extern |
Definition at line 32 of file pathkeys.c.
Referenced by get_useful_group_keys_orderings().
◆ geqo_threshold
|
extern |
Definition at line 83 of file allpaths.c.
Referenced by make_rel_from_joinlist().
◆ join_path_setup_hook
|
extern |
Definition at line 32 of file joinpath.c.
Referenced by add_paths_to_joinrel().
◆ join_search_hook
|
extern |
Definition at line 92 of file allpaths.c.
Referenced by make_rel_from_joinlist().
◆ min_eager_agg_group_size
|
extern |
Definition at line 84 of file allpaths.c.
Referenced by create_rel_agg_info().
◆ min_parallel_index_scan_size
|
extern |
Definition at line 86 of file allpaths.c.
Referenced by compute_parallel_worker(), and parallel_vacuum_compute_workers().
◆ min_parallel_table_scan_size
|
extern |
Definition at line 85 of file allpaths.c.
Referenced by compute_parallel_worker().
◆ set_join_pathlist_hook
|
extern |
Definition at line 31 of file joinpath.c.
Referenced by add_paths_to_joinrel().
◆ set_rel_pathlist_hook
|
extern |
Definition at line 89 of file allpaths.c.
Referenced by set_rel_pathlist().
