79#define EXPRKIND_QUAL 0
80#define EXPRKIND_TARGET 1
81#define EXPRKIND_RTFUNC 2
82#define EXPRKIND_RTFUNC_LATERAL 3
83#define EXPRKIND_VALUES 4
84#define EXPRKIND_VALUES_LATERAL 5
85#define EXPRKIND_LIMIT 6
86#define EXPRKIND_APPINFO 7
88#define EXPRKIND_TABLESAMPLE 9
89#define EXPRKIND_ARBITER_ELEM 10
90#define EXPRKIND_TABLEFUNC 11
91#define EXPRKIND_TABLEFUNC_LATERAL 12
92#define EXPRKIND_GROUPEXPR 13
136 int *tleref_to_colnum_map);
139 double tuple_fraction,
152 bool target_parallel_safe,
159 PathTarget *target,
bool target_parallel_safe,
180 bool output_target_parallel_safe,
182 List *activeWindows);
189 List *activeWindows);
201 List *needed_pathkeys,
202 List *path_pathkeys);
206 bool target_parallel_safe,
207 double limit_tuples);
219 List *activeWindows);
224 bool *have_postponed_srfs);
226 List *targets,
List *targets_contain_srfs);
239 bool force_rel_creation);
245 double limit_tuples);
250 List *scanjoin_targets,
251 List *scanjoin_targets_contain_srfs,
252 bool scanjoin_target_parallel_safe,
290 result = (*planner_hook) (
parse, query_string, cursorOptions, boundParams);
302 double tuple_fraction;
318 glob->boundParams = boundParams;
321 glob->subroots =
NIL;
361 !
parse->hasModifyingCTE &&
413 if (tuple_fraction >= 1.0)
414 tuple_fraction = 0.0;
415 else if (tuple_fraction <= 0.0)
416 tuple_fraction = 1
e-10;
421 tuple_fraction = 0.0;
462 bool unsafe_initplans;
500 &initplan_cost, &unsafe_initplans);
505 root->glob->parallelModeNeeded =
true;
507 top_plan = &gather->
plan;
598 if (glob->partition_directory != NULL)
639 bool hasRecursion,
double tuple_fraction,
643 List *newWithCheckOptions;
655 root->parent_root = parent_root;
657 root->outer_params = NULL;
664 root->ec_merging_done =
false;
665 root->last_rinfo_serial = 0;
666 root->all_result_relids =
668 root->leaf_result_relids = NULL;
672 memset(
root->upper_rels, 0,
sizeof(
root->upper_rels));
673 memset(
root->upper_targets, 0,
sizeof(
root->upper_targets));
674 root->processed_groupClause =
NIL;
675 root->processed_distinctClause =
NIL;
678 root->grouping_map = NULL;
680 root->qual_security_level = 0;
681 root->hasPseudoConstantQuals =
false;
682 root->hasAlternativeSubPlans =
false;
683 root->placeholdersFrozen =
false;
684 root->hasRecursion = hasRecursion;
688 root->wt_param_id = -1;
689 root->non_recursive_path = NULL;
690 root->partColsUpdated =
false;
723 if (
parse->hasSubLinks)
746 if (
parse->setOperations)
759 root->hasJoinRTEs =
false;
760 root->hasLateralRTEs =
false;
761 root->group_rtindex = 0;
762 hasOuterJoins =
false;
763 hasResultRTEs =
false;
764 foreach(l,
parse->rtable)
788 root->hasJoinRTEs =
true;
790 hasOuterJoins =
true;
793 hasResultRTEs =
true;
805 root->hasLateralRTEs =
true;
813 if (rte->securityQuals)
814 root->qual_security_level =
Max(
root->qual_security_level,
822 if (
parse->resultRelation)
827 root->leaf_result_relids =
842 root->hasHavingQual = (
parse->havingQual != NULL);
854 newWithCheckOptions =
NIL;
855 foreach(l,
parse->withCheckOptions)
861 if (wco->
qual != NULL)
862 newWithCheckOptions =
lappend(newWithCheckOptions, wco);
864 parse->withCheckOptions = newWithCheckOptions;
875 foreach(l,
parse->windowClause)
891 if (
parse->onConflict)
893 parse->onConflict->arbiterElems = (
List *)
895 (
Node *)
parse->onConflict->arbiterElems,
897 parse->onConflict->arbiterWhere =
899 parse->onConflict->arbiterWhere,
901 parse->onConflict->onConflictSet = (
List *)
903 (
Node *)
parse->onConflict->onConflictSet,
905 parse->onConflict->onConflictWhere =
907 parse->onConflict->onConflictWhere,
912 foreach(l,
parse->mergeActionList)
926 parse->mergeJoinCondition =
934 foreach(l,
parse->rtable)
957 if (rte->lateral &&
root->hasJoinRTEs)
986 rte->groupexprs = (
List *)
997 foreach(lcsq, rte->securityQuals)
1016 if (
root->hasJoinRTEs)
1018 foreach(l,
parse->rtable)
1022 rte->joinaliasvars =
NIL;
1035 if (
parse->hasGroupRTE)
1044 if (
parse->hasTargetSRFs)
1096 (
parse->groupClause &&
parse->groupingSets &&
1100 newHaving =
lappend(newHaving, havingclause);
1102 else if (
parse->groupClause)
1112 (
List *) whereclause);
1124 (
List *) whereclause);
1126 newHaving =
lappend(newHaving, havingclause);
1145 if (hasResultRTEs || hasOuterJoins)
1204 if (
root->hasJoinRTEs &&
1240#ifdef OPTIMIZER_DEBUG
1241 printf(
"After canonicalize_qual()\n");
1257 if (
root->parse->hasSubLinks)
1266 if (
root->query_level > 1)
1315 elog(
ERROR,
"unrecognized node type: %d",
1368 int64 offset_est = 0;
1369 int64 count_est = 0;
1370 double limit_tuples = -1.0;
1371 bool have_postponed_srfs =
false;
1373 List *final_targets;
1374 List *final_targets_contain_srfs;
1375 bool final_target_parallel_safe;
1385 &offset_est, &count_est);
1391 if (count_est > 0 && offset_est >= 0)
1392 limit_tuples = (double) count_est + (
double) offset_est;
1396 root->tuple_fraction = tuple_fraction;
1398 if (
parse->setOperations)
1418 root->processed_tlist =
1426 final_target_parallel_safe =
1431 final_targets = final_targets_contain_srfs =
NIL;
1437 if (
parse->rowMarks)
1439 (
errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
1442 errmsg(
"%s is not allowed with UNION/INTERSECT/EXCEPT",
1444 parse->rowMarks)->strength))));
1452 root->processed_tlist);
1458 List *sort_input_targets;
1459 List *sort_input_targets_contain_srfs;
1460 bool sort_input_target_parallel_safe;
1462 List *grouping_targets;
1463 List *grouping_targets_contain_srfs;
1464 bool grouping_target_parallel_safe;
1466 List *scanjoin_targets;
1467 List *scanjoin_targets_contain_srfs;
1468 bool scanjoin_target_parallel_safe;
1469 bool scanjoin_target_same_exprs;
1480 if (
parse->groupingSets)
1484 else if (
parse->groupClause)
1518 if (
parse->hasWindowFuncs)
1534 parse->hasWindowFuncs =
false;
1552 if (
parse->groupClause ||
1553 parse->groupingSets ||
1554 parse->distinctClause ||
1556 parse->hasWindowFuncs ||
1557 parse->hasTargetSRFs ||
1558 root->hasHavingQual)
1559 root->limit_tuples = -1.0;
1561 root->limit_tuples = limit_tuples;
1571 qp_extra.
setop = setops;
1592 final_target_parallel_safe =
1600 if (
parse->sortClause)
1604 &have_postponed_srfs);
1605 sort_input_target_parallel_safe =
1610 sort_input_target = final_target;
1611 sort_input_target_parallel_safe = final_target_parallel_safe;
1624 grouping_target_parallel_safe =
1629 grouping_target = sort_input_target;
1630 grouping_target_parallel_safe = sort_input_target_parallel_safe;
1638 have_grouping = (
parse->groupClause ||
parse->groupingSets ||
1643 scanjoin_target_parallel_safe =
1648 scanjoin_target = grouping_target;
1649 scanjoin_target_parallel_safe = grouping_target_parallel_safe;
1658 if (
parse->hasTargetSRFs)
1663 &final_targets_contain_srfs);
1668 &sort_input_targets,
1669 &sort_input_targets_contain_srfs);
1675 &grouping_targets_contain_srfs);
1681 &scanjoin_targets_contain_srfs);
1688 final_targets = final_targets_contain_srfs =
NIL;
1689 sort_input_targets = sort_input_targets_contain_srfs =
NIL;
1690 grouping_targets = grouping_targets_contain_srfs =
NIL;
1691 scanjoin_targets =
list_make1(scanjoin_target);
1692 scanjoin_targets_contain_srfs =
NIL;
1696 scanjoin_target_same_exprs =
list_length(scanjoin_targets) == 1
1699 scanjoin_targets_contain_srfs,
1700 scanjoin_target_parallel_safe,
1701 scanjoin_target_same_exprs);
1727 grouping_target_parallel_safe,
1730 if (
parse->hasTargetSRFs)
1733 grouping_targets_contain_srfs);
1746 sort_input_target_parallel_safe,
1750 if (
parse->hasTargetSRFs)
1753 sort_input_targets_contain_srfs);
1760 if (
parse->distinctClause)
1775 if (
parse->sortClause)
1780 final_target_parallel_safe,
1781 have_postponed_srfs ? -1.0 :
1784 if (
parse->hasTargetSRFs)
1787 final_targets_contain_srfs);
1813 final_rel->fdwroutine = current_rel->fdwroutine;
1830 if (
parse->rowMarks)
1846 offset_est, count_est);
1856 List *updateColnosLists =
NIL;
1857 List *withCheckOptionLists =
NIL;
1860 List *mergeJoinConditions =
NIL;
1867 parse->resultRelation);
1868 int resultRelation = -1;
1871 rootRelation =
parse->resultRelation;
1875 resultRelation)) >= 0)
1893 List *update_colnos =
root->update_colnos;
1895 if (this_result_rel != top_result_rel)
1899 this_result_rel->
relid,
1900 top_result_rel->
relid);
1901 updateColnosLists =
lappend(updateColnosLists,
1904 if (
parse->withCheckOptions)
1906 List *withCheckOptions =
parse->withCheckOptions;
1908 if (this_result_rel != top_result_rel)
1909 withCheckOptions = (
List *)
1911 (
Node *) withCheckOptions,
1914 withCheckOptionLists =
lappend(withCheckOptionLists,
1917 if (
parse->returningList)
1919 List *returningList =
parse->returningList;
1921 if (this_result_rel != top_result_rel)
1922 returningList = (
List *)
1924 (
Node *) returningList,
1927 returningLists =
lappend(returningLists,
1930 if (
parse->mergeActionList)
1939 foreach(l,
parse->mergeActionList)
1949 leaf_action->targetList = (
List *)
1955 leaf_action->updateColnos =
1958 this_result_rel->
relid,
1959 top_result_rel->
relid);
1960 mergeActionList =
lappend(mergeActionList,
1964 mergeActionLists =
lappend(mergeActionLists,
1969 Node *mergeJoinCondition =
parse->mergeJoinCondition;
1971 if (this_result_rel != top_result_rel)
1972 mergeJoinCondition =
1977 mergeJoinConditions =
lappend(mergeJoinConditions,
1978 mergeJoinCondition);
1982 if (resultRelations ==
NIL)
1998 if (
parse->withCheckOptions)
2000 if (
parse->returningList)
2002 if (
parse->mergeActionList)
2015 if (
parse->withCheckOptions)
2017 if (
parse->returningList)
2019 if (
parse->mergeActionList)
2030 if (
parse->rowMarks)
2033 rowMarks =
root->rowMarks;
2040 parse->resultRelation,
2042 root->partColsUpdated,
2045 withCheckOptionLists,
2050 mergeJoinConditions,
2083 if (final_rel->fdwroutine &&
2084 final_rel->fdwroutine->GetForeignUpperPaths)
2086 current_rel, final_rel,
2092 current_rel, final_rel, &extra);
2123 root->processed_groupClause =
parse->groupClause;
2125 if (
parse->groupClause)
2129 foreach(lc,
parse->groupClause)
2159 foreach(lc,
parse->groupingSets)
2180 (
errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
2181 errmsg(
"could not implement GROUP BY"),
2182 errdetail(
"Some of the datatypes only support hashing, while others only support sorting.")));
2185 sortable_sets =
lappend(sortable_sets, gset);
2196 foreach(lc_set, sets)
2287 int *tleref_to_colnum_map)
2293 foreach(lc, groupClause)
2306 foreach(lc2, gs->
set)
2311 result =
lappend(result, set);
2330 if (
parse->rowMarks)
2339 parse->rowMarks)->strength);
2359 if (
parse->resultRelation)
2366 foreach(l,
parse->rowMarks)
2399 prowmarks =
lappend(prowmarks, newrc);
2406 foreach(l,
parse->rtable)
2424 prowmarks =
lappend(prowmarks, newrc);
2427 root->rowMarks = prowmarks;
2441 else if (rte->relkind == RELKIND_FOREIGN_TABLE)
2477 elog(
ERROR,
"unrecognized LockClauseStrength %d", (
int) strength);
2505 double limit_fraction;
2514 if (
parse->limitCount)
2519 if (((
Const *) est)->constisnull)
2527 if (*count_est <= 0)
2537 if (
parse->limitOffset)
2542 if (((
Const *) est)->constisnull)
2550 if (*offset_est < 0)
2560 if (*count_est != 0)
2567 if (*count_est < 0 || *offset_est < 0)
2570 limit_fraction = 0.10;
2575 limit_fraction = (double) *count_est + (
double) *offset_est;
2585 if (tuple_fraction >= 1.0)
2587 if (limit_fraction >= 1.0)
2590 tuple_fraction =
Min(tuple_fraction, limit_fraction);
2597 else if (tuple_fraction > 0.0)
2599 if (limit_fraction >= 1.0)
2602 tuple_fraction = limit_fraction;
2607 tuple_fraction =
Min(tuple_fraction, limit_fraction);
2613 tuple_fraction = limit_fraction;
2616 else if (*offset_est != 0 && tuple_fraction > 0.0)
2627 if (*offset_est < 0)
2628 limit_fraction = 0.10;
2630 limit_fraction = (double) *offset_est;
2638 if (tuple_fraction >= 1.0)
2640 if (limit_fraction >= 1.0)
2643 tuple_fraction += limit_fraction;
2648 tuple_fraction = limit_fraction;
2653 if (limit_fraction >= 1.0)
2660 tuple_fraction += limit_fraction;
2661 if (tuple_fraction >= 1.0)
2662 tuple_fraction = 0.0;
2667 return tuple_fraction;
2689 node =
parse->limitCount;
2695 if (!((
Const *) node)->constisnull)
2702 node =
parse->limitOffset;
2708 if (!((
Const *) node)->constisnull)
2766 new_groupclause =
lappend(new_groupclause, cl);
2769 return new_groupclause;
2782 foreach(sl,
parse->sortClause)
2786 foreach(gl,
parse->groupClause)
2792 new_groupclause =
lappend(new_groupclause, gc);
2802 if (new_groupclause ==
NIL)
2811 foreach(gl,
parse->groupClause)
2819 new_groupclause =
lappend(new_groupclause, gc);
2824 return new_groupclause;
2859 short *adjacency_buf;
2875 lc1 =
lnext(groupingSets, lc1);
2900 orig_sets =
palloc0((num_sets_raw + 1) *
sizeof(
List *));
2902 adjacency =
palloc0((num_sets_raw + 1) *
sizeof(
short *));
2903 adjacency_buf =
palloc((num_sets_raw + 1) *
sizeof(
short));
2916 foreach(lc2, candidate)
2926 for (k =
j; k <
i; ++k)
2928 if (
bms_equal(set_masks[k], candidate_set))
2943 orig_sets[dup_of] =
lappend(orig_sets[dup_of], candidate);
2952 set_masks[
i] = candidate_set;
2956 for (k =
j - 1; k > 0; --k)
2959 adjacency_buf[++n_adj] = k;
2964 adjacency_buf[0] = n_adj;
2965 adjacency[
i] =
palloc((n_adj + 1) *
sizeof(
short));
2966 memcpy(adjacency[
i], adjacency_buf, (n_adj + 1) *
sizeof(
short));
2969 adjacency[
i] = NULL;
2988 chains =
palloc0((num_sets + 1) *
sizeof(
int));
2990 for (
i = 1;
i <= num_sets; ++
i)
2992 int u =
state->pair_vu[
i];
2993 int v =
state->pair_uv[
i];
2996 chains[
i] = chains[u];
2997 else if (v > 0 && v <
i)
2998 chains[
i] = chains[v];
3000 chains[
i] = ++num_chains;
3004 results =
palloc0((num_chains + 1) *
sizeof(
List *));
3006 for (
i = 1;
i <= num_sets; ++
i)
3016 while (num_empty-- > 0)
3017 results[1] =
lcons(
NIL, results[1]);
3020 for (
i = 1;
i <= num_chains; ++
i)
3021 result =
lappend(result, results[
i]);
3032 for (
i = 1;
i <= num_sets; ++
i)
3036 pfree(adjacency_buf);
3038 for (
i = 1;
i <= num_sets; ++
i)
3065 foreach(lc, groupingSets)
3093 result =
lcons(gs, result);
3115 if (pathkey->pk_eclass->ec_has_volatile)
3154 List *grouppathkeys =
root->group_pathkeys;
3174 unprocessed_aggs = NULL;
3175 foreach(lc,
root->agginfos)
3180 if (AGGKIND_IS_ORDERED_SET(aggref->aggkind))
3241 if (currpathkeys ==
NIL)
3243 currpathkeys = pathkeys;
3246 if (grouppathkeys !=
NIL)
3258 if (grouppathkeys !=
NIL)
3267 currpathkeys = pathkeys;
3294 bestaggs = aggindexes;
3295 bestpathkeys = currpathkeys;
3304 if (bestpathkeys !=
NIL)
3305 root->group_pathkeys = bestpathkeys;
3324 aggref->aggpresorted =
true;
3337 List *tlist =
root->processed_tlist;
3365 root->group_pathkeys =
3379 root->num_groupby_pathkeys = 0;
3382 else if (
parse->groupClause ||
root->numOrderedAggs > 0)
3398 root->group_pathkeys =
3400 &
root->processed_groupClause,
3410 root->num_groupby_pathkeys = 0;
3416 if (
root->numOrderedAggs > 0)
3423 root->num_groupby_pathkeys = 0;
3427 if (activeWindows !=
NIL)
3444 if (
parse->distinctClause)
3450 root->distinct_pathkeys =
3452 &
root->processed_distinctClause,
3459 root->distinct_pathkeys =
NIL;
3462 root->distinct_pathkeys =
NIL;
3464 root->sort_pathkeys =
3470 if (qp_extra->
setop != NULL)
3477 root->setop_pathkeys =
3511 if (
root->group_pathkeys)
3512 root->query_pathkeys =
root->group_pathkeys;
3513 else if (
root->window_pathkeys)
3514 root->query_pathkeys =
root->window_pathkeys;
3517 root->query_pathkeys =
root->distinct_pathkeys;
3518 else if (
root->sort_pathkeys)
3519 root->query_pathkeys =
root->sort_pathkeys;
3520 else if (
root->setop_pathkeys !=
NIL)
3521 root->query_pathkeys =
root->setop_pathkeys;
3546 if (
parse->groupClause)
3550 if (
parse->groupingSets)
3623 else if (
parse->groupingSets)
3628 else if (
parse->hasAggs ||
root->hasHavingQual)
3663 bool target_parallel_safe,
3679 target_parallel_safe,
parse->havingQual);
3728 root->numOrderedAggs == 0 &&
3738 extra.
flags = flags;
3756 &agg_costs, gd, &extra,
3757 &partially_grouped_rel);
3774 PathTarget *target,
bool target_parallel_safe,
3813 grouped_rel->fdwroutine = input_rel->fdwroutine;
3830 return (
root->hasHavingQual ||
parse->groupingSets) &&
3866 while (--nrows >= 0)
3947 root->parse->groupClause))
3962 bool force_rel_creation;
3971 partially_grouped_rel =
3977 force_rel_creation);
3981 *partially_grouped_rel_p = partially_grouped_rel;
3986 partially_grouped_rel, agg_costs,
3992 Assert(partially_grouped_rel);
3994 if (partially_grouped_rel->
pathlist)
4011 cheapest_path->
rows,
4017 partially_grouped_rel, agg_costs, gd,
4023 (
errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
4024 errmsg(
"could not implement GROUP BY"),
4025 errdetail(
"Some of the datatypes only support hashing, while others only support sorting.")));
4031 if (grouped_rel->fdwroutine &&
4032 grouped_rel->fdwroutine->GetForeignUpperPaths)
4034 input_rel, grouped_rel,
4040 input_rel, grouped_rel,
4085 double exclude_groups = 0.0;
4109 if (l_start != NULL &&
4113 exclude_groups = unhashed_rollup->
numGroups;
4120 dNumGroups - exclude_groups);
4127 if (hashsize > hash_mem_limit && gd->
rollups)
4156 foreach(lc, sets_data)
4165 empty_sets_data =
lappend(empty_sets_data, gs);
4180 new_rollups =
lappend(new_rollups, rollup);
4188 if (new_rollups ==
NIL)
4195 Assert(!unhashed_rollup || !empty_sets);
4197 if (unhashed_rollup)
4199 new_rollups =
lappend(new_rollups, unhashed_rollup);
4202 else if (empty_sets)
4208 rollup->
gsets = empty_sets;
4212 new_rollups =
lappend(new_rollups, rollup);
4245 double availspace = hash_mem_limit;
4261 int *k_weights =
palloc(num_rollups *
sizeof(
int));
4287 scale =
Max(availspace / (20.0 * num_rollups), 1.0);
4288 k_capacity = (int) floor(availspace /
scale);
4312 k_weights[
i] = (int)
Min(floor(sz /
scale),
4342 rollups =
lappend(rollups, rollup);
4346 rollups =
lappend(rollups, rollup);
4351 if (!rollups && hash_sets)
4354 foreach(lc, hash_sets)
4369 rollups =
lcons(rollup, rollups);
4417 bool output_target_parallel_safe,
4419 List *activeWindows)
4442 window_rel->fdwroutine = input_rel->fdwroutine;
4471 if (window_rel->fdwroutine &&
4472 window_rel->fdwroutine->GetForeignUpperPaths)
4474 input_rel, window_rel,
4480 input_rel, window_rel, NULL);
4506 List *activeWindows)
4527 window_target = input_target;
4529 foreach(l, activeWindows)
4532 List *window_pathkeys;
4541 root->processed_tlist);
4574 if (
lnext(activeWindows, l))
4599 window_target = output_target;
4614 foreach(lc3, wfunc->runCondition)
4639 wfuncrc->inputcollid);
4641 runcondition =
lappend(runcondition, opexpr);
4644 topqual =
lappend(topqual, opexpr);
4652 topwindow ? topqual :
NIL, topwindow);
4693 distinct_rel->fdwroutine = input_rel->fdwroutine;
4704 (
errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
4705 errmsg(
"could not implement DISTINCT"),
4706 errdetail(
"Some of the datatypes only support hashing, while others only support sorting.")));
4712 if (distinct_rel->fdwroutine &&
4713 distinct_rel->fdwroutine->GetForeignUpperPaths)
4714 distinct_rel->fdwroutine->GetForeignUpperPaths(
root,
4723 distinct_rel, NULL);
4728 return distinct_rel;
4746 List *distinctExprs;
4747 double numDistinctRows;
4748 Path *cheapest_partial_path;
4758 if (
parse->hasDistinctOn)
4763 partial_distinct_rel->
reltarget = target;
4772 partial_distinct_rel->fdwroutine = input_rel->fdwroutine;
4781 cheapest_partial_path->
rows,
4797 List *useful_pathkeys_list =
NIL;
4799 useful_pathkeys_list =
4801 root->distinct_pathkeys,
4808 partial_distinct_rel,
4810 cheapest_partial_path,
4814 if (sorted_path == NULL)
4822 if (
root->distinct_pathkeys ==
NIL)
4872 partial_distinct_rel,
4873 cheapest_partial_path,
4874 cheapest_partial_path->pathtarget,
4877 root->processed_distinctClause,
4887 if (partial_distinct_rel->fdwroutine &&
4888 partial_distinct_rel->fdwroutine->GetForeignUpperPaths)
4889 partial_distinct_rel->fdwroutine->GetForeignUpperPaths(
root,
4892 partial_distinct_rel,
4898 input_rel, partial_distinct_rel, NULL);
4911 final_distinct_rel);
4928 double numDistinctRows;
4933 root->hasHavingQual)
4940 numDistinctRows = cheapest_input_path->
rows;
4947 List *distinctExprs;
4952 cheapest_input_path->
rows,
4977 List *needed_pathkeys;
4979 double limittuples =
root->distinct_pathkeys ==
NIL ? 1.0 : -1.0;
4981 if (
parse->hasDistinctOn &&
4984 needed_pathkeys =
root->sort_pathkeys;
4986 needed_pathkeys =
root->distinct_pathkeys;
4992 List *useful_pathkeys_list =
NIL;
4994 useful_pathkeys_list =
5005 cheapest_input_path,
5009 if (sorted_path == NULL)
5025 if (
root->distinct_pathkeys ==
NIL)
5081 cheapest_input_path,
5082 cheapest_input_path->pathtarget,
5085 root->processed_distinctClause,
5091 return distinct_rel;
5104 List *path_pathkeys)
5106 List *useful_pathkeys_list =
NIL;
5110 useful_pathkeys_list =
lappend(useful_pathkeys_list,
5114 return useful_pathkeys_list;
5133 if (
root->parse->hasDistinctOn &&
5137 useful_pathkeys =
lappend(useful_pathkeys, pathkey);
5141 if (useful_pathkeys ==
NIL)
5142 return useful_pathkeys_list;
5150 return useful_pathkeys_list;
5162 return useful_pathkeys_list;
5164 useful_pathkeys_list =
lappend(useful_pathkeys_list,
5167 return useful_pathkeys_list;
5191 bool target_parallel_safe,
5192 double limit_tuples)
5215 ordered_rel->fdwroutine = input_rel->fdwroutine;
5225 input_path->
pathkeys, &presorted_keys);
5228 sorted_path = input_path;
5238 if (input_path != cheapest_input_path &&
5251 root->sort_pathkeys,
5257 root->sort_pathkeys,
5266 if (!
equal(sorted_path->pathtarget->exprs, target->
exprs))
5268 sorted_path, target);
5270 add_path(ordered_rel, sorted_path);
5287 Path *cheapest_partial_path;
5297 double total_groups;
5313 if (input_path != cheapest_partial_path &&
5326 root->sort_pathkeys,
5332 root->sort_pathkeys,
5336 sorted_path = (
Path *)
5339 sorted_path->pathtarget,
5340 root->sort_pathkeys, NULL,
5347 if (!
equal(sorted_path->pathtarget->exprs, target->
exprs))
5349 sorted_path, target);
5351 add_path(ordered_rel, sorted_path);
5359 if (ordered_rel->fdwroutine &&
5360 ordered_rel->fdwroutine->GetForeignUpperPaths)
5362 input_rel, ordered_rel,
5368 input_rel, ordered_rel, NULL);
5412 List *non_group_cols;
5413 List *non_group_vars;
5422 non_group_cols =
NIL;
5425 foreach(lc, final_target->
exprs)
5430 if (sgref &&
root->processed_groupClause &&
5432 root->processed_groupClause) != NULL)
5457 non_group_cols =
lappend(non_group_cols, expr);
5466 if (
parse->havingQual)
5467 non_group_cols =
lappend(non_group_cols,
parse->havingQual);
5488 non_group_vars = (
List *)
5525 List *non_group_cols;
5526 List *non_group_exprs;
5531 non_group_cols =
NIL;
5534 foreach(lc, grouping_target->
exprs)
5539 if (sgref &&
root->processed_groupClause &&
5541 root->processed_groupClause) != NULL)
5555 non_group_cols =
lappend(non_group_cols, expr);
5565 non_group_cols =
lappend(non_group_cols, havingQual);
5586 foreach(lc, partial_target->
exprs)
5599 memcpy(newaggref, aggref,
sizeof(
Aggref));
5631 agg->aggsplit = aggsplit;
5641 agg->aggtype = BYTEAOID;
5643 agg->aggtype = agg->aggtranstype;
5663 foreach(l, new_tlist)
5669 if (new_tle->resjunk)
5672 Assert(orig_tlist_item != NULL);
5674 orig_tlist_item =
lnext(orig_tlist, orig_tlist_item);
5675 if (orig_tle->resjunk)
5676 elog(
ERROR,
"resjunk output columns are not implemented");
5680 if (orig_tlist_item != NULL)
5681 elog(
ERROR,
"resjunk output columns are not implemented");
5697 List *windowClause =
root->parse->windowClause;
5700 foreach(lc, windowClause)
5704 int optimizedFrameOptions = 0;
5725 req.
type = T_SupportRequestOptimizeWindowClause;
5747 optimizedFrameOptions =
res->frameOptions;
5754 else if (optimizedFrameOptions !=
res->frameOptions)
5759 if (lc2 == NULL && wc->
frameOptions != optimizedFrameOptions)
5779 foreach(lc3, windowClause)
5784 if (existing_wc == wc)
5837 List *windowClause =
root->parse->windowClause;
5845 foreach(lc, windowClause)
5854 actives[nActive].
wc = wc;
5898 for (
int i = 0;
i < nActive;
i++)
5899 result =
lappend(result, actives[
i].wc);
5994 List *activeWindows)
5998 List *flattenable_cols;
5999 List *flattenable_vars;
6010 foreach(lc, activeWindows)
6030 foreach(lc,
root->processed_groupClause)
6042 flattenable_cols =
NIL;
6045 foreach(lc, final_target->
exprs)
6069 flattenable_cols =
lappend(flattenable_cols, expr);
6120 (
errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
6121 errmsg(
"could not implement window PARTITION BY"),
6122 errdetail(
"Window partitioning columns must be of sortable datatypes.")));
6125 (
errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
6126 errmsg(
"could not implement window ORDER BY"),
6127 errdetail(
"Window ordering columns must be of sortable datatypes.")));
6157 List *orderby_pathkeys;
6164 if (window_pathkeys !=
NIL)
6167 window_pathkeys = orderby_pathkeys;
6170 return window_pathkeys;
6242 bool *have_postponed_srfs)
6251 bool have_expensive;
6252 bool have_srf_sortcols;
6254 List *postponable_cols;
6255 List *postponable_vars;
6262 *have_postponed_srfs =
false;
6266 col_is_srf = (
bool *)
palloc0(ncols *
sizeof(
bool));
6267 postpone_col = (
bool *)
palloc0(ncols *
sizeof(
bool));
6268 have_srf = have_volatile = have_expensive = have_srf_sortcols =
false;
6271 foreach(lc, final_target->
exprs)
6289 if (
parse->hasTargetSRFs &&
6293 col_is_srf[
i] =
true;
6299 postpone_col[
i] =
true;
6300 have_volatile =
true;
6320 postpone_col[
i] =
true;
6321 have_expensive =
true;
6328 if (!have_srf_sortcols &&
6329 parse->hasTargetSRFs &&
6331 have_srf_sortcols =
true;
6340 postpone_srfs = (have_srf && !have_srf_sortcols);
6345 if (!(postpone_srfs || have_volatile ||
6347 (
parse->limitCount ||
root->tuple_fraction > 0))))
6348 return final_target;
6356 *have_postponed_srfs = postpone_srfs;
6364 postponable_cols =
NIL;
6367 foreach(lc, final_target->
exprs)
6371 if (postpone_col[
i] || (postpone_srfs && col_is_srf[
i]))
6372 postponable_cols =
lappend(postponable_cols, expr);
6417 if (tuple_fraction <= 0.0)
6421 if (tuple_fraction >= 1.0 && best_path->
rows > 0)
6422 tuple_fraction /= best_path->
rows;
6455 List *targets,
List *targets_contain_srfs)
6484 forboth(lc1, targets, lc2, targets_contain_srfs)
6517 forboth(lc1, targets, lc2, targets_contain_srfs)
6583 return (
Expr *) result;
6598 List **relationOids,
6606 MemSet(&glob, 0,
sizeof(glob));
6607 glob.type = T_PlannerGlobal;
6612 root.type = T_PlannerInfo;
6634 return (
Expr *) result;
6659 Cost comparisonCost;
6661 Path seqScanAndSortPath;
6676 root->parse = query;
6678 root->query_level = 1;
6680 root->wt_param_id = -1;
6686 rte->
relid = tableOid;
6687 rte->relkind = RELKIND_RELATION;
6689 rte->lateral =
false;
6691 rte->inFromCl =
true;
6706 if (indexInfo->
indexoid == indexOid)
6781 int parallel_workers;
6800 root->parse = query;
6802 root->query_level = 1;
6804 root->wt_param_id = -1;
6817 rte->
relid = tableOid;
6818 rte->relkind = RELKIND_RELATION;
6820 rte->lateral =
false;
6822 rte->inFromCl =
true;
6843 if (heap->
rd_rel->relpersistence == RELPERSISTENCE_TEMP ||
6847 parallel_workers = 0;
6888 while (parallel_workers > 0 &&
6896 return parallel_workers;
6931 Path *path_save = path;
6932 List *pathkey_orderings =
NIL;
6939 foreach(lc2, pathkey_orderings)
6956 if (
parse->groupingSets)
6959 path,
true, can_hash,
6960 gd, agg_costs, dNumGroups);
6962 else if (
parse->hasAggs)
6980 else if (
parse->groupClause)
7006 if (partially_grouped_rel != NULL)
7008 foreach(lc, partially_grouped_rel->
pathlist)
7012 Path *path_save = path;
7013 List *pathkey_orderings =
NIL;
7021 foreach(lc2, pathkey_orderings)
7066 if (
parse->groupingSets)
7072 cheapest_path,
false,
true,
7073 gd, agg_costs, dNumGroups);
7087 root->processed_groupClause,
7097 if (partially_grouped_rel && partially_grouped_rel->
pathlist)
7108 root->processed_groupClause,
7147 bool force_rel_creation)
7153 Path *cheapest_partial_path = NULL;
7154 Path *cheapest_total_path = NULL;
7155 double dNumPartialGroups = 0;
7156 double dNumPartialPartialGroups = 0;
7185 if (cheapest_total_path == NULL &&
7186 cheapest_partial_path == NULL &&
7187 !force_rel_creation)
7203 partially_grouped_rel->fdwroutine = grouped_rel->fdwroutine;
7238 if (cheapest_total_path != NULL)
7241 cheapest_total_path->
rows,
7244 if (cheapest_partial_path != NULL)
7245 dNumPartialPartialGroups =
7247 cheapest_partial_path->
rows,
7251 if (can_sort && cheapest_total_path != NULL)
7264 Path *path_save = path;
7265 List *pathkey_orderings =
NIL;
7273 foreach(lc2, pathkey_orderings)
7281 partially_grouped_rel,
7283 cheapest_total_path,
7293 partially_grouped_rel,
7301 dNumPartialGroups));
7305 partially_grouped_rel,
7309 dNumPartialGroups));
7314 if (can_sort && cheapest_partial_path != NULL)
7321 Path *path_save = path;
7322 List *pathkey_orderings =
NIL;
7330 foreach(lc2, pathkey_orderings)
7339 partially_grouped_rel,
7341 cheapest_partial_path,
7351 partially_grouped_rel,
7359 dNumPartialPartialGroups));
7363 partially_grouped_rel,
7367 dNumPartialPartialGroups));
7375 if (can_hash && cheapest_total_path != NULL)
7382 partially_grouped_rel,
7383 cheapest_total_path,
7387 root->processed_groupClause,
7390 dNumPartialGroups));
7396 if (can_hash && cheapest_partial_path != NULL)
7400 partially_grouped_rel,
7401 cheapest_partial_path,
7405 root->processed_groupClause,
7408 dNumPartialPartialGroups));
7415 if (partially_grouped_rel->fdwroutine &&
7416 partially_grouped_rel->fdwroutine->GetForeignUpperPaths)
7418 FdwRoutine *fdwroutine = partially_grouped_rel->fdwroutine;
7422 input_rel, partially_grouped_rel,
7426 return partially_grouped_rel;
7437 Path *cheapest_path,
List *pathkeys,
double limit_tuples)
7454 if (path != cheapest_path &&
7498 Path *cheapest_partial_path;
7499 List *groupby_pathkeys;
7507 root->num_groupby_pathkeys);
7509 groupby_pathkeys =
root->group_pathkeys;
7522 double total_groups;
7537 if (path != cheapest_partial_path &&
7590 else if (
parse->groupingSets)
7595 else if (
root->hasNonPartialAggs ||
root->hasNonSerialAggs)
7622 List *scanjoin_targets,
7623 List *scanjoin_targets_contain_srfs,
7624 bool scanjoin_target_parallel_safe,
7653 if (rel_is_partitioned)
7660 if (!scanjoin_target_parallel_safe)
7679 if (rel_is_partitioned)
7702 subpath->pathtarget->sortgrouprefs =
7703 scanjoin_target->sortgrouprefs;
7723 subpath->pathtarget->sortgrouprefs =
7724 scanjoin_target->sortgrouprefs;
7741 if (
root->parse->hasTargetSRFs)
7744 scanjoin_targets_contain_srfs);
7766 if (rel_is_partitioned)
7778 List *child_scanjoin_targets =
NIL;
7780 Assert(child_rel != NULL);
7789 foreach(lc, scanjoin_targets)
7797 nappinfos, appinfos);
7798 child_scanjoin_targets =
lappend(child_scanjoin_targets,
7805 child_scanjoin_targets,
7806 scanjoin_targets_contain_srfs,
7807 scanjoin_target_parallel_safe,
7812 live_children =
lappend(live_children, child_rel);
7864 List *grouped_live_children =
NIL;
7865 List *partially_grouped_live_children =
NIL;
7867 bool partial_grouping_valid =
true;
7872 partially_grouped_rel != NULL);
7878 RelOptInfo *child_input_rel = input_rel->part_rels[
i];
7886 Assert(child_input_rel != NULL);
7898 memcpy(&child_extra, extra,
sizeof(child_extra));
7906 nappinfos, appinfos);
7912 nappinfos, appinfos);
7916 nappinfos, appinfos);
7923 child_extra.
patype = patype;
7937 agg_costs, gd, &child_extra,
7938 &child_partially_grouped_rel);
7940 if (child_partially_grouped_rel)
7942 partially_grouped_live_children =
7943 lappend(partially_grouped_live_children,
7944 child_partially_grouped_rel);
7947 partial_grouping_valid =
false;
7952 grouped_live_children =
lappend(grouped_live_children,
7968 if (partially_grouped_rel && partial_grouping_valid)
7970 Assert(partially_grouped_live_children !=
NIL);
7973 partially_grouped_live_children);
7979 if (partially_grouped_rel->
pathlist)
8008 Assert(input_rel->part_scheme);
8011 if (!input_rel->partexprs)
8014 partnatts = input_rel->part_scheme->partnatts;
8016 for (cnt = 0; cnt < partnatts; cnt++)
8018 List *partexprs = input_rel->partexprs[cnt];
8022 foreach(lc, partexprs)
8026 Oid partcoll = input_rel->part_scheme->partcollation[cnt];
8028 foreach(lg, groupexprs)
8041 if (
equal(groupexpr, partexpr))
8048 partcoll != groupcoll)
8090 foreach(lt, targetlist)
8102 lg =
lnext(grouplist, lg);
int compute_parallel_worker(RelOptInfo *rel, double heap_pages, double index_pages, int max_workers)
void generate_useful_gather_paths(PlannerInfo *root, RelOptInfo *rel, bool override_rows)
void add_paths_to_append_rel(PlannerInfo *root, RelOptInfo *rel, List *live_childrels)
AppendRelInfo ** find_appinfos_by_relids(PlannerInfo *root, Relids relids, int *nappinfos)
Node * adjust_appendrel_attrs(PlannerInfo *root, Node *node, int nappinfos, AppendRelInfo **appinfos)
List * adjust_inherited_attnums_multilevel(PlannerInfo *root, List *attnums, Index child_relid, Index top_parent_relid)
Node * adjust_appendrel_attrs_multilevel(PlannerInfo *root, Node *node, RelOptInfo *childrel, RelOptInfo *parentrel)
void pprint(const void *obj)
BipartiteMatchState * BipartiteMatch(int u_size, int v_size, short **adjacency)
void BipartiteMatchFree(BipartiteMatchState *state)
Bitmapset * bms_make_singleton(int x)
bool bms_equal(const Bitmapset *a, const Bitmapset *b)
int bms_next_member(const Bitmapset *a, int prevbit)
Bitmapset * bms_del_members(Bitmapset *a, const Bitmapset *b)
Bitmapset * bms_del_member(Bitmapset *a, int x)
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_add_member(Bitmapset *a, int x)
BMS_Membership bms_membership(const Bitmapset *a)
bool bms_overlap_list(const Bitmapset *a, const List *b)
#define Assert(condition)
#define MemSet(start, val, len)
#define OidIsValid(objectId)
bool contain_agg_clause(Node *clause)
Node * estimate_expression_value(PlannerInfo *root, Node *node)
WindowFuncLists * find_window_functions(Node *clause, Index maxWinRef)
Node * eval_const_expressions(PlannerInfo *root, Node *node)
void convert_saop_to_hashed_saop(Node *node)
char max_parallel_hazard(Query *parse)
bool is_parallel_safe(PlannerInfo *root, Node *node)
bool contain_subplans(Node *clause)
bool contain_volatile_functions(Node *clause)
bool enable_partitionwise_aggregate
int max_parallel_workers_per_gather
double parallel_setup_cost
double parallel_tuple_cost
void cost_sort(Path *path, PlannerInfo *root, List *pathkeys, int input_disabled_nodes, Cost input_cost, double tuples, int width, Cost comparison_cost, int sort_mem, double limit_tuples)
double compute_gather_rows(Path *path)
void cost_qual_eval_node(QualCost *cost, Node *qual, PlannerInfo *root)
PathTarget * set_pathtarget_cost_width(PlannerInfo *root, PathTarget *target)
void cost_qual_eval(QualCost *cost, List *quals, PlannerInfo *root)
bool enable_presorted_aggregate
int32 clamp_width_est(int64 tuple_width)
bool enable_incremental_sort
Plan * materialize_finished_plan(Plan *subplan)
Plan * create_plan(PlannerInfo *root, Path *best_path)
static void PGresult * res
int errdetail(const char *fmt,...)
int errcode(int sqlerrcode)
int errmsg(const char *fmt,...)
#define ereport(elevel,...)
bool equal(const void *a, const void *b)
bool ExecSupportsBackwardScan(Plan *node)
Datum Int64GetDatum(int64 X)
#define OidFunctionCall1(functionId, arg1)
FdwRoutine * GetFdwRoutineByRelId(Oid relid)
int max_parallel_maintenance_workers
#define IsParallelWorker()
void index_close(Relation relation, LOCKMODE lockmode)
Relation index_open(Oid relationId, LOCKMODE lockmode)
if(TABLE==NULL||TABLE_index==NULL)
double jit_optimize_above_cost
double jit_inline_above_cost
Bitmapset * DiscreteKnapsack(int max_weight, int num_items, int *item_weights, double *item_values)
List * lappend(List *list, void *datum)
List * list_difference_int(const List *list1, const List *list2)
List * list_concat_unique_ptr(List *list1, const List *list2)
List * list_concat(List *list1, const List *list2)
List * list_copy(const List *oldlist)
List * lappend_int(List *list, int datum)
List * lcons(void *datum, List *list)
List * list_delete_int(List *list, int datum)
bool list_member_ptr(const List *list, const void *datum)
void list_free(List *list)
bool list_member_int(const List *list, int datum)
List * list_copy_head(const List *oldlist, int len)
List * list_concat_unique(List *list1, const List *list2)
RegProcedure get_func_support(Oid funcid)
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 * makeConst(Oid consttype, int32 consttypmod, Oid constcollid, int constlen, Datum constvalue, bool constisnull, bool constbyval)
List * make_ands_implicit(Expr *clause)
void pfree(void *pointer)
void * palloc0(Size size)
MemoryContext CurrentMemoryContext
Oid exprCollation(const Node *expr)
bool expression_returns_set(Node *clause)
void fix_opfuncids(Node *node)
size_t get_hash_memory_limit(void)
#define DO_AGGSPLIT_SKIPFINAL(as)
#define IsA(nodeptr, _type_)
#define IS_OUTER_JOIN(jointype)
#define DO_AGGSPLIT_SERIALIZE(as)
@ AGGSPLIT_FINAL_DESERIAL
@ AGGSPLIT_INITIAL_SERIAL
#define PVC_RECURSE_AGGREGATES
#define PVC_RECURSE_WINDOWFUNCS
#define PVC_INCLUDE_WINDOWFUNCS
#define PVC_INCLUDE_PLACEHOLDERS
#define PVC_INCLUDE_AGGREGATES
int assign_special_exec_param(PlannerInfo *root)
List * expand_grouping_sets(List *groupingSets, bool groupDistinct, int limit)
Index assignSortGroupRef(TargetEntry *tle, List *tlist)
RTEPermissionInfo * addRTEPermissionInfo(List **rteperminfos, RangeTblEntry *rte)
#define CURSOR_OPT_SCROLL
#define CURSOR_OPT_FAST_PLAN
#define CURSOR_OPT_PARALLEL_OK
void CheckSelectLocking(Query *qry, LockClauseStrength strength)
const char * LCS_asString(LockClauseStrength strength)
#define rt_fetch(rangetable_index, rangetable)
void DestroyPartitionDirectory(PartitionDirectory pdir)
List * append_pathkeys(List *target, List *source)
bool pathkeys_count_contained_in(List *keys1, List *keys2, int *n_common)
List * make_pathkeys_for_sortclauses(PlannerInfo *root, List *sortclauses, List *tlist)
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)
bool pathkeys_contained_in(List *keys1, List *keys2)
PathKeysComparison compare_pathkeys(List *keys1, List *keys2)
List * get_useful_group_keys_orderings(PlannerInfo *root, Path *path)
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)
ProjectSetPath * create_set_projection_path(PlannerInfo *root, RelOptInfo *rel, Path *subpath, PathTarget *target)
ProjectionPath * create_projection_path(PlannerInfo *root, RelOptInfo *rel, Path *subpath, PathTarget *target)
WindowAggPath * create_windowagg_path(PlannerInfo *root, RelOptInfo *rel, Path *subpath, PathTarget *target, List *windowFuncs, List *runCondition, WindowClause *winclause, List *qual, bool topwindow)
LockRowsPath * create_lockrows_path(PlannerInfo *root, RelOptInfo *rel, Path *subpath, List *rowMarks, int epqParam)
Path * apply_projection_to_path(PlannerInfo *root, RelOptInfo *rel, Path *path, PathTarget *target)
Path * create_seqscan_path(PlannerInfo *root, RelOptInfo *rel, Relids required_outer, int parallel_workers)
GatherMergePath * create_gather_merge_path(PlannerInfo *root, RelOptInfo *rel, Path *subpath, PathTarget *target, List *pathkeys, Relids required_outer, double *rows)
void set_cheapest(RelOptInfo *parent_rel)
void add_partial_path(RelOptInfo *parent_rel, Path *new_path)
LimitPath * create_limit_path(PlannerInfo *root, RelOptInfo *rel, Path *subpath, Node *limitOffset, Node *limitCount, LimitOption limitOption, int64 offset_est, int64 count_est)
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)
int compare_fractional_path_costs(Path *path1, Path *path2, double fraction)
IncrementalSortPath * create_incremental_sort_path(PlannerInfo *root, RelOptInfo *rel, Path *subpath, List *pathkeys, int presorted_keys, double limit_tuples)
GroupingSetsPath * create_groupingsets_path(PlannerInfo *root, RelOptInfo *rel, Path *subpath, List *having_qual, AggStrategy aggstrategy, List *rollups, const AggClauseCosts *agg_costs)
SortPath * create_sort_path(PlannerInfo *root, RelOptInfo *rel, Path *subpath, List *pathkeys, double limit_tuples)
GroupPath * create_group_path(PlannerInfo *root, RelOptInfo *rel, Path *subpath, List *groupClause, List *qual, double numGroups)
void add_path(RelOptInfo *parent_rel, Path *new_path)
UpperUniquePath * create_upper_unique_path(PlannerInfo *root, RelOptInfo *rel, Path *subpath, int numCols, double numGroups)
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)
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)
GroupResultPath * create_group_result_path(PlannerInfo *root, RelOptInfo *rel, PathTarget *target, List *havingqual)
PartitionwiseAggregateType
@ PARTITIONWISE_AGGREGATE_PARTIAL
@ PARTITIONWISE_AGGREGATE_FULL
@ PARTITIONWISE_AGGREGATE_NONE
#define GROUPING_CAN_USE_HASH
#define get_pathtarget_sortgroupref(target, colno)
#define IS_PARTITIONED_REL(rel)
#define GROUPING_CAN_USE_SORT
#define GROUPING_CAN_PARTIAL_AGG
@ UPPERREL_PARTIAL_GROUP_AGG
@ UPPERREL_PARTIAL_DISTINCT
#define IS_OTHER_REL(rel)
bool has_subclass(Oid relationId)
#define lfirst_node(type, lc)
static int list_length(const List *l)
#define linitial_node(type, l)
#define forboth(cell1, list1, cell2, list2)
#define foreach_current_index(var_or_cell)
#define for_each_cell(cell, lst, initcell)
#define for_each_from(cell, lst, N)
static void * list_nth(const List *list, int n)
#define foreach_node(type, var, lst)
static ListCell * list_head(const List *l)
#define list_nth_node(type, list, n)
static ListCell * lnext(const List *l, const ListCell *c)
#define list_make1_int(x1)
static int list_cell_number(const List *l, const ListCell *c)
#define llast_node(type, l)
void preprocess_minmax_aggregates(PlannerInfo *root)
void estimate_rel_size(Relation rel, int32 *attr_widths, BlockNumber *pages, double *tuples, double *allvisfrac)
int32 get_relation_data_width(Oid relid, int32 *attr_widths)
RelOptInfo * query_planner(PlannerInfo *root, query_pathkeys_callback qp_callback, void *qp_extra)
#define DEFAULT_CURSOR_TUPLE_FRACTION
#define EXPRKIND_TABLEFUNC_LATERAL
static RelOptInfo * create_final_distinct_paths(PlannerInfo *root, RelOptInfo *input_rel, RelOptInfo *distinct_rel)
static List * postprocess_setop_tlist(List *new_tlist, List *orig_tlist)
static PathTarget * make_partial_grouping_target(PlannerInfo *root, PathTarget *grouping_target, Node *havingQual)
Expr * expression_planner_with_deps(Expr *expr, List **relationOids, List **invalItems)
static void gather_grouping_paths(PlannerInfo *root, RelOptInfo *rel)
static void preprocess_rowmarks(PlannerInfo *root)
#define EXPRKIND_TABLESAMPLE
PlannedStmt * planner(Query *parse, const char *query_string, int cursorOptions, ParamListInfo boundParams)
static void create_degenerate_grouping_paths(PlannerInfo *root, RelOptInfo *input_rel, RelOptInfo *grouped_rel)
#define EXPRKIND_GROUPEXPR
planner_hook_type planner_hook
double cursor_tuple_fraction
static bool is_degenerate_grouping(PlannerInfo *root)
bool plan_cluster_use_sort(Oid tableOid, Oid indexOid)
static void preprocess_qual_conditions(PlannerInfo *root, Node *jtnode)
int plan_create_index_workers(Oid tableOid, Oid indexOid)
#define EXPRKIND_RTFUNC_LATERAL
#define EXPRKIND_VALUES_LATERAL
static void create_ordinary_grouping_paths(PlannerInfo *root, RelOptInfo *input_rel, RelOptInfo *grouped_rel, const AggClauseCosts *agg_costs, grouping_sets_data *gd, GroupPathExtraData *extra, RelOptInfo **partially_grouped_rel_p)
static bool can_partial_agg(PlannerInfo *root)
static double preprocess_limit(PlannerInfo *root, double tuple_fraction, int64 *offset_est, int64 *count_est)
Path * get_cheapest_fractional_path(RelOptInfo *rel, double tuple_fraction)
Expr * preprocess_phv_expression(PlannerInfo *root, Expr *expr)
static List * get_useful_pathkeys_for_distinct(PlannerInfo *root, List *needed_pathkeys, List *path_pathkeys)
bool parallel_leader_participation
static PathTarget * make_window_input_target(PlannerInfo *root, PathTarget *final_target, List *activeWindows)
static void apply_scanjoin_target_to_paths(PlannerInfo *root, RelOptInfo *rel, List *scanjoin_targets, List *scanjoin_targets_contain_srfs, bool scanjoin_target_parallel_safe, bool tlist_same_exprs)
static RelOptInfo * create_distinct_paths(PlannerInfo *root, RelOptInfo *input_rel, PathTarget *target)
static void optimize_window_clauses(PlannerInfo *root, WindowFuncLists *wflists)
RowMarkType select_rowmark_type(RangeTblEntry *rte, LockClauseStrength strength)
PlannerInfo * subquery_planner(PlannerGlobal *glob, Query *parse, PlannerInfo *parent_root, bool hasRecursion, double tuple_fraction, SetOperationStmt *setops)
static void adjust_paths_for_srfs(PlannerInfo *root, RelOptInfo *rel, List *targets, List *targets_contain_srfs)
static void create_partial_distinct_paths(PlannerInfo *root, RelOptInfo *input_rel, RelOptInfo *final_distinct_rel, PathTarget *target)
static List * preprocess_groupclause(PlannerInfo *root, List *force)
static Node * preprocess_expression(PlannerInfo *root, Node *expr, int kind)
static Path * make_ordered_path(PlannerInfo *root, RelOptInfo *rel, Path *path, Path *cheapest_path, List *pathkeys, double limit_tuples)
static bool has_volatile_pathkey(List *keys)
static RelOptInfo * create_partial_grouping_paths(PlannerInfo *root, RelOptInfo *grouped_rel, RelOptInfo *input_rel, grouping_sets_data *gd, GroupPathExtraData *extra, bool force_rel_creation)
static PathTarget * make_sort_input_target(PlannerInfo *root, PathTarget *final_target, bool *have_postponed_srfs)
static void create_one_window_path(PlannerInfo *root, RelOptInfo *window_rel, Path *path, PathTarget *input_target, PathTarget *output_target, WindowFuncLists *wflists, List *activeWindows)
bool enable_distinct_reordering
void mark_partial_aggref(Aggref *agg, AggSplit aggsplit)
static grouping_sets_data * preprocess_grouping_sets(PlannerInfo *root)
static List * remap_to_groupclause_idx(List *groupClause, List *gsets, int *tleref_to_colnum_map)
static void adjust_group_pathkeys_for_groupagg(PlannerInfo *root)
static PathTarget * make_group_input_target(PlannerInfo *root, PathTarget *final_target)
static List * reorder_grouping_sets(List *groupingSets, List *sortclause)
static int common_prefix_cmp(const void *a, const void *b)
static void grouping_planner(PlannerInfo *root, double tuple_fraction, SetOperationStmt *setops)
static RelOptInfo * make_grouping_rel(PlannerInfo *root, RelOptInfo *input_rel, PathTarget *target, bool target_parallel_safe, Node *havingQual)
static List * generate_setop_child_grouplist(SetOperationStmt *op, List *targetlist)
static List * select_active_windows(PlannerInfo *root, WindowFuncLists *wflists)
Expr * expression_planner(Expr *expr)
bool limit_needed(Query *parse)
create_upper_paths_hook_type create_upper_paths_hook
#define EXPRKIND_TABLEFUNC
static void consider_groupingsets_paths(PlannerInfo *root, RelOptInfo *grouped_rel, Path *path, bool is_sorted, bool can_hash, grouping_sets_data *gd, const AggClauseCosts *agg_costs, double dNumGroups)
static List * make_pathkeys_for_window(PlannerInfo *root, WindowClause *wc, List *tlist)
static void add_paths_to_grouping_rel(PlannerInfo *root, RelOptInfo *input_rel, RelOptInfo *grouped_rel, RelOptInfo *partially_grouped_rel, const AggClauseCosts *agg_costs, grouping_sets_data *gd, double dNumGroups, GroupPathExtraData *extra)
static RelOptInfo * create_ordered_paths(PlannerInfo *root, RelOptInfo *input_rel, PathTarget *target, bool target_parallel_safe, double limit_tuples)
static double get_number_of_groups(PlannerInfo *root, double path_rows, grouping_sets_data *gd, List *target_list)
static List * extract_rollup_sets(List *groupingSets)
static RelOptInfo * create_grouping_paths(PlannerInfo *root, RelOptInfo *input_rel, PathTarget *target, bool target_parallel_safe, grouping_sets_data *gd)
static void create_partitionwise_grouping_paths(PlannerInfo *root, RelOptInfo *input_rel, RelOptInfo *grouped_rel, RelOptInfo *partially_grouped_rel, const AggClauseCosts *agg_costs, grouping_sets_data *gd, PartitionwiseAggregateType patype, GroupPathExtraData *extra)
#define EXPRKIND_ARBITER_ELEM
static bool group_by_has_partkey(RelOptInfo *input_rel, List *targetList, List *groupClause)
PlannedStmt * standard_planner(Query *parse, const char *query_string, int cursorOptions, ParamListInfo boundParams)
static void standard_qp_callback(PlannerInfo *root, void *extra)
static RelOptInfo * create_window_paths(PlannerInfo *root, RelOptInfo *input_rel, PathTarget *input_target, PathTarget *output_target, bool output_target_parallel_safe, WindowFuncLists *wflists, List *activeWindows)
PlannedStmt *(* planner_hook_type)(Query *parse, const char *query_string, int cursorOptions, ParamListInfo boundParams)
void(* create_upper_paths_hook_type)(PlannerInfo *root, UpperRelationKind stage, RelOptInfo *input_rel, RelOptInfo *output_rel, void *extra)
@ ROW_MARK_NOKEYEXCLUSIVE
#define qsort(a, b, c, d)
static int64 DatumGetInt64(Datum X)
static Datum PointerGetDatum(const void *X)
static Pointer DatumGetPointer(Datum X)
void get_agg_clause_costs(PlannerInfo *root, AggSplit aggsplit, AggClauseCosts *costs)
void preprocess_aggrefs(PlannerInfo *root, Node *clause)
void preprocess_function_rtes(PlannerInfo *root)
void flatten_simple_union_all(PlannerInfo *root)
void transform_MERGE_to_join(Query *parse)
void remove_useless_result_rtes(PlannerInfo *root)
void pull_up_sublinks(PlannerInfo *root)
void replace_empty_jointree(Query *parse)
void pull_up_subqueries(PlannerInfo *root)
Relids get_relids_in_jointree(Node *jtnode, bool include_outer_joins, bool include_inner_joins)
void reduce_outer_joins(PlannerInfo *root)
Expr * canonicalize_qual(Expr *qual, bool is_check)
void preprocess_targetlist(PlannerInfo *root)
RelOptInfo * plan_set_operations(PlannerInfo *root)
static struct subre * parse(struct vars *v, int stopper, int type, struct state *init, struct state *final)
List * RelationGetIndexPredicate(Relation relation)
List * RelationGetIndexExpressions(Relation relation)
RelOptInfo * find_base_rel(PlannerInfo *root, int relid)
void setup_simple_rel_arrays(PlannerInfo *root)
RelOptInfo * fetch_upper_rel(PlannerInfo *root, UpperRelationKind kind, Relids relids)
RelOptInfo * build_simple_rel(PlannerInfo *root, int relid, RelOptInfo *parent)
Node * remove_nulling_relids(Node *node, const Bitmapset *removable_relids, const Bitmapset *except_relids)
double estimate_num_groups(PlannerInfo *root, List *groupExprs, double input_rows, List **pgset, EstimationInfo *estinfo)
double estimate_hashagg_tablesize(PlannerInfo *root, Path *path, const AggClauseCosts *agg_costs, double dNumGroups)
Plan * set_plan_references(PlannerInfo *root, Plan *plan)
bool extract_query_dependencies_walker(Node *node, PlannerInfo *context)
void check_stack_depth(void)
GetForeignRowMarkType_function GetForeignRowMarkType
GetForeignUpperPaths_function GetForeignUpperPaths
LockClauseStrength strength
LockWaitPolicy waitPolicy
Bitmapset * rewindPlanIDs
Bitmapset * rewindPlanIDs
struct TableSampleClause * tablesample
struct PathTarget * reltarget
struct Path * cheapest_startup_path
struct Path * cheapest_total_path
LockClauseStrength strength
LockWaitPolicy waitPolicy
struct WindowClause * window_clause
int * tleref_to_colnum_map
Bitmapset * unhashable_refs
Bitmapset * unsortable_refs
grouping_sets_data * gset_data
Node * SS_process_sublinks(PlannerInfo *root, Node *expr, bool isQual)
void SS_process_ctes(PlannerInfo *root)
void SS_identify_outer_params(PlannerInfo *root)
Node * SS_replace_correlation_vars(PlannerInfo *root, Node *expr)
void SS_finalize_plan(PlannerInfo *root, Plan *plan)
void SS_compute_initplan_cost(List *init_plans, Cost *initplan_cost_p, bool *unsafe_initplans_p)
void SS_charge_for_initplans(PlannerInfo *root, RelOptInfo *final_rel)
void table_close(Relation relation, LOCKMODE lockmode)
Relation table_open(Oid relationId, LOCKMODE lockmode)
bool tlist_same_exprs(List *tlist1, List *tlist2)
SortGroupClause * get_sortgroupref_clause_noerr(Index sortref, List *clauses)
SortGroupClause * get_sortgroupref_clause(Index sortref, List *clauses)
bool grouping_is_sortable(List *groupClause)
PathTarget * copy_pathtarget(PathTarget *src)
void add_new_columns_to_pathtarget(PathTarget *target, List *exprs)
PathTarget * create_empty_pathtarget(void)
List * get_sortgrouplist_exprs(List *sgClauses, List *targetList)
void split_pathtarget_at_srfs(PlannerInfo *root, PathTarget *target, PathTarget *input_target, List **targets, List **targets_contain_srfs)
bool grouping_is_hashable(List *groupClause)
void add_column_to_pathtarget(PathTarget *target, Expr *expr, Index sortgroupref)
#define create_pathtarget(root, tlist)
Node * flatten_group_exprs(PlannerInfo *root, Query *query, Node *node)
Relids pull_varnos(PlannerInfo *root, Node *node)
List * pull_var_clause(Node *node, int flags)
Node * flatten_join_alias_vars(PlannerInfo *root, Query *query, Node *node)