36 #define PATH_PARAM_BY_PARENT(path, rel) \
37 ((path)->param_info && bms_overlap(PATH_REQ_OUTER(path), \
38 (rel)->top_parent_relids))
39 #define PATH_PARAM_BY_REL_SELF(path, rel) \
40 ((path)->param_info && bms_overlap(PATH_REQ_OUTER(path), (rel)->relids))
42 #define PATH_PARAM_BY_REL(path, rel) \
43 (PATH_PARAM_BY_REL_SELF(path, rel) || PATH_PARAM_BY_PARENT(path, rel))
76 Path *inner_cheapest_total);
86 bool *mergejoin_allowed);
94 Path *inner_cheapest_total,
132 bool mergejoin_allowed =
true;
146 joinrelids = joinrel->
relids;
224 jointype, sjinfo, restrictlist,
281 if (mergejoin_allowed)
292 if (mergejoin_allowed)
309 if (mergejoin_allowed)
310 match_unsorted_inner(root, joinrel, outerrel, innerrel,
328 if (joinrel->fdwroutine &&
329 joinrel->fdwroutine->GetForeignJoinPaths)
330 joinrel->fdwroutine->GetForeignJoinPaths(root, joinrel,
366 return (
bms_overlap(inner_paramrels, outerrelids) &&
383 #ifdef USE_ASSERT_CHECKING
433 List **param_exprs,
List **operators,
441 *binary_mode =
false;
443 if (param_info != NULL)
468 if (rinfo->outer_is_left)
471 hasheqoperator = rinfo->left_hasheqoperator;
476 hasheqoperator = rinfo->right_hasheqoperator;
487 *operators =
lappend_oid(*operators, hasheqoperator);
488 *param_exprs =
lappend(*param_exprs, expr);
532 *param_exprs =
lappend(*param_exprs, expr);
562 List *hash_operators;
576 if (outer_path->parent->
rows < 2)
584 if ((inner_path->param_info == NULL ||
585 inner_path->param_info->ppi_clauses ==
NIL) &&
629 (inner_path->param_info == NULL ||
652 inner_path->param_info,
653 outerrel->top_parent ?
654 outerrel->top_parent : outerrel,
703 innerrelids = innerrel->
relids;
708 outerrelids = outerrel->
relids;
718 innerrelids, inner_paramrels);
719 if (required_outer &&
730 Assert(!have_unsafe_outer_join_ref(root, outerrelids, inner_paramrels));
742 outer_path, inner_path, extra);
746 pathkeys, required_outer))
811 if (inner_path->param_info != NULL)
813 Relids inner_paramrels = inner_path->param_info->ppi_req_outer;
825 outerrelids = outerrel->
relids;
836 outer_path, inner_path, extra);
912 if (required_outer &&
935 outer_path, inner_path,
936 outersortkeys, innersortkeys,
941 pathkeys, required_outer))
988 if (inner_path->param_info != NULL)
990 Relids inner_paramrels = inner_path->param_info->ppi_req_outer;
1000 if (outersortkeys &&
1002 outersortkeys =
NIL;
1003 if (innersortkeys &&
1005 innersortkeys =
NIL;
1011 outer_path, inner_path,
1012 outersortkeys, innersortkeys,
1058 if (required_outer &&
1071 outer_path, inner_path, extra,
false);
1075 NIL, required_outer))
1125 if (inner_path->param_info != NULL)
1127 Relids inner_paramrels = inner_path->param_info->ppi_req_outer;
1138 outer_path, inner_path, extra, parallel_hash);
1175 rinfo->outer_is_left =
true;
1182 rinfo->outer_is_left =
false;
1210 Path *cheapest_partial_outer = NULL;
1211 Path *cheapest_safe_inner = NULL;
1248 outer_path, extra->
sjinfo);
1255 inner_path, extra->
sjinfo);
1278 cheapest_safe_inner = inner_path;
1280 cheapest_safe_inner =
1316 foreach(l, all_pathkeys)
1319 List *cur_mergeclauses;
1322 List *merge_pathkeys;
1326 outerkeys =
lcons(front_pathkey,
1330 outerkeys = all_pathkeys;
1373 if (cheapest_partial_outer && cheapest_safe_inner)
1376 cheapest_partial_outer,
1377 cheapest_safe_inner,
1409 Path *inner_cheapest_total,
1410 List *merge_pathkeys,
1414 List *innersortkeys;
1415 List *trialsortkeys;
1416 Path *cheapest_startup_inner;
1417 Path *cheapest_total_inner;
1440 if (mergeclauses ==
NIL)
1447 if (useallclauses &&
1465 inner_cheapest_total,
1511 cheapest_startup_inner = inner_cheapest_total;
1512 cheapest_total_inner = inner_cheapest_total;
1517 cheapest_startup_inner = NULL;
1518 cheapest_total_inner = NULL;
1521 if (num_sortkeys > 1 && !useallclauses)
1522 trialsortkeys =
list_copy(innersortkeys);
1524 trialsortkeys = innersortkeys;
1526 for (sortkeycnt = num_sortkeys; sortkeycnt > 0; sortkeycnt--)
1542 if (innerpath != NULL &&
1543 (cheapest_total_inner == NULL ||
1549 if (sortkeycnt < num_sortkeys)
1558 newclauses = mergeclauses;
1570 cheapest_total_inner = innerpath;
1578 if (innerpath != NULL &&
1579 (cheapest_startup_inner == NULL ||
1584 if (innerpath != cheapest_total_inner)
1590 if (newclauses ==
NIL)
1592 if (sortkeycnt < num_sortkeys)
1601 newclauses = mergeclauses;
1615 cheapest_startup_inner = innerpath;
1661 Path *matpath = NULL;
1678 useallclauses =
false;
1683 useallclauses =
true;
1689 useallclauses =
false;
1692 elog(
ERROR,
"unrecognized join type: %d",
1695 useallclauses =
false;
1705 inner_cheapest_total = NULL;
1714 if (inner_cheapest_total == NULL)
1716 inner_cheapest_total = (
Path *)
1718 Assert(inner_cheapest_total);
1720 else if (nestjoinOK)
1736 List *merge_pathkeys;
1754 outerpath, extra->
sjinfo);
1775 inner_cheapest_total,
1780 else if (nestjoinOK)
1808 innerpath, outerpath, jointype,
1821 if (matpath != NULL)
1836 if (inner_cheapest_total == NULL)
1841 save_jointype, extra, useallclauses,
1842 inner_cheapest_total, merge_pathkeys,
1864 save_jointype, extra);
1871 if (inner_cheapest_total == NULL ||
1880 if (inner_cheapest_total)
1882 save_jointype, extra,
1883 inner_cheapest_total);
1906 Path *inner_cheapest_total)
1914 List *merge_pathkeys;
1923 extra,
false, inner_cheapest_total,
1924 merge_pathkeys,
true);
1996 pathkeys, jointype, extra);
2003 innerpath, outerpath, jointype,
2007 pathkeys, jointype, extra);
2055 if (!restrictinfo->can_join ||
2056 restrictinfo->hashjoinoperator ==
InvalidOid)
2065 hashclauses =
lappend(hashclauses, restrictinfo);
2093 cheapest_total_outer = (
Path *)
2095 cheapest_total_outer, extra->
sjinfo);
2096 Assert(cheapest_total_outer);
2100 cheapest_total_outer,
2101 cheapest_total_inner,
2109 cheapest_total_inner = (
Path *)
2111 cheapest_total_inner, extra->
sjinfo);
2112 Assert(cheapest_total_inner);
2116 cheapest_total_outer,
2117 cheapest_total_inner,
2121 if (cheapest_startup_outer != NULL &&
2122 cheapest_startup_outer != cheapest_total_outer)
2125 cheapest_startup_outer,
2126 cheapest_total_inner,
2143 if (cheapest_startup_outer != NULL)
2146 cheapest_startup_outer,
2147 cheapest_total_inner,
2174 if (outerpath == cheapest_startup_outer &&
2175 innerpath == cheapest_total_inner)
2208 Path *cheapest_partial_outer;
2209 Path *cheapest_partial_inner = NULL;
2210 Path *cheapest_safe_inner = NULL;
2212 cheapest_partial_outer =
2224 cheapest_partial_inner =
2227 cheapest_partial_outer,
2228 cheapest_partial_inner,
2229 hashclauses, jointype, extra,
2241 cheapest_safe_inner = cheapest_total_inner;
2243 cheapest_safe_inner =
2246 if (cheapest_safe_inner != NULL)
2248 cheapest_partial_outer,
2249 cheapest_safe_inner,
2250 hashclauses, jointype, extra,
2285 bool *mergejoin_allowed)
2289 bool have_nonmergeable_joinclause =
false;
2292 foreach(l, restrictlist)
2306 if (!restrictinfo->can_join ||
2307 restrictinfo->mergeopfamilies ==
NIL)
2316 have_nonmergeable_joinclause =
true;
2325 have_nonmergeable_joinclause =
true;
2342 have_nonmergeable_joinclause =
true;
2346 result_list =
lappend(result_list, restrictinfo);
2356 *mergejoin_allowed = !have_nonmergeable_joinclause;
2359 *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)
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 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
elog(ERROR, "%s: %s", p2, msg)
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)
Assert(fmt[strlen(fmt) - 1] !='\n')
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)
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)
Relids calc_nestloop_required_outer(Relids outerrelids, Relids outer_paramrels, Relids innerrelids, Relids inner_paramrels)
Path * reparameterize_path_by_child(PlannerInfo *root, Path *path, RelOptInfo *child_rel)
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)
static ListCell * list_head(const List *l)
#define foreach_current_index(cell)
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