47 #define STD_FUZZ_FACTOR 1.01
121 if (fraction <= 0.0 || fraction >= 1.0)
166 #define CONSIDER_PATH_STARTUP_COST(p) \
167 ((p)->param_info == NULL ? (p)->parent->consider_startup : (p)->parent->consider_param_startup)
211 #undef CONSIDER_PATH_STARTUP_COST
244 Path *cheapest_startup_path;
245 Path *cheapest_total_path;
246 Path *best_param_path;
247 List *parameterized_paths;
253 elog(
ERROR,
"could not devise a query plan for the given query");
255 cheapest_startup_path = cheapest_total_path = best_param_path = NULL;
256 parameterized_paths =
NIL;
263 if (path->param_info)
266 parameterized_paths =
lappend(parameterized_paths, path);
272 if (cheapest_total_path)
280 if (best_param_path == NULL)
281 best_param_path = path;
291 best_param_path = path;
295 best_param_path = path;
314 if (cheapest_total_path == NULL)
316 cheapest_startup_path = cheapest_total_path = path;
332 cheapest_startup_path = path;
339 cheapest_total_path = path;
344 if (cheapest_total_path)
345 parameterized_paths =
lcons(cheapest_total_path, parameterized_paths);
351 if (cheapest_total_path == NULL)
352 cheapest_total_path = best_param_path;
353 Assert(cheapest_total_path != NULL);
422 bool accept_new =
true;
424 List *new_path_pathkeys;
434 new_path_pathkeys = new_path->param_info ?
NIL : new_path->
pathkeys;
444 bool remove_old =
false;
469 List *old_path_pathkeys;
471 old_path_pathkeys = old_path->param_info ?
NIL : old_path->
pathkeys;
522 else if (new_path->
rows < old_path->
rows)
524 else if (new_path->
rows > old_path->
rows)
646 List *new_path_pathkeys;
647 bool consider_startup;
651 new_path_pathkeys = required_outer ?
NIL : pathkeys;
676 List *old_path_pathkeys;
678 old_path_pathkeys = old_path->param_info ?
NIL : old_path->
pathkeys;
749 bool accept_new =
true;
769 bool remove_old =
false;
928 Relids required_outer,
int parallel_workers)
933 pathnode->parent = rel;
957 pathnode->parent = rel;
997 List *indexorderbycols,
1008 pathnode->
path.
pathtype = indexonly ? T_IndexOnlyScan : T_IndexScan;
1009 pathnode->
path.parent = rel;
1047 int parallel_degree)
1052 pathnode->
path.parent = rel;
1064 pathnode->
path.param_info,
1065 bitmapqual, loop_count);
1080 Relids required_outer = NULL;
1084 pathnode->
path.parent = rel;
1092 foreach(lc, bitmapquals)
1132 Relids required_outer = NULL;
1136 pathnode->
path.parent = rel;
1144 foreach(lc, bitmapquals)
1185 pathnode->
path.parent = rel;
1197 pathnode->
path.param_info);
1214 pathnode->
path.parent = rel;
1226 pathnode->
path.param_info);
1246 List *subpaths,
List *partial_subpaths,
1248 int parallel_workers,
bool parallel_aware,
1254 Assert(!parallel_aware || parallel_workers > 0);
1257 pathnode->
path.parent = rel;
1384 return bms_compare(path1->parent->relids, path2->parent->relids);
1406 return bms_compare(path1->parent->relids, path2->parent->relids);
1422 Cost input_startup_cost;
1423 Cost input_total_cost;
1427 pathnode->
path.parent = rel;
1450 input_startup_cost = 0;
1451 input_total_cost = 0;
1452 foreach(l, subpaths)
1463 input_startup_cost +=
subpath->startup_cost;
1464 input_total_cost +=
subpath->total_cost;
1504 input_startup_cost, input_total_cost,
1524 pathnode->
path.parent = rel;
1525 pathnode->
path.pathtarget = target;
1526 pathnode->
path.param_info = NULL;
1531 pathnode->
quals = havingqual;
1573 pathnode->
path.parent = rel;
1599 List *param_exprs,
List *hash_operators,
1600 bool singlerow,
bool binary_mode,
double calls)
1607 pathnode->
path.parent = rel;
1693 pathnode->
path.parent = rel;
1756 List *sub_tlist_colnos;
1761 if (sub_tlist_colnos &&
1817 int hashentrysize =
subpath->pathtarget->width + 64;
1883 Relids required_outer,
double *rows)
1886 Cost input_startup_cost = 0;
1887 Cost input_total_cost = 0;
1900 elog(
ERROR,
"gather merge input not sufficiently sorted");
1903 pathnode->
path.parent = rel;
1911 pathnode->
path.pathtarget = target ? target : rel->
reltarget;
1913 input_startup_cost +=
subpath->startup_cost;
1914 input_total_cost +=
subpath->total_cost;
1917 input_startup_cost, input_total_cost, rows);
1943 if (!var || !
IsA(var,
Var) ||
1944 var->
varno != relid)
1968 pathnode->
path.parent = rel;
1969 pathnode->
path.pathtarget = target;
2005 bool trivial_pathtarget,
2011 pathnode->
path.parent = rel;
2023 trivial_pathtarget);
2039 pathnode->
pathtype = T_FunctionScan;
2040 pathnode->parent = rel;
2065 pathnode->
pathtype = T_TableFuncScan;
2066 pathnode->parent = rel;
2092 pathnode->parent = rel;
2118 pathnode->parent = rel;
2143 pathnode->
pathtype = T_NamedTuplestoreScan;
2144 pathnode->parent = rel;
2170 pathnode->parent = rel;
2195 pathnode->
pathtype = T_WorkTableScan;
2196 pathnode->parent = rel;
2225 double rows,
Cost startup_cost,
Cost total_cost,
2228 Path *fdw_outerpath,
2229 List *fdw_restrictinfo,
2238 pathnode->
path.parent = rel;
2239 pathnode->
path.pathtarget = target ? target : rel->
reltarget;
2271 double rows,
Cost startup_cost,
Cost total_cost,
2274 Path *fdw_outerpath,
2275 List *fdw_restrictinfo,
2288 elog(
ERROR,
"parameterized foreign joins are not supported yet");
2291 pathnode->
path.parent = rel;
2292 pathnode->
path.pathtarget = target ? target : rel->
reltarget;
2293 pathnode->
path.param_info = NULL;
2323 double rows,
Cost startup_cost,
Cost total_cost,
2325 Path *fdw_outerpath,
2326 List *fdw_restrictinfo,
2338 pathnode->
path.parent = rel;
2339 pathnode->
path.pathtarget = target ? target : rel->
reltarget;
2340 pathnode->
path.param_info = NULL;
2376 if (!inner_paramrels)
2379 required_outer =
bms_union(outer_paramrels, inner_paramrels);
2383 return required_outer;
2408 if (inner_path->parent->top_parent_relids)
2409 innerrelids = inner_path->parent->top_parent_relids;
2411 innerrelids = inner_path->parent->relids;
2413 if (outer_path->parent->top_parent_relids)
2414 outerrelids = outer_path->parent->top_parent_relids;
2416 outerrelids = outer_path->parent->relids;
2422 required_outer =
bms_union(outer_paramrels, inner_paramrels);
2424 return required_outer;
2452 List *restrict_clauses,
2464 if (outer_path->parent->top_parent_relids)
2465 outerrelids = outer_path->parent->top_parent_relids;
2467 outerrelids = outer_path->parent->relids;
2483 foreach(lc, restrict_clauses)
2488 jclauses =
lappend(jclauses, rinfo);
2490 restrict_clauses = jclauses;
2493 pathnode->
jpath.path.pathtype = T_NestLoop;
2494 pathnode->
jpath.path.parent = joinrel;
2496 pathnode->
jpath.path.param_info =
2504 pathnode->
jpath.path.parallel_aware =
false;
2509 pathnode->
jpath.path.pathkeys = pathkeys;
2548 List *restrict_clauses,
2552 List *outersortkeys,
2553 List *innersortkeys)
2557 pathnode->
jpath.path.pathtype = T_MergeJoin;
2558 pathnode->
jpath.path.parent = joinrel;
2560 pathnode->
jpath.path.param_info =
2568 pathnode->
jpath.path.parallel_aware =
false;
2573 pathnode->
jpath.path.pathkeys = pathkeys;
2615 List *restrict_clauses,
2621 pathnode->
jpath.path.pathtype = T_HashJoin;
2622 pathnode->
jpath.path.parent = joinrel;
2624 pathnode->
jpath.path.param_info =
2632 pathnode->
jpath.path.parallel_aware =
2650 pathnode->
jpath.path.pathkeys =
NIL;
2698 pathnode->
path.parent = rel;
2699 pathnode->
path.pathtarget = target;
2701 pathnode->
path.param_info = NULL;
2721 oldtarget =
subpath->pathtarget;
2799 oldcost = path->pathtarget->cost;
2800 path->pathtarget = target;
2880 pathnode->
path.parent = rel;
2881 pathnode->
path.pathtarget = target;
2883 pathnode->
path.param_info = NULL;
2899 foreach(lc, target->
exprs)
2905 if (tlist_rows < itemrows)
2906 tlist_rows = itemrows;
2944 double limit_tuples)
2950 pathnode->
path.parent = rel;
2954 pathnode->
path.param_info = NULL;
2964 root, pathkeys, presorted_keys,
2972 sort->nPresortedCols = presorted_keys;
2992 double limit_tuples)
2997 pathnode->
path.parent = rel;
3001 pathnode->
path.param_info = NULL;
3043 pathnode->
path.parent = rel;
3044 pathnode->
path.pathtarget = target;
3046 pathnode->
path.param_info = NULL;
3057 pathnode->
qual = qual;
3100 pathnode->
path.parent = rel;
3104 pathnode->
path.param_info = NULL;
3157 pathnode->
path.parent = rel;
3158 pathnode->
path.pathtarget = target;
3160 pathnode->
path.param_info = NULL;
3178 root->num_groupby_pathkeys);
3192 pathnode->
qual = qual;
3195 aggstrategy, aggcosts,
3236 bool is_first =
true;
3237 bool is_first_sort =
true;
3241 pathnode->
path.parent = rel;
3242 pathnode->
path.pathtarget = target;
3275 pathnode->
qual = having_qual;
3282 foreach(lc, rollups)
3312 is_first_sort =
false;
3335 is_first_sort =
false;
3397 pathnode->
path.parent = rel;
3398 pathnode->
path.pathtarget = target;
3400 pathnode->
path.param_info = NULL;
3409 pathnode->
quals = quals;
3413 foreach(lc, mmaggregates)
3489 pathnode->
path.parent = rel;
3490 pathnode->
path.pathtarget = target;
3492 pathnode->
path.param_info = NULL;
3502 pathnode->
qual = qual;
3557 pathnode->
path.parent = rel;
3561 pathnode->
path.param_info = NULL;
3571 pathnode->
cmd = cmd;
3617 pathnode->
path.parent = rel;
3618 pathnode->
path.pathtarget = target;
3620 pathnode->
path.param_info = NULL;
3656 pathnode->
path.parent = rel;
3660 pathnode->
path.param_info = NULL;
3715 CmdType operation,
bool canSetTag,
3717 bool partColsUpdated,
3718 List *resultRelations,
3719 List *updateColnosLists,
3720 List *withCheckOptionLists,
List *returningLists,
3722 List *mergeActionLists,
List *mergeJoinConditions,
3730 updateColnosLists ==
NIL));
3737 pathnode->
path.parent = rel;
3741 pathnode->
path.param_info = NULL;
3759 if (returningLists !=
NIL)
3769 pathnode->
path.pathtarget->width =
subpath->pathtarget->width;
3774 pathnode->
path.pathtarget->width = 0;
3816 Node *limitOffset,
Node *limitCount,
3818 int64 offset_est, int64 count_est)
3823 pathnode->
path.parent = rel;
3827 pathnode->
path.param_info = NULL;
3847 offset_est, count_est);
3875 double input_rows = *rows;
3876 Cost input_startup_cost = *startup_cost;
3877 Cost input_total_cost = *total_cost;
3879 if (offset_est != 0)
3884 offset_rows = (double) offset_est;
3887 if (offset_rows > *rows)
3888 offset_rows = *rows;
3891 (input_total_cost - input_startup_cost)
3892 * offset_rows / input_rows;
3893 *rows -= offset_rows;
3903 count_rows = (double) count_est;
3906 if (count_rows > *rows)
3909 *total_cost = *startup_cost +
3910 (input_total_cost - input_startup_cost)
3911 * count_rows / input_rows;
3953 case T_IndexOnlyScan:
3965 memcpy(newpath, ipath,
sizeof(
IndexPath));
3966 newpath->
path.param_info =
3969 return (
Path *) newpath;
3971 case T_BitmapHeapScan:
3981 case T_SubqueryScan:
3985 bool trivial_pathtarget;
3994 trivial_pathtarget =
4029 if (i < apath->first_partial_path)
4030 childpaths =
lappend(childpaths, spath);
4032 partialpaths =
lappend(partialpaths, spath);
4111 #define ADJUST_CHILD_ATTRS(node) \
4112 ((node) = (void *) adjust_appendrel_attrs_multilevel(root, \
4115 child_rel->top_parent))
4117 #define REPARAMETERIZE_CHILD_PATH(path) \
4119 (path) = reparameterize_path_by_child(root, (path), child_rel); \
4120 if ((path) == NULL) \
4124 #define REPARAMETERIZE_CHILD_PATH_LIST(pathlist) \
4126 if ((pathlist) != NIL) \
4128 (pathlist) = reparameterize_pathlist_by_child(root, (pathlist), \
4130 if ((pathlist) == NIL) \
4139 if (!path->param_info ||
4160 if (path->
pathtype == T_SampleScan)
4162 Index scan_relid = path->parent->relid;
4181 new_path = (
Path *) ipath;
4185 case T_BitmapHeapPath:
4191 new_path = (
Path *) bhpath;
4195 case T_BitmapAndPath:
4200 new_path = (
Path *) bapath;
4204 case T_BitmapOrPath:
4209 new_path = (
Path *) bopath;
4226 path->parent->fdwroutine->ReparameterizeForeignPathByChild;
4230 new_path = (
Path *) fpath;
4248 new_path = (
Path *) cpath;
4260 new_path = (
Path *) npath;
4273 new_path = (
Path *) mpath;
4286 new_path = (
Path *) hpath;
4295 new_path = (
Path *) apath;
4299 case T_MaterialPath:
4304 new_path = (
Path *) mpath;
4314 new_path = (
Path *) mpath;
4323 new_path = (
Path *) gpath;
4337 old_ppi = new_path->param_info;
4341 child_rel->top_parent);
4351 if (new_ppi == NULL)
4370 new_path->param_info = new_ppi;
4401 #define REJECT_IF_PATH_NOT_REPARAMETERIZABLE(path) \
4403 if (!path_is_reparameterizable_by_child(path, child_rel)) \
4407 #define REJECT_IF_PATH_LIST_NOT_REPARAMETERIZABLE(pathlist) \
4409 if (!pathlist_is_reparameterizable_by_child(pathlist, child_rel)) \
4417 if (!path->param_info ||
4431 case T_BitmapHeapPath:
4439 case T_BitmapAndPath:
4447 case T_BitmapOrPath:
4491 case T_MaterialPath:
4537 foreach(lc, pathlist)
4548 result =
lappend(result, path);
4563 foreach(lc, pathlist)
Datum sort(PG_FUNCTION_ARGS)
bool query_is_distinct_for(Query *query, List *colnos, List *opids)
bool query_supports_distinctness(Query *query)
Relids adjust_child_relids_multilevel(PlannerInfo *root, Relids relids, RelOptInfo *childrel, RelOptInfo *parentrel)
bool bms_equal(const Bitmapset *a, const Bitmapset *b)
BMS_Comparison bms_subset_compare(const Bitmapset *a, const 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_union(const Bitmapset *a, const Bitmapset *b)
Bitmapset * bms_add_members(Bitmapset *a, const Bitmapset *b)
Bitmapset * bms_del_members(Bitmapset *a, const Bitmapset *b)
bool bms_overlap(const Bitmapset *a, const Bitmapset *b)
int bms_compare(const Bitmapset *a, const Bitmapset *b)
Bitmapset * bms_copy(const Bitmapset *a)
#define PG_USED_FOR_ASSERTS_ONLY
#define Assert(condition)
bool is_parallel_safe(PlannerInfo *root, Node *node)
double expression_returns_set_rows(PlannerInfo *root, Node *clause)
void final_cost_hashjoin(PlannerInfo *root, HashPath *path, JoinCostWorkspace *workspace, JoinPathExtraData *extra)
void final_cost_mergejoin(PlannerInfo *root, MergePath *path, JoinCostWorkspace *workspace, JoinPathExtraData *extra)
void cost_functionscan(Path *path, PlannerInfo *root, RelOptInfo *baserel, ParamPathInfo *param_info)
void cost_material(Path *path, Cost input_startup_cost, Cost input_total_cost, double tuples, int width)
void cost_bitmap_heap_scan(Path *path, PlannerInfo *root, RelOptInfo *baserel, ParamPathInfo *param_info, Path *bitmapqual, double loop_count)
void cost_tidrangescan(Path *path, PlannerInfo *root, RelOptInfo *baserel, List *tidrangequals, ParamPathInfo *param_info)
void cost_merge_append(Path *path, PlannerInfo *root, List *pathkeys, int n_streams, Cost input_startup_cost, Cost input_total_cost, double tuples)
void final_cost_nestloop(PlannerInfo *root, NestPath *path, JoinCostWorkspace *workspace, JoinPathExtraData *extra)
void cost_recursive_union(Path *runion, Path *nrterm, Path *rterm)
void cost_incremental_sort(Path *path, PlannerInfo *root, List *pathkeys, int presorted_keys, Cost input_startup_cost, Cost input_total_cost, double input_tuples, int width, Cost comparison_cost, int sort_mem, double limit_tuples)
void cost_tablefuncscan(Path *path, PlannerInfo *root, RelOptInfo *baserel, ParamPathInfo *param_info)
void cost_samplescan(Path *path, PlannerInfo *root, RelOptInfo *baserel, ParamPathInfo *param_info)
void cost_gather(GatherPath *path, PlannerInfo *root, RelOptInfo *rel, ParamPathInfo *param_info, double *rows)
void cost_agg(Path *path, PlannerInfo *root, AggStrategy aggstrategy, const AggClauseCosts *aggcosts, int numGroupCols, double numGroups, List *quals, Cost input_startup_cost, Cost input_total_cost, double input_tuples, double input_width)
void cost_namedtuplestorescan(Path *path, PlannerInfo *root, RelOptInfo *baserel, ParamPathInfo *param_info)
void cost_seqscan(Path *path, PlannerInfo *root, RelOptInfo *baserel, ParamPathInfo *param_info)
void cost_valuesscan(Path *path, PlannerInfo *root, RelOptInfo *baserel, ParamPathInfo *param_info)
void cost_qual_eval(QualCost *cost, List *quals, PlannerInfo *root)
void cost_resultscan(Path *path, PlannerInfo *root, RelOptInfo *baserel, ParamPathInfo *param_info)
void cost_windowagg(Path *path, PlannerInfo *root, List *windowFuncs, WindowClause *winclause, Cost input_startup_cost, Cost input_total_cost, double input_tuples)
void cost_bitmap_and_node(BitmapAndPath *path, PlannerInfo *root)
void cost_gather_merge(GatherMergePath *path, PlannerInfo *root, RelOptInfo *rel, ParamPathInfo *param_info, Cost input_startup_cost, Cost input_total_cost, double *rows)
void cost_tidscan(Path *path, PlannerInfo *root, RelOptInfo *baserel, List *tidquals, ParamPathInfo *param_info)
double clamp_row_est(double nrows)
void cost_subqueryscan(SubqueryScanPath *path, PlannerInfo *root, RelOptInfo *baserel, ParamPathInfo *param_info, bool trivial_pathtarget)
void cost_append(AppendPath *apath)
void cost_ctescan(Path *path, PlannerInfo *root, RelOptInfo *baserel, ParamPathInfo *param_info)
void cost_bitmap_or_node(BitmapOrPath *path, PlannerInfo *root)
void cost_index(IndexPath *path, PlannerInfo *root, double loop_count, bool partial_path)
void cost_sort(Path *path, PlannerInfo *root, List *pathkeys, Cost input_cost, double tuples, int width, Cost comparison_cost, int sort_mem, double limit_tuples)
void cost_group(Path *path, PlannerInfo *root, int numGroupCols, double numGroups, List *quals, Cost input_startup_cost, Cost input_total_cost, double input_tuples)
bool is_projection_capable_path(Path *path)
bool equal(const void *a, const void *b)
List *(* ReparameterizeForeignPathByChild_function)(PlannerInfo *root, List *fdw_private, RelOptInfo *child_rel)
bool relation_has_unique_index_for(PlannerInfo *root, RelOptInfo *rel, List *restrictlist, List *exprlist, List *oprlist)
if(TABLE==NULL||TABLE_index==NULL)
void list_sort(List *list, list_sort_comparator cmp)
List * list_insert_nth(List *list, int pos, void *datum)
List * lappend(List *list, void *datum)
List * list_copy_head(const List *oldlist, int len)
List * lappend_int(List *list, int datum)
void list_free(List *list)
List * list_concat(List *list1, const List *list2)
List * lcons(void *datum, List *list)
Datum subpath(PG_FUNCTION_ARGS)
void pfree(void *pointer)
MemoryContext GetMemoryChunkContext(void *pointer)
#define CHECK_FOR_INTERRUPTS()
size_t get_hash_memory_limit(void)
#define IsA(nodeptr, _type_)
bool pathkeys_contained_in(List *keys1, List *keys2)
PathKeysComparison compare_pathkeys(List *keys1, List *keys2)
#define REPARAMETERIZE_CHILD_PATH_LIST(pathlist)
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)
static int append_startup_cost_compare(const ListCell *a, const ListCell *b)
SortPath * create_sort_path(PlannerInfo *root, RelOptInfo *rel, Path *subpath, List *pathkeys, double limit_tuples)
TidPath * create_tidscan_path(PlannerInfo *root, RelOptInfo *rel, List *tidquals, Relids required_outer)
#define REPARAMETERIZE_CHILD_PATH(path)
GroupResultPath * create_group_result_path(PlannerInfo *root, RelOptInfo *rel, PathTarget *target, List *havingqual)
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)
static PathCostComparison compare_path_costs_fuzzily(Path *path1, Path *path2, double fuzz_factor)
bool path_is_reparameterizable_by_child(Path *path, RelOptInfo *child_rel)
IndexPath * create_index_path(PlannerInfo *root, IndexOptInfo *index, List *indexclauses, List *indexorderbys, List *indexorderbycols, List *pathkeys, ScanDirection indexscandir, bool indexonly, Relids required_outer, double loop_count, bool partial_path)
LimitPath * create_limit_path(PlannerInfo *root, RelOptInfo *rel, Path *subpath, Node *limitOffset, Node *limitCount, LimitOption limitOption, int64 offset_est, int64 count_est)
ProjectionPath * create_projection_path(PlannerInfo *root, RelOptInfo *rel, Path *subpath, PathTarget *target)
GatherMergePath * create_gather_merge_path(PlannerInfo *root, RelOptInfo *rel, Path *subpath, PathTarget *target, List *pathkeys, Relids required_outer, double *rows)
UpperUniquePath * create_upper_unique_path(PlannerInfo *root, RelOptInfo *rel, Path *subpath, int numCols, double numGroups)
static bool pathlist_is_reparameterizable_by_child(List *pathlist, RelOptInfo *child_rel)
Relids calc_nestloop_required_outer(Relids outerrelids, Relids outer_paramrels, Relids innerrelids, Relids inner_paramrels)
Path * create_tablefuncscan_path(PlannerInfo *root, RelOptInfo *rel, Relids required_outer)
Path * create_namedtuplestorescan_path(PlannerInfo *root, RelOptInfo *rel, Relids required_outer)
#define REJECT_IF_PATH_LIST_NOT_REPARAMETERIZABLE(pathlist)
LockRowsPath * create_lockrows_path(PlannerInfo *root, RelOptInfo *rel, Path *subpath, List *rowMarks, int epqParam)
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)
static List * reparameterize_pathlist_by_child(PlannerInfo *root, List *pathlist, RelOptInfo *child_rel)
GatherPath * create_gather_path(PlannerInfo *root, RelOptInfo *rel, Path *subpath, PathTarget *target, Relids required_outer, double *rows)
Path * create_resultscan_path(PlannerInfo *root, RelOptInfo *rel, Relids required_outer)
Path * create_samplescan_path(PlannerInfo *root, RelOptInfo *rel, Relids required_outer)
MemoizePath * create_memoize_path(PlannerInfo *root, RelOptInfo *rel, Path *subpath, List *param_exprs, List *hash_operators, bool singlerow, bool binary_mode, double calls)
MergeAppendPath * create_merge_append_path(PlannerInfo *root, RelOptInfo *rel, List *subpaths, List *pathkeys, Relids required_outer)
void set_cheapest(RelOptInfo *parent_rel)
Path * reparameterize_path(PlannerInfo *root, Path *path, Relids required_outer, double loop_count)
ProjectSetPath * create_set_projection_path(PlannerInfo *root, RelOptInfo *rel, Path *subpath, PathTarget *target)
SubqueryScanPath * create_subqueryscan_path(PlannerInfo *root, RelOptInfo *rel, Path *subpath, bool trivial_pathtarget, List *pathkeys, Relids required_outer)
ForeignPath * create_foreignscan_path(PlannerInfo *root, RelOptInfo *rel, PathTarget *target, double rows, Cost startup_cost, Cost total_cost, List *pathkeys, Relids required_outer, Path *fdw_outerpath, List *fdw_restrictinfo, List *fdw_private)
ForeignPath * create_foreign_upper_path(PlannerInfo *root, RelOptInfo *rel, PathTarget *target, double rows, Cost startup_cost, Cost total_cost, List *pathkeys, Path *fdw_outerpath, List *fdw_restrictinfo, List *fdw_private)
void add_partial_path(RelOptInfo *parent_rel, Path *new_path)
MaterialPath * create_material_path(RelOptInfo *rel, Path *subpath)
Path * create_functionscan_path(PlannerInfo *root, RelOptInfo *rel, List *pathkeys, Relids required_outer)
#define ADJUST_CHILD_ATTRS(node)
BitmapOrPath * create_bitmap_or_path(PlannerInfo *root, RelOptInfo *rel, List *bitmapquals)
int compare_fractional_path_costs(Path *path1, Path *path2, double fraction)
GroupPath * create_group_path(PlannerInfo *root, RelOptInfo *rel, Path *subpath, List *groupClause, List *qual, double numGroups)
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)
GroupingSetsPath * create_groupingsets_path(PlannerInfo *root, RelOptInfo *rel, Path *subpath, List *having_qual, AggStrategy aggstrategy, List *rollups, const AggClauseCosts *agg_costs)
SetOpPath * create_setop_path(PlannerInfo *root, RelOptInfo *rel, Path *subpath, SetOpCmd cmd, SetOpStrategy strategy, List *distinctList, AttrNumber flagColIdx, int firstFlag, double numGroups, double outputRows)
#define REJECT_IF_PATH_NOT_REPARAMETERIZABLE(path)
RecursiveUnionPath * create_recursiveunion_path(PlannerInfo *root, RelOptInfo *rel, Path *leftpath, Path *rightpath, PathTarget *target, List *distinctList, int wtParam, double numGroups)
IncrementalSortPath * create_incremental_sort_path(PlannerInfo *root, RelOptInfo *rel, Path *subpath, List *pathkeys, int presorted_keys, double limit_tuples)
MinMaxAggPath * create_minmaxagg_path(PlannerInfo *root, RelOptInfo *rel, PathTarget *target, List *mmaggregates, List *quals)
Path * create_worktablescan_path(PlannerInfo *root, RelOptInfo *rel, Relids required_outer)
#define CONSIDER_PATH_STARTUP_COST(p)
WindowAggPath * create_windowagg_path(PlannerInfo *root, RelOptInfo *rel, Path *subpath, PathTarget *target, List *windowFuncs, List *runCondition, WindowClause *winclause, List *qual, bool topwindow)
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)
void add_path(RelOptInfo *parent_rel, Path *new_path)
ModifyTablePath * create_modifytable_path(PlannerInfo *root, RelOptInfo *rel, Path *subpath, CmdType operation, bool canSetTag, Index nominalRelation, Index rootRelation, bool partColsUpdated, List *resultRelations, List *updateColnosLists, List *withCheckOptionLists, List *returningLists, List *rowMarks, OnConflictExpr *onconflict, List *mergeActionLists, List *mergeJoinConditions, int epqParam)
Path * create_valuesscan_path(PlannerInfo *root, RelOptInfo *rel, Relids required_outer)
int compare_path_costs(Path *path1, Path *path2, CostSelector criterion)
Path * apply_projection_to_path(PlannerInfo *root, RelOptInfo *rel, Path *path, PathTarget *target)
static int append_total_cost_compare(const ListCell *a, const ListCell *b)
BitmapAndPath * create_bitmap_and_path(PlannerInfo *root, RelOptInfo *rel, List *bitmapquals)
TidRangePath * create_tidrangescan_path(PlannerInfo *root, RelOptInfo *rel, List *tidrangequals, Relids required_outer)
Path * create_seqscan_path(PlannerInfo *root, RelOptInfo *rel, Relids required_outer, int parallel_workers)
void adjust_limit_rows_costs(double *rows, Cost *startup_cost, Cost *total_cost, int64 offset_est, int64 count_est)
ForeignPath * create_foreign_join_path(PlannerInfo *root, RelOptInfo *rel, PathTarget *target, double rows, Cost startup_cost, Cost total_cost, List *pathkeys, Relids required_outer, Path *fdw_outerpath, List *fdw_restrictinfo, List *fdw_private)
static List * translate_sub_tlist(List *tlist, int relid)
Path * create_ctescan_path(PlannerInfo *root, RelOptInfo *rel, List *pathkeys, Relids required_outer)
bool add_path_precheck(RelOptInfo *parent_rel, Cost startup_cost, Cost total_cost, List *pathkeys, Relids required_outer)
BitmapHeapPath * create_bitmap_heap_path(PlannerInfo *root, RelOptInfo *rel, Path *bitmapqual, Relids required_outer, double loop_count, int parallel_degree)
#define IS_SIMPLE_REL(rel)
#define PATH_REQ_OUTER(path)
#define planner_rt_fetch(rti, root)
static int list_length(const List *l)
#define foreach_current_index(var_or_cell)
#define foreach_delete_current(lst, var_or_cell)
MemoryContextSwitchTo(old_ctx)
static int cmp(const chr *x, const chr *y, size_t len)
ParamPathInfo * get_baserel_parampathinfo(PlannerInfo *root, RelOptInfo *baserel, Relids required_outer)
ParamPathInfo * get_appendrel_parampathinfo(RelOptInfo *appendrel, Relids required_outer)
ParamPathInfo * get_joinrel_parampathinfo(PlannerInfo *root, RelOptInfo *joinrel, Path *outer_path, Path *inner_path, SpecialJoinInfo *sjinfo, Relids required_outer, List **restrict_clauses)
ParamPathInfo * find_param_path_info(RelOptInfo *rel, Relids required_outer)
Bitmapset * get_param_path_clause_serials(Path *path)
double estimate_num_groups(PlannerInfo *root, List *groupExprs, double input_rows, List **pgset, EstimationInfo *estinfo)
struct List *(* ReparameterizeCustomPathByChild)(PlannerInfo *root, List *custom_private, RelOptInfo *child_rel)
const struct CustomPathMethods * methods
List * custom_restrictinfo
ScanDirection indexscandir
List * withCheckOptionLists
List * mergeJoinConditions
OnConflictExpr * onconflict
struct TableSampleClause * tablesample
bool consider_param_startup
struct PathTarget * reltarget
List * cheapest_parameterized_paths
struct Path * cheapest_unique_path
struct Path * cheapest_startup_path
struct Path * cheapest_total_path
PathTarget * copy_pathtarget(PathTarget *src)