37 #define PATH_PARAM_BY_PARENT(path, rel) \
38 ((path)->param_info && bms_overlap(PATH_REQ_OUTER(path), \
39 (rel)->top_parent_relids))
40 #define PATH_PARAM_BY_REL_SELF(path, rel) \
41 ((path)->param_info && bms_overlap(PATH_REQ_OUTER(path), (rel)->relids))
43 #define PATH_PARAM_BY_REL(path, rel) \
44 (PATH_PARAM_BY_REL_SELF(path, rel) || PATH_PARAM_BY_PARENT(path, rel))
77 Path *inner_cheapest_total);
87 bool *mergejoin_allowed);
95 Path *inner_cheapest_total,
133 bool mergejoin_allowed =
true;
147 joinrelids = joinrel->
relids;
225 jointype, sjinfo, restrictlist,
242 foreach(lc,
root->join_info_list)
282 if (mergejoin_allowed)
294 if (mergejoin_allowed)
311 if (mergejoin_allowed)
312 match_unsorted_inner(
root, joinrel, outerrel, innerrel,
330 if (joinrel->fdwroutine &&
331 joinrel->fdwroutine->GetForeignJoinPaths)
332 joinrel->fdwroutine->GetForeignJoinPaths(
root, joinrel,
371 return (
bms_overlap(inner_paramrels, outerrelids) &&
388 #ifdef USE_ASSERT_CHECKING
402 foreach(lc,
root->join_info_list)
441 List **param_exprs,
List **operators,
449 *binary_mode =
false;
452 if (param_info != NULL)
477 if (rinfo->outer_is_left)
480 hasheqoperator = rinfo->left_hasheqoperator;
485 hasheqoperator = rinfo->right_hasheqoperator;
503 *operators =
lappend_oid(*operators, hasheqoperator);
504 *param_exprs =
lappend(*param_exprs, expr);
556 *param_exprs =
lappend(*param_exprs, expr);
587 List *hash_operators;
601 if (outer_path->parent->
rows < 2)
609 if ((inner_path->param_info == NULL ||
610 inner_path->param_info->ppi_clauses ==
NIL) &&
654 (inner_path->param_info == NULL ||
681 if (inner_path->param_info != NULL)
683 foreach(lc, inner_path->param_info->ppi_clauses)
694 inner_path->param_info,
695 outerrel->top_parent ?
696 outerrel->top_parent : outerrel,
759 innerrelids = innerrel->
relids;
764 outerrelids = outerrel->
relids;
774 innerrelids, inner_paramrels);
775 if (required_outer &&
786 Assert(!have_unsafe_outer_join_ref(
root, outerrelids, inner_paramrels));
812 outer_path, inner_path, extra);
816 pathkeys, required_outer))
860 if (inner_path->param_info != NULL)
862 Relids inner_paramrels = inner_path->param_info->ppi_req_outer;
874 outerrelids = outerrel->
relids;
896 outer_path, inner_path, extra);
967 if (required_outer &&
990 outer_path, inner_path,
991 outersortkeys, innersortkeys,
996 pathkeys, required_outer))
1032 List *outersortkeys,
1033 List *innersortkeys,
1043 if (inner_path->param_info != NULL)
1045 Relids inner_paramrels = inner_path->param_info->ppi_req_outer;
1055 if (outersortkeys &&
1057 outersortkeys =
NIL;
1058 if (innersortkeys &&
1060 innersortkeys =
NIL;
1066 outer_path, inner_path,
1067 outersortkeys, innersortkeys,
1124 if (required_outer &&
1137 outer_path, inner_path, extra,
false);
1141 NIL, required_outer))
1191 if (inner_path->param_info != NULL)
1193 Relids inner_paramrels = inner_path->param_info->ppi_req_outer;
1204 outer_path, inner_path, extra, parallel_hash);
1241 rinfo->outer_is_left =
true;
1248 rinfo->outer_is_left =
false;
1276 Path *cheapest_partial_outer = NULL;
1277 Path *cheapest_safe_inner = NULL;
1314 outer_path, extra->
sjinfo);
1321 inner_path, extra->
sjinfo);
1345 cheapest_safe_inner = inner_path;
1347 cheapest_safe_inner =
1383 foreach(l, all_pathkeys)
1386 List *cur_mergeclauses;
1389 List *merge_pathkeys;
1393 outerkeys =
lcons(front_pathkey,
1397 outerkeys = all_pathkeys;
1440 if (cheapest_partial_outer && cheapest_safe_inner)
1443 cheapest_partial_outer,
1444 cheapest_safe_inner,
1476 Path *inner_cheapest_total,
1477 List *merge_pathkeys,
1481 List *innersortkeys;
1482 List *trialsortkeys;
1483 Path *cheapest_startup_inner;
1484 Path *cheapest_total_inner;
1507 if (mergeclauses ==
NIL)
1514 if (useallclauses &&
1532 inner_cheapest_total,
1578 cheapest_startup_inner = inner_cheapest_total;
1579 cheapest_total_inner = inner_cheapest_total;
1584 cheapest_startup_inner = NULL;
1585 cheapest_total_inner = NULL;
1588 if (num_sortkeys > 1 && !useallclauses)
1589 trialsortkeys =
list_copy(innersortkeys);
1591 trialsortkeys = innersortkeys;
1593 for (sortkeycnt = num_sortkeys; sortkeycnt > 0; sortkeycnt--)
1609 if (innerpath != NULL &&
1610 (cheapest_total_inner == NULL ||
1616 if (sortkeycnt < num_sortkeys)
1625 newclauses = mergeclauses;
1637 cheapest_total_inner = innerpath;
1645 if (innerpath != NULL &&
1646 (cheapest_startup_inner == NULL ||
1651 if (innerpath != cheapest_total_inner)
1657 if (newclauses ==
NIL)
1659 if (sortkeycnt < num_sortkeys)
1668 newclauses = mergeclauses;
1682 cheapest_startup_inner = innerpath;
1728 Path *matpath = NULL;
1745 useallclauses =
false;
1751 useallclauses =
true;
1757 useallclauses =
false;
1760 elog(
ERROR,
"unrecognized join type: %d",
1763 useallclauses =
false;
1773 inner_cheapest_total = NULL;
1782 if (inner_cheapest_total == NULL)
1784 inner_cheapest_total = (
Path *)
1786 Assert(inner_cheapest_total);
1788 else if (nestjoinOK)
1804 List *merge_pathkeys;
1822 outerpath, extra->
sjinfo);
1843 inner_cheapest_total,
1848 else if (nestjoinOK)
1876 innerpath, outerpath, jointype,
1889 if (matpath != NULL)
1904 if (inner_cheapest_total == NULL)
1909 save_jointype, extra, useallclauses,
1910 inner_cheapest_total, merge_pathkeys,
1933 save_jointype, extra);
1940 if (inner_cheapest_total == NULL ||
1949 if (inner_cheapest_total)
1951 save_jointype, extra,
1952 inner_cheapest_total);
1975 Path *inner_cheapest_total)
1983 List *merge_pathkeys;
1992 extra,
false, inner_cheapest_total,
1993 merge_pathkeys,
true);
2065 pathkeys, jointype, extra);
2072 innerpath, outerpath, jointype,
2076 pathkeys, jointype, extra);
2124 if (!restrictinfo->can_join ||
2125 restrictinfo->hashjoinoperator ==
InvalidOid)
2134 hashclauses =
lappend(hashclauses, restrictinfo);
2162 cheapest_total_outer = (
Path *)
2164 cheapest_total_outer, extra->
sjinfo);
2165 Assert(cheapest_total_outer);
2169 cheapest_total_outer,
2170 cheapest_total_inner,
2178 cheapest_total_inner = (
Path *)
2180 cheapest_total_inner, extra->
sjinfo);
2181 Assert(cheapest_total_inner);
2185 cheapest_total_outer,
2186 cheapest_total_inner,
2190 if (cheapest_startup_outer != NULL &&
2191 cheapest_startup_outer != cheapest_total_outer)
2194 cheapest_startup_outer,
2195 cheapest_total_inner,
2212 if (cheapest_startup_outer != NULL)
2215 cheapest_startup_outer,
2216 cheapest_total_inner,
2243 if (outerpath == cheapest_startup_outer &&
2244 innerpath == cheapest_total_inner)
2270 Path *cheapest_partial_outer;
2271 Path *cheapest_partial_inner = NULL;
2272 Path *cheapest_safe_inner = NULL;
2274 cheapest_partial_outer =
2286 cheapest_partial_inner =
2289 cheapest_partial_outer,
2290 cheapest_partial_inner,
2291 hashclauses, jointype, extra,
2307 cheapest_safe_inner = NULL;
2309 cheapest_safe_inner = cheapest_total_inner;
2311 cheapest_safe_inner =
2314 if (cheapest_safe_inner != NULL)
2316 cheapest_partial_outer,
2317 cheapest_safe_inner,
2318 hashclauses, jointype, extra,
2353 bool *mergejoin_allowed)
2357 bool have_nonmergeable_joinclause =
false;
2360 foreach(l, restrictlist)
2374 if (!restrictinfo->can_join ||
2375 restrictinfo->mergeopfamilies ==
NIL)
2384 have_nonmergeable_joinclause =
true;
2393 have_nonmergeable_joinclause =
true;
2410 have_nonmergeable_joinclause =
true;
2414 result_list =
lappend(result_list, restrictinfo);
2425 *mergejoin_allowed = !have_nonmergeable_joinclause;
2428 *mergejoin_allowed =
true;
bool innerrel_is_unique(PlannerInfo *root, Relids joinrelids, Relids outerrelids, RelOptInfo *innerrel, JoinType jointype, List *restrictlist, bool force_cache)
Bitmapset * bms_join(Bitmapset *a, Bitmapset *b)
bool bms_is_subset(const Bitmapset *a, const Bitmapset *b)
void bms_free(Bitmapset *a)
int bms_num_members(const Bitmapset *a)
bool bms_is_member(int x, const Bitmapset *a)
Bitmapset * bms_difference(const Bitmapset *a, const Bitmapset *b)
Bitmapset * bms_intersect(const Bitmapset *a, const Bitmapset *b)
Bitmapset * bms_add_members(Bitmapset *a, const Bitmapset *b)
bool bms_overlap(const Bitmapset *a, const Bitmapset *b)
bool bms_nonempty_difference(const Bitmapset *a, const Bitmapset *b)
#define Assert(condition)
#define OidIsValid(objectId)
bool contain_volatile_functions(Node *clause)
void initial_cost_mergejoin(PlannerInfo *root, JoinCostWorkspace *workspace, JoinType jointype, List *mergeclauses, Path *outer_path, Path *inner_path, List *outersortkeys, List *innersortkeys, JoinPathExtraData *extra)
void compute_semi_anti_join_factors(PlannerInfo *root, RelOptInfo *joinrel, RelOptInfo *outerrel, RelOptInfo *innerrel, JoinType jointype, SpecialJoinInfo *sjinfo, List *restrictlist, SemiAntiJoinFactors *semifactors)
void initial_cost_hashjoin(PlannerInfo *root, JoinCostWorkspace *workspace, JoinType jointype, List *hashclauses, Path *outer_path, Path *inner_path, JoinPathExtraData *extra, bool parallel_hash)
void initial_cost_nestloop(PlannerInfo *root, JoinCostWorkspace *workspace, JoinType jointype, Path *outer_path, Path *inner_path, JoinPathExtraData *extra)
bool enable_parallel_hash
bool ExecMaterializesOutput(NodeTag plantype)
if(TABLE==NULL||TABLE_index==NULL)
static void try_hashjoin_path(PlannerInfo *root, RelOptInfo *joinrel, Path *outer_path, Path *inner_path, List *hashclauses, JoinType jointype, JoinPathExtraData *extra)
static Path * get_memoize_path(PlannerInfo *root, RelOptInfo *innerrel, RelOptInfo *outerrel, Path *inner_path, Path *outer_path, JoinType jointype, JoinPathExtraData *extra)
static bool clause_sides_match_join(RestrictInfo *rinfo, RelOptInfo *outerrel, RelOptInfo *innerrel)
static List * select_mergejoin_clauses(PlannerInfo *root, RelOptInfo *joinrel, RelOptInfo *outerrel, RelOptInfo *innerrel, List *restrictlist, JoinType jointype, bool *mergejoin_allowed)
static void sort_inner_and_outer(PlannerInfo *root, RelOptInfo *joinrel, RelOptInfo *outerrel, RelOptInfo *innerrel, JoinType jointype, JoinPathExtraData *extra)
void add_paths_to_joinrel(PlannerInfo *root, RelOptInfo *joinrel, RelOptInfo *outerrel, RelOptInfo *innerrel, JoinType jointype, SpecialJoinInfo *sjinfo, List *restrictlist)
static bool paraminfo_get_equal_hashops(PlannerInfo *root, ParamPathInfo *param_info, RelOptInfo *outerrel, RelOptInfo *innerrel, List **param_exprs, List **operators, bool *binary_mode)
static void try_nestloop_path(PlannerInfo *root, RelOptInfo *joinrel, Path *outer_path, Path *inner_path, List *pathkeys, JoinType jointype, JoinPathExtraData *extra)
static void consider_parallel_nestloop(PlannerInfo *root, RelOptInfo *joinrel, RelOptInfo *outerrel, RelOptInfo *innerrel, JoinType jointype, JoinPathExtraData *extra)
#define PATH_PARAM_BY_PARENT(path, rel)
set_join_pathlist_hook_type set_join_pathlist_hook
static void try_mergejoin_path(PlannerInfo *root, RelOptInfo *joinrel, Path *outer_path, Path *inner_path, List *pathkeys, List *mergeclauses, List *outersortkeys, List *innersortkeys, JoinType jointype, JoinPathExtraData *extra, bool is_partial)
static void consider_parallel_mergejoin(PlannerInfo *root, RelOptInfo *joinrel, RelOptInfo *outerrel, RelOptInfo *innerrel, JoinType jointype, JoinPathExtraData *extra, Path *inner_cheapest_total)
static void generate_mergejoin_paths(PlannerInfo *root, RelOptInfo *joinrel, RelOptInfo *innerrel, Path *outerpath, JoinType jointype, JoinPathExtraData *extra, bool useallclauses, Path *inner_cheapest_total, List *merge_pathkeys, bool is_partial)
static void hash_inner_and_outer(PlannerInfo *root, RelOptInfo *joinrel, RelOptInfo *outerrel, RelOptInfo *innerrel, JoinType jointype, JoinPathExtraData *extra)
static void try_partial_mergejoin_path(PlannerInfo *root, RelOptInfo *joinrel, Path *outer_path, Path *inner_path, List *pathkeys, List *mergeclauses, List *outersortkeys, List *innersortkeys, JoinType jointype, JoinPathExtraData *extra)
#define PATH_PARAM_BY_REL(path, rel)
static bool allow_star_schema_join(PlannerInfo *root, Relids outerrelids, Relids inner_paramrels)
static void try_partial_hashjoin_path(PlannerInfo *root, RelOptInfo *joinrel, Path *outer_path, Path *inner_path, List *hashclauses, JoinType jointype, JoinPathExtraData *extra, bool parallel_hash)
static void match_unsorted_outer(PlannerInfo *root, RelOptInfo *joinrel, RelOptInfo *outerrel, RelOptInfo *innerrel, JoinType jointype, JoinPathExtraData *extra)
static void try_partial_nestloop_path(PlannerInfo *root, RelOptInfo *joinrel, Path *outer_path, Path *inner_path, List *pathkeys, JoinType jointype, JoinPathExtraData *extra)
bool have_dangerous_phv(PlannerInfo *root, Relids outer_relids, Relids inner_params)
List * list_truncate(List *list, int new_size)
List * lappend(List *list, void *datum)
List * lappend_oid(List *list, Oid datum)
List * list_copy(const List *oldlist)
List * list_delete_nth_cell(List *list, int n)
void list_free(List *list)
bool list_member(const List *list, const void *datum)
List * lcons(void *datum, List *list)
Oid exprType(const Node *expr)
#define IsA(nodeptr, _type_)
#define IS_OUTER_JOIN(jointype)
List * build_join_pathkeys(PlannerInfo *root, RelOptInfo *joinrel, JoinType jointype, List *outer_pathkeys)
List * make_inner_pathkeys_for_merge(PlannerInfo *root, List *mergeclauses, List *outer_pathkeys)
Path * get_cheapest_path_for_pathkeys(List *paths, List *pathkeys, Relids required_outer, CostSelector cost_criterion, bool require_parallel_safe)
List * find_mergeclauses_for_outer_pathkeys(PlannerInfo *root, List *pathkeys, List *restrictinfos)
List * trim_mergeclauses_for_inner_pathkeys(PlannerInfo *root, List *mergeclauses, List *pathkeys)
List * select_outer_pathkeys_for_merge(PlannerInfo *root, List *mergeclauses, RelOptInfo *joinrel)
void update_mergeclause_eclasses(PlannerInfo *root, RestrictInfo *restrictinfo)
Path * get_cheapest_parallel_safe_total_inner(List *paths)
bool pathkeys_contained_in(List *keys1, List *keys2)
NestPath * create_nestloop_path(PlannerInfo *root, RelOptInfo *joinrel, JoinType jointype, JoinCostWorkspace *workspace, JoinPathExtraData *extra, Path *outer_path, Path *inner_path, List *restrict_clauses, List *pathkeys, Relids required_outer)
Relids calc_non_nestloop_required_outer(Path *outer_path, Path *inner_path)
UniquePath * create_unique_path(PlannerInfo *root, RelOptInfo *rel, Path *subpath, SpecialJoinInfo *sjinfo)
bool path_is_reparameterizable_by_child(Path *path, RelOptInfo *child_rel)
Relids calc_nestloop_required_outer(Relids outerrelids, Relids outer_paramrels, Relids innerrelids, Relids inner_paramrels)
MergePath * create_mergejoin_path(PlannerInfo *root, RelOptInfo *joinrel, JoinType jointype, JoinCostWorkspace *workspace, JoinPathExtraData *extra, Path *outer_path, Path *inner_path, List *restrict_clauses, List *pathkeys, Relids required_outer, List *mergeclauses, List *outersortkeys, List *innersortkeys)
MemoizePath * create_memoize_path(PlannerInfo *root, RelOptInfo *rel, Path *subpath, List *param_exprs, List *hash_operators, bool singlerow, bool binary_mode, double calls)
void add_partial_path(RelOptInfo *parent_rel, Path *new_path)
MaterialPath * create_material_path(RelOptInfo *rel, Path *subpath)
HashPath * create_hashjoin_path(PlannerInfo *root, RelOptInfo *joinrel, JoinType jointype, JoinCostWorkspace *workspace, JoinPathExtraData *extra, Path *outer_path, Path *inner_path, bool parallel_hash, List *restrict_clauses, Relids required_outer, List *hashclauses)
bool add_partial_path_precheck(RelOptInfo *parent_rel, Cost total_cost, List *pathkeys)
void add_path(RelOptInfo *parent_rel, Path *new_path)
int compare_path_costs(Path *path1, Path *path2, CostSelector criterion)
bool add_path_precheck(RelOptInfo *parent_rel, Cost startup_cost, Cost total_cost, List *pathkeys, Relids required_outer)
#define EC_MUST_BE_REDUNDANT(eclass)
#define RINFO_IS_PUSHED_DOWN(rinfo, joinrelids)
#define PATH_REQ_OUTER(path)
void(* set_join_pathlist_hook_type)(PlannerInfo *root, RelOptInfo *joinrel, RelOptInfo *outerrel, RelOptInfo *innerrel, JoinType jointype, JoinPathExtraData *extra)
static int list_length(const List *l)
#define foreach_current_index(var_or_cell)
static ListCell * list_head(const List *l)
struct PathTarget * reltarget
List * cheapest_parameterized_paths
struct Path * cheapest_startup_path
struct Path * cheapest_total_path
TypeCacheEntry * lookup_type_cache(Oid type_id, int flags)
#define TYPECACHE_HASH_PROC