31 #ifdef OPTIMIZER_DEBUG
56 #define UNSAFE_HAS_VOLATILE_FUNC (1 << 0)
57 #define UNSAFE_HAS_SET_FUNC (1 << 1)
58 #define UNSAFE_NOTIN_DISTINCTON_CLAUSE (1 << 2)
59 #define UNSAFE_NOTIN_PARTITIONBY_CLAUSE (1 << 3)
60 #define UNSAFE_TYPE_MISMATCH (1 << 4)
121 List *live_childrels,
122 List *all_child_pathkeys);
128 List **special_subpaths);
205 RelOptInfo *brel = root->simple_rel_array[rti];
217 total_pages += (double) brel->
pages;
299 RelOptInfo *rel = root->simple_rel_array[rti];
312 rte = root->simple_rte_array[rti];
342 RelOptInfo *rel = root->simple_rel_array[rti];
392 if (rte->
relkind == RELKIND_FOREIGN_TABLE)
397 else if (rte->
relkind == RELKIND_PARTITIONED_TABLE)
489 if (rte->
relkind == RELKIND_FOREIGN_TABLE)
542 (*set_rel_pathlist_hook) (root, rel, rti, rte);
565 #ifdef OPTIMIZER_DEBUG
566 debug_print_rel(root, rel);
633 if (proparallel != PROPARALLEL_SAFE)
647 if (rte->
relkind == RELKIND_FOREIGN_TABLE)
650 if (!rel->fdwroutine->IsForeignScanParallelSafe)
652 if (!rel->fdwroutine->IsForeignScanParallelSafe(root, rel, rte))
799 int parallel_workers;
805 if (parallel_workers <= 0)
911 rel->fdwroutine->GetForeignRelSize(root, rel, rte->
relid);
932 rel->fdwroutine->GetForeignPaths(root, rel, rte->
relid);
950 int parentRTindex = rti;
951 bool has_live_children;
954 double *parent_attrsizes;
970 rte->
relkind == RELKIND_PARTITIONED_TABLE &&
988 has_live_children =
false;
992 parent_attrsizes = (
double *)
palloc0(nattrs *
sizeof(
double));
1010 childRTE = root->simple_rte_array[childRTindex];
1056 childrinfos =
lappend(childrinfos,
1136 has_live_children =
true;
1155 parent_rows += childrel->
rows;
1172 if (
IsA(parentvar,
Var) && parentvar->
varno == parentRTindex)
1175 int32 child_width = 0;
1177 if (
IsA(childvar,
Var) &&
1178 ((
Var *) childvar)->varno == childrel->
relid)
1180 int cndx = ((
Var *) childvar)->varattno - childrel->
min_attr;
1182 child_width = childrel->attr_widths[cndx];
1184 if (child_width <= 0)
1188 parent_attrsizes[pndx] += child_width * childrel->
rows;
1193 if (has_live_children)
1201 rel->
rows = parent_rows;
1203 for (
i = 0;
i < nattrs;
i++)
1204 rel->attr_widths[
i] = rint(parent_attrsizes[
i] / parent_rows);
1210 rel->
tuples = parent_rows;
1227 pfree(parent_attrsizes);
1238 int parentRTindex = rti;
1259 childRTE = root->simple_rte_array[childRTindex];
1260 childrel = root->simple_rel_array[childRTindex];
1285 live_childrels =
lappend(live_childrels, childrel);
1306 List *live_childrels)
1309 bool subpaths_valid =
true;
1311 List *pa_partial_subpaths =
NIL;
1312 List *pa_nonpartial_subpaths =
NIL;
1313 bool partial_subpaths_valid =
true;
1314 bool pa_subpaths_valid;
1315 List *all_child_pathkeys =
NIL;
1318 double partial_rows = -1;
1328 foreach(l, live_childrels)
1332 Path *cheapest_partial_path = NULL;
1347 subpaths_valid =
false;
1354 &partial_subpaths, NULL);
1357 partial_subpaths_valid =
false;
1363 if (pa_subpaths_valid)
1365 Path *nppath = NULL;
1370 if (cheapest_partial_path == NULL && nppath == NULL)
1373 pa_subpaths_valid =
false;
1375 else if (nppath == NULL ||
1376 (cheapest_partial_path != NULL &&
1380 Assert(cheapest_partial_path != NULL);
1382 &pa_partial_subpaths,
1383 &pa_nonpartial_subpaths);
1401 &pa_nonpartial_subpaths,
1419 if (childkeys !=
NIL)
1425 foreach(lpk, all_child_pathkeys)
1439 all_child_pathkeys =
lappend(all_child_pathkeys,
1451 foreach(lco, all_child_outers)
1455 if (
bms_equal(existing_outers, childouter))
1464 all_child_outers =
lappend(all_child_outers,
1478 NIL, NULL, 0,
false,
1485 if (partial_subpaths_valid && partial_subpaths !=
NIL)
1489 int parallel_workers = 0;
1492 foreach(lc, partial_subpaths)
1498 Assert(parallel_workers > 0);
1511 parallel_workers =
Max(parallel_workers,
1513 parallel_workers =
Min(parallel_workers,
1516 Assert(parallel_workers > 0);
1520 NIL, NULL, parallel_workers,
1528 partial_rows = appendpath->
path.
rows;
1540 if (pa_subpaths_valid && pa_nonpartial_subpaths !=
NIL)
1544 int parallel_workers = 0;
1550 foreach(lc, pa_partial_subpaths)
1562 parallel_workers =
Max(parallel_workers,
1564 parallel_workers =
Min(parallel_workers,
1566 Assert(parallel_workers > 0);
1569 pa_partial_subpaths,
1570 NIL, NULL, parallel_workers,
true,
1581 all_child_pathkeys);
1596 foreach(l, all_child_outers)
1603 subpaths_valid =
true;
1604 foreach(lcr, live_childrels)
1612 subpaths_valid =
false;
1622 subpaths_valid =
false;
1631 NIL, required_outer, 0,
false,
1694 List *live_childrels,
1695 List *all_child_pathkeys)
1698 List *partition_pathkeys =
NIL;
1699 List *partition_pathkeys_desc =
NIL;
1700 bool partition_pathkeys_partial =
true;
1701 bool partition_pathkeys_desc_partial =
true;
1716 &partition_pathkeys_partial);
1720 &partition_pathkeys_desc_partial);
1734 foreach(lcp, all_child_pathkeys)
1739 List *fractional_subpaths =
NIL;
1740 bool startup_neq_total =
false;
1741 bool match_partition_order;
1742 bool match_partition_order_desc;
1756 match_partition_order =
1758 (!partition_pathkeys_partial &&
1761 match_partition_order_desc = !match_partition_order &&
1763 (!partition_pathkeys_desc_partial &&
1773 if (match_partition_order_desc)
1784 match_partition_order =
true;
1795 for (
int i = first_index;
i != end_index;
i += direction)
1798 Path *cheapest_startup,
1800 *cheapest_fractional = NULL;
1820 if (cheapest_startup == NULL || cheapest_total == NULL)
1822 cheapest_startup = cheapest_total =
1825 Assert(cheapest_total->param_info == NULL);
1842 cheapest_fractional =
1856 if (!cheapest_fractional)
1857 cheapest_fractional = cheapest_total;
1865 if (cheapest_startup != cheapest_total)
1866 startup_neq_total =
true;
1872 if (match_partition_order)
1884 startup_subpaths =
lappend(startup_subpaths, cheapest_startup);
1885 total_subpaths =
lappend(total_subpaths, cheapest_total);
1887 if (cheapest_fractional)
1890 fractional_subpaths =
lappend(fractional_subpaths, cheapest_fractional);
1900 &startup_subpaths, NULL);
1902 &total_subpaths, NULL);
1904 if (cheapest_fractional)
1906 &fractional_subpaths, NULL);
1911 if (match_partition_order)
1923 if (startup_neq_total)
1934 if (fractional_subpaths)
1937 fractional_subpaths,
1953 if (startup_neq_total)
1960 if (fractional_subpaths)
1963 fractional_subpaths,
1994 Assert(cheapest != NULL);
2019 if (cheapest != NULL &&
2031 if (cheapest != NULL &&
2077 else if (special_subpaths != NULL)
2079 List *new_special_subpaths;
2087 *special_subpaths =
list_concat(*special_subpaths,
2088 new_special_subpaths);
2100 *subpaths =
lappend(*subpaths, path);
2173 int num_base_rels = 0;
2178 RelOptInfo *brel = root->simple_rel_array[rti];
2185 if (++num_base_rels > 1)
2217 bool wfunc_left,
bool *keep_original,
2230 *keep_original =
true;
2266 req.
type = T_SupportRequestWFuncMonotonic;
2286 foreach(lc, opinfos)
2303 *keep_original =
false;
2305 runoperator = opexpr->
opno;
2321 *keep_original =
false;
2323 runoperator = opexpr->
opno;
2340 *keep_original =
false;
2342 runoperator = opexpr->
opno;
2359 *keep_original =
true;
2371 if (runopexpr != NULL)
2381 runopexpr->opresulttype,
2382 runopexpr->opretset, (
Expr *) wfunc,
2383 otherexpr, runopexpr->opcollid,
2384 runopexpr->inputcollid);
2387 runopexpr->opresulttype,
2388 runopexpr->opretset,
2389 otherexpr, (
Expr *) wfunc,
2390 runopexpr->opcollid,
2391 runopexpr->inputcollid);
2393 wclause->runCondition =
lappend(wclause->runCondition, newexpr);
2424 bool keep_original =
true;
2461 opexpr,
true, &keep_original,
2463 return keep_original;
2474 opexpr,
false, &keep_original,
2476 return keep_original;
2500 bool trivial_pathtarget;
2503 double tuple_fraction;
2530 memset(&safetyInfo, 0,
sizeof(safetyInfo));
2567 List *upperrestrictlist =
NIL;
2575 if (rinfo->pseudoconstant)
2577 upperrestrictlist =
lappend(upperrestrictlist, rinfo);
2596 if (!subquery->hasWindowFuncs ||
2605 upperrestrictlist =
lappend(upperrestrictlist, rinfo);
2610 upperrestrictlist =
lappend(upperrestrictlist, rinfo);
2634 if (
parse->hasAggs ||
2635 parse->groupClause ||
2636 parse->groupingSets ||
2638 parse->distinctClause ||
2639 parse->sortClause ||
2641 tuple_fraction = 0.0;
2651 false, tuple_fraction);
2683 trivial_pathtarget =
false;
2686 trivial_pathtarget =
true;
2694 trivial_pathtarget =
false;
2698 if (var->
varno != rti ||
2701 trivial_pathtarget =
false;
2711 foreach(lc, sub_final_rel->
pathlist)
2726 pathkeys, required_outer));
2822 pathkeys, required_outer));
2889 while (levelsup-- > 0)
2891 cteroot = cteroot->parent_root;
3018 while (levelsup-- > 0)
3020 cteroot = cteroot->parent_root;
3062 Path *cheapest_partial_path;
3063 Path *simple_gather_path;
3066 double *rowsp = NULL;
3084 simple_gather_path = (
Path *)
3103 subpath->pathkeys, NULL, rowsp);
3131 bool require_parallel_safe)
3133 List *useful_pathkeys_list =
NIL;
3164 require_parallel_safe))
3176 useful_pathkeys_list =
lappend(useful_pathkeys_list,
3178 else if (npathkeys > 0)
3179 useful_pathkeys_list =
lappend(useful_pathkeys_list,
3184 return useful_pathkeys_list;
3202 double *rowsp = NULL;
3203 List *useful_pathkeys_list =
NIL;
3204 Path *cheapest_partial_path = NULL;
3227 foreach(lc, useful_pathkeys_list)
3262 if (
subpath != cheapest_partial_path &&
3327 if (levels_needed <= 0)
3336 foreach(jl, joinlist)
3354 elog(
ERROR,
"unrecognized joinlist node type: %d",
3359 initial_rels =
lappend(initial_rels, thisrel);
3362 if (levels_needed == 1)
3378 root->initial_rels = initial_rels;
3383 return geqo(root, levels_needed, initial_rels);
3428 Assert(root->join_rel_level == NULL);
3441 root->join_rel_level = (
List **)
palloc0((levels_needed + 1) *
sizeof(
List *));
3443 root->join_rel_level[1] = initial_rels;
3445 for (lev = 2; lev <= levels_needed; lev++)
3466 foreach(lc, root->join_rel_level[lev])
3484 #ifdef OPTIMIZER_DEBUG
3485 debug_print_rel(root, rel);
3493 if (root->join_rel_level[levels_needed] ==
NIL)
3494 elog(
ERROR,
"failed to build any %d-way joins", levels_needed);
3499 root->join_rel_level = NULL;
3604 subquery->hasWindowFuncs ||
3605 subquery->hasTargetSRFs)
3618 if (subquery == topquery)
3654 Assert(subquery != NULL);
3672 elog(
ERROR,
"unrecognized node type: %d",
3726 if (subquery->hasTargetSRFs &&
3745 if (subquery->hasDistinctOn &&
3756 if (subquery->hasWindowFuncs &&
3798 if (colType == NULL)
3799 elog(
ERROR,
"wrong number of tlist entries");
3802 colType =
lnext(colTypes, colType);
3804 if (colType != NULL)
3805 elog(
ERROR,
"wrong number of tlist entries");
3919 if (var->
varno != rti)
3985 &subquery->hasSubLinks);
4019 Assert(subquery != NULL);
4031 elog(
ERROR,
"unrecognized node type: %d",
4072 attrs_used = extra_used_attrs;
4147 if (subquery->hasTargetSRFs &&
4177 int parallel_workers;
4178 double pages_fetched;
4187 if (parallel_workers <= 0)
4213 int parallel_workers = 0;
4236 if (heap_pages >= 0)
4238 int heap_parallel_threshold;
4239 int heap_parallel_workers = 1;
4249 while (heap_pages >= (
BlockNumber) (heap_parallel_threshold * 3))
4251 heap_parallel_workers++;
4252 heap_parallel_threshold *= 3;
4253 if (heap_parallel_threshold > INT_MAX / 3)
4257 parallel_workers = heap_parallel_workers;
4260 if (index_pages >= 0)
4262 int index_parallel_workers = 1;
4263 int index_parallel_threshold;
4267 while (index_pages >= (
BlockNumber) (index_parallel_threshold * 3))
4269 index_parallel_workers++;
4270 index_parallel_threshold *= 3;
4271 if (index_parallel_threshold > INT_MAX / 3)
4275 if (parallel_workers > 0)
4276 parallel_workers =
Min(parallel_workers, index_parallel_workers);
4278 parallel_workers = index_parallel_workers;
4283 parallel_workers =
Min(parallel_workers, max_workers);
4285 return parallel_workers;
4320 part_rels = rel->part_rels;
4323 for (cnt_parts = 0; cnt_parts < num_parts; cnt_parts++)
4325 RelOptInfo *child_rel = part_rels[cnt_parts];
4328 if (child_rel == NULL)
4352 #ifdef OPTIMIZER_DEBUG
4353 debug_print_rel(root, child_rel);
4356 live_children =
lappend(live_children, child_rel);
4376 #ifdef OPTIMIZER_DEBUG
4389 if (x < root->simple_rel_array_size &&
4390 root->simple_rte_array[
x])
4391 printf(
"%s", root->simple_rte_array[
x]->eref->aliasname);
4408 if (
lnext(clauses, l))
4430 ptype =
"SampleScan";
4432 case T_FunctionScan:
4433 ptype =
"FunctionScan";
4435 case T_TableFuncScan:
4436 ptype =
"TableFuncScan";
4439 ptype =
"ValuesScan";
4444 case T_NamedTuplestoreScan:
4445 ptype =
"NamedTuplestoreScan";
4450 case T_WorkTableScan:
4451 ptype =
"WorkTableScan";
4461 case T_BitmapHeapPath:
4462 ptype =
"BitmapHeapScan";
4464 case T_BitmapAndPath:
4465 ptype =
"BitmapAndPath";
4467 case T_BitmapOrPath:
4468 ptype =
"BitmapOrPath";
4473 case T_SubqueryScanPath:
4474 ptype =
"SubqueryScan";
4477 ptype =
"ForeignScan";
4480 ptype =
"CustomScan";
4487 ptype =
"MergeJoin";
4497 case T_MergeAppendPath:
4498 ptype =
"MergeAppend";
4500 case T_GroupResultPath:
4501 ptype =
"GroupResult";
4503 case T_MaterialPath:
4519 case T_GatherMergePath:
4520 ptype =
"GatherMerge";
4523 case T_ProjectionPath:
4524 ptype =
"Projection";
4527 case T_ProjectSetPath:
4528 ptype =
"ProjectSet";
4535 case T_IncrementalSortPath:
4536 ptype =
"IncrementalSort";
4543 case T_UpperUniquePath:
4544 ptype =
"UpperUnique";
4551 case T_GroupingSetsPath:
4552 ptype =
"GroupingSets";
4555 case T_MinMaxAggPath:
4556 ptype =
"MinMaxAgg";
4558 case T_WindowAggPath:
4559 ptype =
"WindowAgg";
4566 case T_RecursiveUnionPath:
4567 ptype =
"RecursiveUnion";
4569 case T_LockRowsPath:
4573 case T_ModifyTablePath:
4574 ptype =
"ModifyTable";
4585 for (
i = 0;
i < indent;
i++)
4592 print_relids(root, path->parent->relids);
4595 if (path->param_info)
4597 printf(
" required_outer (");
4598 print_relids(root, path->param_info->ppi_req_outer);
4601 printf(
" rows=%.0f cost=%.2f..%.2f\n",
4606 for (
i = 0;
i < indent;
i++)
4616 for (
i = 0;
i < indent;
i++)
4626 for (
i = 0;
i < indent;
i++)
4628 printf(
" sortouter=%d sortinner=%d materializeinner=%d\n",
4639 print_path(root,
subpath, indent + 1);
4648 print_relids(root, rel->
relids);
4653 printf(
"\tbaserestrictinfo: ");
4661 print_restrictclauses(root, rel->
joininfo);
4665 printf(
"\tpath list:\n");
4667 print_path(root,
lfirst(l), 1);
4670 printf(
"\n\tcheapest parameterized paths:\n");
4672 print_path(root,
lfirst(l), 1);
4676 printf(
"\n\tcheapest startup path:\n");
4681 printf(
"\n\tcheapest total path:\n");
static void set_base_rel_sizes(PlannerInfo *root)
static void set_subquery_pathlist(PlannerInfo *root, RelOptInfo *rel, Index rti, RangeTblEntry *rte)
static bool find_window_run_conditions(Query *subquery, RangeTblEntry *rte, Index rti, AttrNumber attno, WindowFunc *wfunc, OpExpr *opexpr, bool wfunc_left, bool *keep_original, Bitmapset **run_cond_attrs)
#define UNSAFE_TYPE_MISMATCH
static Path * get_cheapest_parameterized_child_path(PlannerInfo *root, RelOptInfo *rel, Relids required_outer)
static void set_namedtuplestore_pathlist(PlannerInfo *root, RelOptInfo *rel, RangeTblEntry *rte)
static void subquery_push_qual(Query *subquery, RangeTblEntry *rte, Index rti, Node *qual)
void generate_partitionwise_join_paths(PlannerInfo *root, RelOptInfo *rel)
RelOptInfo * standard_join_search(PlannerInfo *root, int levels_needed, List *initial_rels)
static void set_base_rel_consider_startup(PlannerInfo *root)
#define UNSAFE_HAS_VOLATILE_FUNC
#define UNSAFE_NOTIN_DISTINCTON_CLAUSE
static void set_rel_pathlist(PlannerInfo *root, RelOptInfo *rel, Index rti, RangeTblEntry *rte)
static Path * get_singleton_append_subpath(Path *path)
static void set_tablesample_rel_size(PlannerInfo *root, RelOptInfo *rel, RangeTblEntry *rte)
static void set_tablesample_rel_pathlist(PlannerInfo *root, RelOptInfo *rel, RangeTblEntry *rte)
static void set_foreign_pathlist(PlannerInfo *root, RelOptInfo *rel, RangeTblEntry *rte)
static void set_base_rel_pathlists(PlannerInfo *root)
static void set_append_rel_pathlist(PlannerInfo *root, RelOptInfo *rel, Index rti, RangeTblEntry *rte)
static pushdown_safe_type qual_is_pushdown_safe(Query *subquery, Index rti, RestrictInfo *rinfo, pushdown_safety_info *safetyInfo)
static void set_result_pathlist(PlannerInfo *root, RelOptInfo *rel, RangeTblEntry *rte)
int compute_parallel_worker(RelOptInfo *rel, double heap_pages, double index_pages, int max_workers)
void generate_gather_paths(PlannerInfo *root, RelOptInfo *rel, bool override_rows)
static void set_dummy_rel_pathlist(RelOptInfo *rel)
static void compare_tlist_datatypes(List *tlist, List *colTypes, pushdown_safety_info *safetyInfo)
static void set_worktable_pathlist(PlannerInfo *root, RelOptInfo *rel, RangeTblEntry *rte)
static bool targetIsInAllPartitionLists(TargetEntry *tle, Query *query)
static void create_plain_partial_paths(PlannerInfo *root, RelOptInfo *rel)
static bool subquery_is_pushdown_safe(Query *subquery, Query *topquery, pushdown_safety_info *safetyInfo)
join_search_hook_type join_search_hook
static bool check_and_push_window_quals(Query *subquery, RangeTblEntry *rte, Index rti, Node *clause, Bitmapset **run_cond_attrs)
void generate_useful_gather_paths(PlannerInfo *root, RelOptInfo *rel, bool override_rows)
static RelOptInfo * make_rel_from_joinlist(PlannerInfo *root, List *joinlist)
static void set_function_pathlist(PlannerInfo *root, RelOptInfo *rel, RangeTblEntry *rte)
static void recurse_push_qual(Node *setOp, Query *topquery, RangeTblEntry *rte, Index rti, Node *qual)
static void set_plain_rel_pathlist(PlannerInfo *root, RelOptInfo *rel, RangeTblEntry *rte)
static List * get_useful_pathkeys_for_relation(PlannerInfo *root, RelOptInfo *rel, bool require_parallel_safe)
static void remove_unused_subquery_outputs(Query *subquery, RelOptInfo *rel, Bitmapset *extra_used_attrs)
static void check_output_expressions(Query *subquery, pushdown_safety_info *safetyInfo)
static void set_tablefunc_pathlist(PlannerInfo *root, RelOptInfo *rel, RangeTblEntry *rte)
static void set_foreign_size(PlannerInfo *root, RelOptInfo *rel, RangeTblEntry *rte)
set_rel_pathlist_hook_type set_rel_pathlist_hook
static void set_values_pathlist(PlannerInfo *root, RelOptInfo *rel, RangeTblEntry *rte)
struct pushdown_safety_info pushdown_safety_info
#define UNSAFE_HAS_SET_FUNC
static void set_cte_pathlist(PlannerInfo *root, RelOptInfo *rel, RangeTblEntry *rte)
static void set_rel_consider_parallel(PlannerInfo *root, RelOptInfo *rel, RangeTblEntry *rte)
static void set_append_rel_size(PlannerInfo *root, RelOptInfo *rel, Index rti, RangeTblEntry *rte)
void create_partial_bitmap_paths(PlannerInfo *root, RelOptInfo *rel, Path *bitmapqual)
static void set_plain_rel_size(PlannerInfo *root, RelOptInfo *rel, RangeTblEntry *rte)
void add_paths_to_append_rel(PlannerInfo *root, RelOptInfo *rel, List *live_childrels)
static void set_rel_size(PlannerInfo *root, RelOptInfo *rel, Index rti, RangeTblEntry *rte)
static void generate_orderedappend_paths(PlannerInfo *root, RelOptInfo *rel, List *live_childrels, List *all_child_pathkeys)
#define UNSAFE_NOTIN_PARTITIONBY_CLAUSE
RelOptInfo * make_one_rel(PlannerInfo *root, List *joinlist)
static bool recurse_pushdown_safe(Node *setOp, Query *topquery, pushdown_safety_info *safetyInfo)
static bool has_multiple_baserels(PlannerInfo *root)
@ PUSHDOWN_WINDOWCLAUSE_RUNCOND
static void accumulate_append_subpath(Path *path, List **subpaths, List **special_subpaths)
int min_parallel_index_scan_size
int min_parallel_table_scan_size
Node * adjust_appendrel_attrs(PlannerInfo *root, Node *node, int nappinfos, AppendRelInfo **appinfos)
#define InvalidAttrNumber
void print_pathkeys(const List *pathkeys, const List *rtable)
void print_expr(const Node *expr, const List *rtable)
bool bms_equal(const Bitmapset *a, const Bitmapset *b)
int bms_next_member(const Bitmapset *a, int prevbit)
bool bms_is_subset(const Bitmapset *a, const Bitmapset *b)
bool bms_is_member(int x, const Bitmapset *a)
Bitmapset * bms_add_member(Bitmapset *a, int x)
BMS_Membership bms_membership(const Bitmapset *a)
bool bms_overlap(const Bitmapset *a, const Bitmapset *b)
bool bms_get_singleton_member(const Bitmapset *a, int *member)
#define OidIsValid(objectId)
bool is_pseudo_constant_clause(Node *clause)
bool contain_leaked_vars(Node *clause)
bool is_parallel_safe(PlannerInfo *root, Node *node)
bool contain_subplans(Node *clause)
bool contain_volatile_functions(Node *clause)
void set_namedtuplestore_size_estimates(PlannerInfo *root, RelOptInfo *rel)
int max_parallel_workers_per_gather
void set_baserel_size_estimates(PlannerInfo *root, RelOptInfo *rel)
void set_function_size_estimates(PlannerInfo *root, RelOptInfo *rel)
double compute_bitmap_pages(PlannerInfo *root, RelOptInfo *baserel, Path *bitmapqual, int loop_count, Cost *cost, double *tuple)
void set_cte_size_estimates(PlannerInfo *root, RelOptInfo *rel, double cte_rows)
void set_result_size_estimates(PlannerInfo *root, RelOptInfo *rel)
bool enable_partitionwise_join
void set_subquery_size_estimates(PlannerInfo *root, RelOptInfo *rel)
bool enable_parallel_append
void set_foreign_size_estimates(PlannerInfo *root, RelOptInfo *rel)
double clamp_row_est(double nrows)
void set_tablefunc_size_estimates(PlannerInfo *root, RelOptInfo *rel)
void set_values_size_estimates(PlannerInfo *root, RelOptInfo *rel)
bool enable_incremental_sort
static void PGresult * res
elog(ERROR, "%s: %s", p2, msg)
void add_child_rel_equivalences(PlannerInfo *root, AppendRelInfo *appinfo, RelOptInfo *parent_rel, RelOptInfo *child_rel)
bool relation_can_be_sorted_early(PlannerInfo *root, RelOptInfo *rel, EquivalenceClass *ec, bool require_parallel_safe)
#define OidFunctionCall1(functionId, arg1)
RelOptInfo * geqo(PlannerInfo *root, int number_of_rels, List *initial_rels)
void check_index_predicates(PlannerInfo *root, RelOptInfo *rel)
void create_index_paths(PlannerInfo *root, RelOptInfo *rel)
if(TABLE==NULL||TABLE_index==NULL)
void join_search_one_level(PlannerInfo *root, int level)
void mark_dummy_rel(RelOptInfo *rel)
static void const char fflush(stdout)
Assert(fmt[strlen(fmt) - 1] !='\n')
List * lappend(List *list, void *datum)
List * list_copy_head(const List *oldlist, int len)
void list_free(List *list)
List * list_copy_tail(const List *oldlist, int nskip)
List * list_concat(List *list1, const List *list2)
char get_rel_persistence(Oid relid)
char func_parallel(Oid funcid)
RegProcedure get_func_support(Oid funcid)
Oid get_opfamily_member(Oid opfamily, Oid lefttype, Oid righttype, int16 strategy)
bool func_strict(Oid funcid)
List * get_op_btree_interpretation(Oid opno)
int32 get_typavgwidth(Oid typid, int32 typmod)
Datum subpath(PG_FUNCTION_ARGS)
Expr * make_opclause(Oid opno, Oid opresulttype, bool opretset, Expr *leftop, Expr *rightop, Oid opcollid, Oid inputcollid)
Const * makeNullConst(Oid consttype, int32 consttypmod, Oid constcollid)
Node * make_and_qual(Node *qual1, Node *qual2)
void pfree(void *pointer)
void * palloc0(Size size)
Oid exprType(const Node *expr)
int32 exprTypmod(const Node *expr)
Oid exprCollation(const Node *expr)
bool expression_returns_set(Node *clause)
void set_opfuncid(OpExpr *opexpr)
#define IsA(nodeptr, _type_)
#define castNode(_type_, nodeptr)
#define PVC_INCLUDE_PLACEHOLDERS
bool targetIsInSortList(TargetEntry *tle, Oid sortop, List *sortList)
#define rt_fetch(rangetable_index, rangetable)
bool partitions_are_ordered(PartitionBoundInfo boundinfo, Bitmapset *live_parts)
List * build_expression_pathkey(PlannerInfo *root, Expr *expr, Oid opno, Relids rel, bool create_it)
Path * get_cheapest_path_for_pathkeys(List *paths, List *pathkeys, Relids required_outer, CostSelector cost_criterion, bool require_parallel_safe)
bool pathkeys_count_contained_in(List *keys1, List *keys2, int *n_common)
bool has_useful_pathkeys(PlannerInfo *root, RelOptInfo *rel)
Path * get_cheapest_parallel_safe_total_inner(List *paths)
List * convert_subquery_pathkeys(PlannerInfo *root, RelOptInfo *rel, List *subquery_pathkeys, List *subquery_tlist)
Path * get_cheapest_fractional_path_for_pathkeys(List *paths, List *pathkeys, Relids required_outer, double fraction)
bool pathkeys_contained_in(List *keys1, List *keys2)
PathKeysComparison compare_pathkeys(List *keys1, List *keys2)
List * build_partition_pathkeys(PlannerInfo *root, RelOptInfo *partrel, ScanDirection scandir, bool *partialkeys)
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)
SortPath * create_sort_path(PlannerInfo *root, RelOptInfo *rel, Path *subpath, List *pathkeys, double limit_tuples)
GatherMergePath * create_gather_merge_path(PlannerInfo *root, RelOptInfo *rel, Path *subpath, PathTarget *target, List *pathkeys, Relids required_outer, double *rows)
Path * create_tablefuncscan_path(PlannerInfo *root, RelOptInfo *rel, Relids required_outer)
Path * create_namedtuplestorescan_path(PlannerInfo *root, RelOptInfo *rel, Relids required_outer)
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)
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)
SubqueryScanPath * create_subqueryscan_path(PlannerInfo *root, RelOptInfo *rel, Path *subpath, bool trivial_pathtarget, List *pathkeys, Relids required_outer)
Path * create_ctescan_path(PlannerInfo *root, RelOptInfo *rel, Relids required_outer)
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)
IncrementalSortPath * create_incremental_sort_path(PlannerInfo *root, RelOptInfo *rel, Path *subpath, List *pathkeys, int presorted_keys, double limit_tuples)
Path * create_worktablescan_path(PlannerInfo *root, RelOptInfo *rel, Relids required_outer)
void add_path(RelOptInfo *parent_rel, Path *new_path)
Path * create_valuesscan_path(PlannerInfo *root, RelOptInfo *rel, Relids required_outer)
int compare_path_costs(Path *path1, Path *path2, CostSelector criterion)
Path * create_seqscan_path(PlannerInfo *root, RelOptInfo *rel, Relids required_outer, int parallel_workers)
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 IS_PARTITIONED_REL(rel)
#define PATH_REQ_OUTER(path)
@ RELOPT_OTHER_MEMBER_REL
RelOptInfo *(* join_search_hook_type)(PlannerInfo *root, int levels_needed, List *initial_rels)
void(* set_rel_pathlist_hook_type)(PlannerInfo *root, RelOptInfo *rel, Index rti, RangeTblEntry *rte)
static int pg_leftmost_one_pos32(uint32 word)
static int list_length(const List *l)
#define forboth(cell1, list1, cell2, list2)
static ListCell * list_head(const List *l)
#define for_each_from(cell, lst, N)
static void * list_nth(const List *list, int n)
#define list_nth_node(type, list, n)
static ListCell * lnext(const List *l, const ListCell *c)
static int list_nth_int(const List *list, int n)
#define foreach_current_index(cell)
bool relation_excluded_by_constraints(PlannerInfo *root, RelOptInfo *rel, RangeTblEntry *rte)
PlannerInfo * subquery_planner(PlannerGlobal *glob, Query *parse, PlannerInfo *parent_root, bool hasRecursion, double tuple_fraction)
bool limit_needed(Query *parse)
@ MONOTONICFUNC_DECREASING
@ MONOTONICFUNC_INCREASING
void check_stack_depth(void)
static Datum PointerGetDatum(const void *X)
static Pointer DatumGetPointer(Datum X)
static struct subre * parse(struct vars *v, int stopper, int type, struct state *init, struct state *final)
RelOptInfo * find_base_rel(PlannerInfo *root, int relid)
RelOptInfo * fetch_upper_rel(PlannerInfo *root, UpperRelationKind kind, Relids relids)
Node * ReplaceVarsFromTargetList(Node *node, int target_varno, int sublevels_up, RangeTblEntry *target_rte, List *targetlist, ReplaceVarsNoMatchOption nomatch_option, int nomatch_varno, bool *outer_hasSubLinks)
@ REPLACEVARS_REPORT_ERROR
#define BTGreaterStrategyNumber
#define BTLessStrategyNumber
#define BTEqualStrategyNumber
#define BTLessEqualStrategyNumber
#define BTGreaterEqualStrategyNumber
int simple_rel_array_size
struct Path * non_recursive_path
Cardinality total_table_pages
Selectivity tuple_fraction
struct TableSampleClause * tablesample
bool consider_param_startup
struct PathTarget * reltarget
List * cheapest_parameterized_paths
struct Path * cheapest_startup_path
struct Path * cheapest_total_path
bool consider_partitionwise_join
struct WindowClause * window_clause
bool repeatable_across_scans
SampleScanGetSampleSize_function SampleScanGetSampleSize
unsigned char * unsafeFlags
#define FirstLowInvalidHeapAttributeNumber
TsmRoutine * GetTsmRoutine(Oid tsmhandler)
void create_tidscan_paths(PlannerInfo *root, RelOptInfo *rel)
List * make_tlist_from_pathtarget(PathTarget *target)
List * pull_var_clause(Node *node, int flags)
void pull_varattnos(Node *node, Index varno, Bitmapset **varattnos)