From baee6cd9e575728650813152af0d4d2d9c96674f Mon Sep 17 00:00:00 2001 From: Robert Haas Date: Mon, 26 Aug 2024 12:27:08 -0400 Subject: [PATCH v2 1/2] Convert enable_* GUCs into per-RelOptInfo values with GUCs setting defaults. --- contrib/postgres_fdw/postgres_fdw.c | 5 +- src/backend/optimizer/path/allpaths.c | 15 ++-- src/backend/optimizer/path/costsize.c | 107 +++++++++++++++++------- src/backend/optimizer/path/indxpath.c | 2 +- src/backend/optimizer/path/joinpath.c | 53 ++++++------ src/backend/optimizer/path/pathkeys.c | 3 +- src/backend/optimizer/path/tidpath.c | 11 +-- src/backend/optimizer/plan/createplan.c | 26 +++--- src/backend/optimizer/plan/planner.c | 58 ++++++++----- src/backend/optimizer/plan/subselect.c | 9 +- src/backend/optimizer/prep/prepunion.c | 20 +++-- src/backend/optimizer/util/pathnode.c | 21 ++--- src/backend/optimizer/util/plancat.c | 3 +- src/backend/optimizer/util/relnode.c | 6 +- src/backend/utils/misc/guc_tables.c | 37 ++++---- src/include/nodes/pathnodes.h | 29 +++++++ src/include/optimizer/cost.h | 29 ++++++- src/include/optimizer/planmain.h | 2 +- 18 files changed, 288 insertions(+), 148 deletions(-) diff --git a/contrib/postgres_fdw/postgres_fdw.c b/contrib/postgres_fdw/postgres_fdw.c index adc62576d1..1df4ddf268 100644 --- a/contrib/postgres_fdw/postgres_fdw.c +++ b/contrib/postgres_fdw/postgres_fdw.c @@ -439,6 +439,7 @@ static void get_remote_estimate(const char *sql, Cost *startup_cost, Cost *total_cost); static void adjust_foreign_grouping_path_cost(PlannerInfo *root, + RelOptInfo *rel, List *pathkeys, double retrieved_rows, double width, @@ -3489,7 +3490,7 @@ estimate_path_cost_size(PlannerInfo *root, { Assert(foreignrel->reloptkind == RELOPT_UPPER_REL && fpinfo->stage == UPPERREL_GROUP_AGG); - adjust_foreign_grouping_path_cost(root, pathkeys, + adjust_foreign_grouping_path_cost(root, foreignrel, pathkeys, retrieved_rows, width, fpextra->limit_tuples, &disabled_nodes, @@ -3644,6 +3645,7 @@ get_remote_estimate(const char *sql, PGconn *conn, */ static void adjust_foreign_grouping_path_cost(PlannerInfo *root, + RelOptInfo *rel, List *pathkeys, double retrieved_rows, double width, @@ -3667,6 +3669,7 @@ adjust_foreign_grouping_path_cost(PlannerInfo *root, cost_sort(&sort_path, root, + rel, pathkeys, 0, *p_startup_cost + *p_run_cost, diff --git a/src/backend/optimizer/path/allpaths.c b/src/backend/optimizer/path/allpaths.c index 057b4b79eb..8645244f84 100644 --- a/src/backend/optimizer/path/allpaths.c +++ b/src/backend/optimizer/path/allpaths.c @@ -970,7 +970,7 @@ set_append_rel_size(PlannerInfo *root, RelOptInfo *rel, * flag; currently, we only consider partitionwise joins with the baserel * if its targetlist doesn't contain a whole-row Var. */ - if (enable_partitionwise_join && + if (REL_CAN_USE_PATH(rel, PartitionwiseJoin) && rel->reloptkind == RELOPT_BASEREL && rte->relkind == RELKIND_PARTITIONED_TABLE && bms_is_empty(rel->attr_needed[InvalidAttrNumber - rel->min_attr])) @@ -1325,7 +1325,8 @@ add_paths_to_append_rel(PlannerInfo *root, RelOptInfo *rel, double partial_rows = -1; /* If appropriate, consider parallel append */ - pa_subpaths_valid = enable_parallel_append && rel->consider_parallel; + pa_subpaths_valid = REL_CAN_USE_PATH(rel, ParallelAppend) + && rel->consider_parallel; /* * For every non-dummy child, remember the cheapest path. Also, identify @@ -1535,7 +1536,7 @@ add_paths_to_append_rel(PlannerInfo *root, RelOptInfo *rel, * partitions vs. an unpartitioned table with the same data, so the * use of some kind of log-scaling here seems to make some sense. */ - if (enable_parallel_append) + if (REL_CAN_USE_PATH(rel, ParallelAppend)) { parallel_workers = Max(parallel_workers, pg_leftmost_one_pos32(list_length(live_childrels)) + 1); @@ -1547,7 +1548,7 @@ add_paths_to_append_rel(PlannerInfo *root, RelOptInfo *rel, /* Generate a partial append path. */ appendpath = create_append_path(root, rel, NIL, partial_subpaths, NIL, NULL, parallel_workers, - enable_parallel_append, + REL_CAN_USE_PATH(rel, ParallelAppend), -1); /* @@ -3259,7 +3260,8 @@ generate_useful_gather_paths(PlannerInfo *root, RelOptInfo *rel, bool override_r * input path). */ if (subpath != cheapest_partial_path && - (presorted_keys == 0 || !enable_incremental_sort)) + (presorted_keys == 0 || + !REL_CAN_USE_PATH(rel, IncrementalSort))) continue; /* @@ -3274,7 +3276,8 @@ generate_useful_gather_paths(PlannerInfo *root, RelOptInfo *rel, bool override_r * output. Here we add an explicit sort to match the useful * ordering. */ - if (presorted_keys == 0 || !enable_incremental_sort) + if (presorted_keys == 0 || + !REL_CAN_USE_PATH(rel, IncrementalSort)) { subpath = (Path *) create_sort_path(root, rel, diff --git a/src/backend/optimizer/path/costsize.c b/src/backend/optimizer/path/costsize.c index e1523d15df..3dfa22fdcd 100644 --- a/src/backend/optimizer/path/costsize.c +++ b/src/backend/optimizer/path/costsize.c @@ -163,6 +163,7 @@ bool enable_parallel_hash = true; bool enable_partition_pruning = true; bool enable_presorted_aggregate = true; bool enable_async_append = true; +uint32 default_path_type_mask = PathTypeMaskAll; typedef struct { @@ -283,6 +284,38 @@ clamp_cardinality_to_long(Cardinality x) return (x < (double) LONG_MAX) ? (long) x : LONG_MAX; } +/* + * Define assign hooks for each enable_ GUC that affects + * default_path_type_mask. These are all basically identical, so we use + * a templating macro to define them. + */ +#define define_assign_hook(gucname, type) \ + void \ + gucname ## _assign_hook(bool newval, void *extra) \ + { \ + if (newval) \ + default_path_type_mask |= PathType ## type; \ + else \ + default_path_type_mask &= ~(PathType ## type); \ + } +define_assign_hook(enable_bitmapscan, BitmapScan) +define_assign_hook(enable_gathermerge, GatherMerge) +define_assign_hook(enable_hashagg, HashAgg) +define_assign_hook(enable_hashjoin, HashJoin) +define_assign_hook(enable_incremental_sort, IncrementalSort) +define_assign_hook(enable_indexscan, IndexScan) +define_assign_hook(enable_indexonlyscan, IndexOnlyScan) +define_assign_hook(enable_material, Material) +define_assign_hook(enable_memoize, Memoize) +define_assign_hook(enable_mergejoin, MergeJoin) +define_assign_hook(enable_nestloop, NestLoop) +define_assign_hook(enable_parallel_append, ParallelAppend) +define_assign_hook(enable_parallel_hash, ParallelHash) +define_assign_hook(enable_partitionwise_join, PartitionwiseJoin) +define_assign_hook(enable_partitionwise_aggregate, PartitionwiseAggregate) +define_assign_hook(enable_seqscan, SeqScan) +define_assign_hook(enable_sort, Sort) +define_assign_hook(enable_tidscan, TIDScan) /* * cost_seqscan @@ -354,7 +387,7 @@ cost_seqscan(Path *path, PlannerInfo *root, path->rows = clamp_row_est(path->rows / parallel_divisor); } - path->disabled_nodes = enable_seqscan ? 0 : 1; + path->disabled_nodes = REL_CAN_USE_PATH(baserel, SeqScan) ? 0 : 1; path->startup_cost = startup_cost; path->total_cost = startup_cost + cpu_run_cost + disk_run_cost; } @@ -533,7 +566,7 @@ cost_gather_merge(GatherMergePath *path, PlannerInfo *root, run_cost += parallel_tuple_cost * path->path.rows * 1.05; path->path.disabled_nodes = input_disabled_nodes - + (enable_gathermerge ? 0 : 1); + + (REL_CAN_USE_PATH(rel, GatherMerge) ? 0 : 1); path->path.startup_cost = startup_cost + input_startup_cost; path->path.total_cost = (startup_cost + run_cost + input_total_cost); } @@ -615,7 +648,8 @@ cost_index(IndexPath *path, PlannerInfo *root, double loop_count, } /* we don't need to check enable_indexonlyscan; indxpath.c does that */ - path->path.disabled_nodes = enable_indexscan ? 0 : 1; + path->path.disabled_nodes = + REL_CAN_USE_PATH(baserel, IndexScan) ? 0 : 1; /* * Call index-access-method-specific code to estimate the processing cost @@ -1109,7 +1143,7 @@ cost_bitmap_heap_scan(Path *path, PlannerInfo *root, RelOptInfo *baserel, startup_cost += path->pathtarget->cost.startup; run_cost += path->pathtarget->cost.per_tuple * path->rows; - path->disabled_nodes = enable_bitmapscan ? 0 : 1; + path->disabled_nodes = REL_CAN_USE_PATH(baserel, BitmapScan) ? 0 : 1; path->startup_cost = startup_cost; path->total_cost = startup_cost + run_cost; } @@ -1287,10 +1321,11 @@ cost_tidscan(Path *path, PlannerInfo *root, /* * We must use a TID scan for CurrentOfExpr; in any other case, we - * should be generating a TID scan only if enable_tidscan=true. Also, - * if CurrentOfExpr is the qual, there should be only one. + * should be generating a TID scan only if this TID scans are enabled + * for this rel. Also, if CurrentOfExpr is the qual, there should be + * only one. */ - Assert(enable_tidscan || IsA(qual, CurrentOfExpr)); + Assert(REL_CAN_USE_PATH(baserel, TIDScan) || IsA(qual, CurrentOfExpr)); Assert(list_length(tidquals) == 1 || !IsA(qual, CurrentOfExpr)); if (IsA(qual, ScalarArrayOpExpr)) @@ -1342,8 +1377,8 @@ cost_tidscan(Path *path, PlannerInfo *root, /* * There are assertions above verifying that we only reach this function - * either when enable_tidscan=true or when the TID scan is the only legal - * path, so it's safe to set disabled_nodes to zero here. + * either when TID scans are enabled for this rel or when a TID scan is + * the only legal path, so it's safe to set disabled_nodes to zero here. */ path->disabled_nodes = 0; path->startup_cost = startup_cost; @@ -1438,8 +1473,8 @@ cost_tidrangescan(Path *path, PlannerInfo *root, startup_cost += path->pathtarget->cost.startup; run_cost += path->pathtarget->cost.per_tuple * path->rows; - /* we should not generate this path type when enable_tidscan=false */ - Assert(enable_tidscan); + /* we should not generate this path type when TID scans are disabled */ + Assert(REL_CAN_USE_PATH(baserel, TIDScan)); path->disabled_nodes = 0; path->startup_cost = startup_cost; path->total_cost = startup_cost + run_cost; @@ -2120,8 +2155,11 @@ cost_incremental_sort(Path *path, path->rows = input_tuples; - /* should not generate these paths when enable_incremental_sort=false */ - Assert(enable_incremental_sort); + /* + * If incremental sort is not enabled here, we should not have generated a + * path of this type. + */ + Assert(REL_CAN_USE_PATH(path->parent, IncrementalSort)); path->disabled_nodes = input_disabled_nodes; path->startup_cost = startup_cost; @@ -2141,7 +2179,7 @@ cost_incremental_sort(Path *path, * of sort keys, which all callers *could* supply.) */ void -cost_sort(Path *path, PlannerInfo *root, +cost_sort(Path *path, PlannerInfo *root, RelOptInfo *rel, List *pathkeys, int input_disabled_nodes, Cost input_cost, double tuples, int width, Cost comparison_cost, int sort_mem, @@ -2159,7 +2197,8 @@ cost_sort(Path *path, PlannerInfo *root, startup_cost += input_cost; path->rows = tuples; - path->disabled_nodes = input_disabled_nodes + (enable_sort ? 0 : 1); + path->disabled_nodes = input_disabled_nodes + + (REL_CAN_USE_PATH(rel, Sort) ? 0 : 1); path->startup_cost = startup_cost; path->total_cost = startup_cost + run_cost; } @@ -2321,6 +2360,7 @@ cost_append(AppendPath *apath) */ cost_sort(&sort_path, NULL, /* doesn't currently need root */ + apath->path.parent, pathkeys, subpath->disabled_nodes, subpath->total_cost, @@ -2480,7 +2520,7 @@ cost_merge_append(Path *path, PlannerInfo *root, * occur only on rescan, which is estimated in cost_rescan. */ void -cost_material(Path *path, +cost_material(Path *path, RelOptInfo *rel, int input_disabled_nodes, Cost input_startup_cost, Cost input_total_cost, double tuples, int width) @@ -2519,7 +2559,8 @@ cost_material(Path *path, run_cost += seq_page_cost * npages; } - path->disabled_nodes = input_disabled_nodes + (enable_material ? 0 : 1); + path->disabled_nodes = input_disabled_nodes + + (REL_CAN_USE_PATH(rel, Material) ? 0 : 1); path->startup_cost = startup_cost; path->total_cost = startup_cost + run_cost; } @@ -2679,7 +2720,7 @@ cost_memoize_rescan(PlannerInfo *root, MemoizePath *mpath, * are for appropriately-sorted input. */ void -cost_agg(Path *path, PlannerInfo *root, +cost_agg(Path *path, PlannerInfo *root, RelOptInfo *rel, AggStrategy aggstrategy, const AggClauseCosts *aggcosts, int numGroupCols, double numGroups, List *quals, @@ -2738,7 +2779,7 @@ cost_agg(Path *path, PlannerInfo *root, /* Here we are able to deliver output on-the-fly */ startup_cost = input_startup_cost; total_cost = input_total_cost; - if (aggstrategy == AGG_MIXED && !enable_hashagg) + if (aggstrategy == AGG_MIXED && !REL_CAN_USE_PATH(rel, HashAgg)) ++disabled_nodes; /* calcs phrased this way to match HASHED case, see note above */ total_cost += aggcosts->transCost.startup; @@ -2753,7 +2794,7 @@ cost_agg(Path *path, PlannerInfo *root, { /* must be AGG_HASHED */ startup_cost = input_total_cost; - if (!enable_hashagg) + if (!REL_CAN_USE_PATH(rel, HashAgg)) ++disabled_nodes; startup_cost += aggcosts->transCost.startup; startup_cost += aggcosts->transCost.per_tuple * input_tuples; @@ -3266,7 +3307,7 @@ cost_group(Path *path, PlannerInfo *root, */ void initial_cost_nestloop(PlannerInfo *root, JoinCostWorkspace *workspace, - JoinType jointype, + RelOptInfo *joinrel, JoinType jointype, Path *outer_path, Path *inner_path, JoinPathExtraData *extra) { @@ -3280,7 +3321,7 @@ initial_cost_nestloop(PlannerInfo *root, JoinCostWorkspace *workspace, Cost inner_rescan_run_cost; /* Count up disabled nodes. */ - disabled_nodes = enable_nestloop ? 0 : 1; + disabled_nodes = REL_CAN_USE_PATH(joinrel, NestLoop) ? 0 : 1; disabled_nodes += inner_path->disabled_nodes; disabled_nodes += outer_path->disabled_nodes; @@ -3549,7 +3590,7 @@ final_cost_nestloop(PlannerInfo *root, NestPath *path, */ void initial_cost_mergejoin(PlannerInfo *root, JoinCostWorkspace *workspace, - JoinType jointype, + RelOptInfo *joinrel, JoinType jointype, List *mergeclauses, Path *outer_path, Path *inner_path, List *outersortkeys, List *innersortkeys, @@ -3676,7 +3717,7 @@ initial_cost_mergejoin(PlannerInfo *root, JoinCostWorkspace *workspace, Assert(outerstartsel <= outerendsel); Assert(innerstartsel <= innerendsel); - disabled_nodes = enable_mergejoin ? 0 : 1; + disabled_nodes = REL_CAN_USE_PATH(joinrel, MergeJoin) ? 0 : 1; /* cost of source data */ @@ -3684,6 +3725,7 @@ initial_cost_mergejoin(PlannerInfo *root, JoinCostWorkspace *workspace, { cost_sort(&sort_path, root, + outer_path->parent, outersortkeys, outer_path->disabled_nodes, outer_path->total_cost, @@ -3713,6 +3755,7 @@ initial_cost_mergejoin(PlannerInfo *root, JoinCostWorkspace *workspace, { cost_sort(&sort_path, root, + inner_path->parent, innersortkeys, inner_path->disabled_nodes, inner_path->total_cost, @@ -3793,6 +3836,7 @@ final_cost_mergejoin(PlannerInfo *root, MergePath *path, JoinCostWorkspace *workspace, JoinPathExtraData *extra) { + RelOptInfo *joinrel = path->jpath.path.parent; Path *outer_path = path->jpath.outerjoinpath; Path *inner_path = path->jpath.innerjoinpath; double inner_path_rows = inner_path->rows; @@ -3946,7 +3990,8 @@ final_cost_mergejoin(PlannerInfo *root, MergePath *path, * Prefer materializing if it looks cheaper, unless the user has asked to * suppress materialization. */ - else if (enable_material && mat_inner_cost < bare_inner_cost) + else if (REL_CAN_USE_PATH(joinrel, Material) && + mat_inner_cost < bare_inner_cost) path->materialize_inner = true; /* @@ -3961,7 +4006,7 @@ final_cost_mergejoin(PlannerInfo *root, MergePath *path, * selected as the input of a mergejoin, and they don't support * mark/restore at present. * - * We don't test the value of enable_material here, because + * We don't test whether a MaterialPath is allowed here, because * materialization is required for correctness in this case, and turning * it off does not entitle us to deliver an invalid plan. */ @@ -3977,10 +4022,10 @@ final_cost_mergejoin(PlannerInfo *root, MergePath *path, * though. * * Since materialization is a performance optimization in this case, - * rather than necessary for correctness, we skip it if enable_material is - * off. + * rather than necessary for correctness, we skip it if MaterialPath is + * not allowed here. */ - else if (enable_material && innersortkeys != NIL && + else if (REL_CAN_USE_PATH(joinrel, Material) && innersortkeys != NIL && relation_byte_size(inner_path_rows, inner_path->pathtarget->width) > (work_mem * 1024L)) @@ -4113,7 +4158,7 @@ cached_scansel(PlannerInfo *root, RestrictInfo *rinfo, PathKey *pathkey) */ void initial_cost_hashjoin(PlannerInfo *root, JoinCostWorkspace *workspace, - JoinType jointype, + RelOptInfo *joinrel, JoinType jointype, List *hashclauses, Path *outer_path, Path *inner_path, JoinPathExtraData *extra, @@ -4132,7 +4177,7 @@ initial_cost_hashjoin(PlannerInfo *root, JoinCostWorkspace *workspace, size_t space_allowed; /* unused */ /* Count up disabled nodes. */ - disabled_nodes = enable_hashjoin ? 0 : 1; + disabled_nodes = REL_CAN_USE_PATH(joinrel, HashJoin) ? 0 : 1; disabled_nodes += inner_path->disabled_nodes; disabled_nodes += outer_path->disabled_nodes; diff --git a/src/backend/optimizer/path/indxpath.c b/src/backend/optimizer/path/indxpath.c index c0fcc7d78d..be183db4ce 100644 --- a/src/backend/optimizer/path/indxpath.c +++ b/src/backend/optimizer/path/indxpath.c @@ -1736,7 +1736,7 @@ check_index_only(RelOptInfo *rel, IndexOptInfo *index) int i; /* Index-only scans must be enabled */ - if (!enable_indexonlyscan) + if (!REL_CAN_USE_PATH(rel, IndexOnlyScan)) return false; /* diff --git a/src/backend/optimizer/path/joinpath.c b/src/backend/optimizer/path/joinpath.c index b0e8c94dfc..5f0040cd1b 100644 --- a/src/backend/optimizer/path/joinpath.c +++ b/src/backend/optimizer/path/joinpath.c @@ -205,10 +205,10 @@ add_paths_to_joinrel(PlannerInfo *root, /* * Find potential mergejoin clauses. We can skip this if we are not * interested in doing a mergejoin. However, mergejoin may be our only - * way of implementing a full outer join, so override enable_mergejoin if - * it's a full join. + * way of implementing a full outer join, so disregard the result of + * REL_CAN_USE_PATH() if it's a full join. */ - if (enable_mergejoin || jointype == JOIN_FULL) + if (REL_CAN_USE_PATH(joinrel, MergeJoin) || jointype == JOIN_FULL) extra.mergeclause_list = select_mergejoin_clauses(root, joinrel, outerrel, @@ -316,10 +316,11 @@ add_paths_to_joinrel(PlannerInfo *root, /* * 4. Consider paths where both outer and inner relations must be hashed - * before being joined. As above, disregard enable_hashjoin for full - * joins, because there may be no other alternative. + * before being joined. As above, the result of REL_CAN_USE_PATH() + * doesn't matter for full joins, because there may be no other + * alternative. */ - if (enable_hashjoin || jointype == JOIN_FULL) + if (REL_CAN_USE_PATH(joinrel, HashJoin) || jointype == JOIN_FULL) hash_inner_and_outer(root, joinrel, outerrel, innerrel, jointype, &extra); @@ -672,7 +673,7 @@ extract_lateral_vars_from_PHVs(PlannerInfo *root, Relids innerrelids) * we do not have a way to extract cache keys from joinrels. */ static Path * -get_memoize_path(PlannerInfo *root, RelOptInfo *innerrel, +get_memoize_path(PlannerInfo *root, RelOptInfo *joinrel, RelOptInfo *innerrel, RelOptInfo *outerrel, Path *inner_path, Path *outer_path, JoinType jointype, JoinPathExtraData *extra) @@ -684,7 +685,7 @@ get_memoize_path(PlannerInfo *root, RelOptInfo *innerrel, List *ph_lateral_vars; /* Obviously not if it's disabled */ - if (!enable_memoize) + if (!REL_CAN_USE_PATH(joinrel, Memoize)) return NULL; /* @@ -912,7 +913,7 @@ try_nestloop_path(PlannerInfo *root, * The latter two steps are expensive enough to make this two-phase * methodology worthwhile. */ - initial_cost_nestloop(root, &workspace, jointype, + initial_cost_nestloop(root, &workspace, joinrel, jointype, outer_path, inner_path, extra); if (add_path_precheck(joinrel, workspace.disabled_nodes, @@ -997,7 +998,7 @@ try_partial_nestloop_path(PlannerInfo *root, * Before creating a path, get a quick lower bound on what it is likely to * cost. Bail out right away if it looks terrible. */ - initial_cost_nestloop(root, &workspace, jointype, + initial_cost_nestloop(root, &workspace, joinrel, jointype, outer_path, inner_path, extra); if (!add_partial_path_precheck(joinrel, workspace.disabled_nodes, workspace.total_cost, pathkeys)) @@ -1092,7 +1093,7 @@ try_mergejoin_path(PlannerInfo *root, /* * See comments in try_nestloop_path(). */ - initial_cost_mergejoin(root, &workspace, jointype, mergeclauses, + initial_cost_mergejoin(root, &workspace, joinrel, jointype, mergeclauses, outer_path, inner_path, outersortkeys, innersortkeys, extra); @@ -1164,7 +1165,7 @@ try_partial_mergejoin_path(PlannerInfo *root, /* * See comments in try_partial_nestloop_path(). */ - initial_cost_mergejoin(root, &workspace, jointype, mergeclauses, + initial_cost_mergejoin(root, &workspace, joinrel, jointype, mergeclauses, outer_path, inner_path, outersortkeys, innersortkeys, extra); @@ -1236,7 +1237,7 @@ try_hashjoin_path(PlannerInfo *root, * See comments in try_nestloop_path(). Also note that hashjoin paths * never have any output pathkeys, per comments in create_hashjoin_path. */ - initial_cost_hashjoin(root, &workspace, jointype, hashclauses, + initial_cost_hashjoin(root, &workspace, joinrel, jointype, hashclauses, outer_path, inner_path, extra, false); if (add_path_precheck(joinrel, workspace.disabled_nodes, @@ -1298,7 +1299,7 @@ try_partial_hashjoin_path(PlannerInfo *root, * Before creating a path, get a quick lower bound on what it is likely to * cost. Bail out right away if it looks terrible. */ - initial_cost_hashjoin(root, &workspace, jointype, hashclauses, + initial_cost_hashjoin(root, &workspace, joinrel, jointype, hashclauses, outer_path, inner_path, extra, parallel_hash); if (!add_partial_path_precheck(joinrel, workspace.disabled_nodes, workspace.total_cost, NIL)) @@ -1899,10 +1900,11 @@ match_unsorted_outer(PlannerInfo *root, { /* * Consider materializing the cheapest inner path, unless - * enable_material is off or the path in question materializes its - * output anyway. + * materialization is disabled or the path in question materializes + * its output anyway. */ - if (enable_material && inner_cheapest_total != NULL && + if (REL_CAN_USE_PATH(innerrel, Material) && + inner_cheapest_total != NULL && !ExecMaterializesOutput(inner_cheapest_total->pathtype)) matpath = (Path *) create_material_path(innerrel, inner_cheapest_total); @@ -1982,7 +1984,7 @@ match_unsorted_outer(PlannerInfo *root, * Try generating a memoize path and see if that makes the * nested loop any cheaper. */ - mpath = get_memoize_path(root, innerrel, outerrel, + mpath = get_memoize_path(root, joinrel, innerrel, outerrel, innerpath, outerpath, jointype, extra); if (mpath != NULL) @@ -2134,13 +2136,14 @@ consider_parallel_nestloop(PlannerInfo *root, /* * Consider materializing the cheapest inner path, unless: 1) we're doing * JOIN_UNIQUE_INNER, because in this case we have to unique-ify the - * cheapest inner path, 2) enable_material is off, 3) the cheapest inner - * path is not parallel-safe, 4) the cheapest inner path is parameterized - * by the outer rel, or 5) the cheapest inner path materializes its output - * anyway. + * cheapest inner path, 2) MaterialPath is allowed for this rel, 3) the + * cheapest inner path is not parallel-safe, 4) the cheapest inner path is + * parameterized by the outer rel, or 5) the cheapest inner path + * materializes its output anyway. */ if (save_jointype != JOIN_UNIQUE_INNER && - enable_material && inner_cheapest_total->parallel_safe && + REL_CAN_USE_PATH(joinrel, Material) && + inner_cheapest_total->parallel_safe && !PATH_PARAM_BY_REL(inner_cheapest_total, outerrel) && !ExecMaterializesOutput(inner_cheapest_total->pathtype)) { @@ -2198,7 +2201,7 @@ consider_parallel_nestloop(PlannerInfo *root, * Try generating a memoize path and see if that makes the nested * loop any cheaper. */ - mpath = get_memoize_path(root, innerrel, outerrel, + mpath = get_memoize_path(root, joinrel, innerrel, outerrel, innerpath, outerpath, jointype, extra); if (mpath != NULL) @@ -2416,7 +2419,7 @@ hash_inner_and_outer(PlannerInfo *root, */ if (innerrel->partial_pathlist != NIL && save_jointype != JOIN_UNIQUE_INNER && - enable_parallel_hash) + REL_CAN_USE_PATH(joinrel, ParallelHash)) { cheapest_partial_inner = (Path *) linitial(innerrel->partial_pathlist); diff --git a/src/backend/optimizer/path/pathkeys.c b/src/backend/optimizer/path/pathkeys.c index e25798972f..26a0f5c0c3 100644 --- a/src/backend/optimizer/path/pathkeys.c +++ b/src/backend/optimizer/path/pathkeys.c @@ -505,7 +505,8 @@ get_useful_group_keys_orderings(PlannerInfo *root, Path *path) root->num_groupby_pathkeys); if (n > 0 && - (enable_incremental_sort || n == root->num_groupby_pathkeys) && + (REL_CAN_USE_PATH(path->parent, IncrementalSort) || + n == root->num_groupby_pathkeys) && compare_pathkeys(pathkeys, root->group_pathkeys) != PATHKEYS_EQUAL) { info = makeNode(GroupByOrdering); diff --git a/src/backend/optimizer/path/tidpath.c b/src/backend/optimizer/path/tidpath.c index b0323b26ec..ed447916ec 100644 --- a/src/backend/optimizer/path/tidpath.c +++ b/src/backend/optimizer/path/tidpath.c @@ -505,13 +505,14 @@ create_tidscan_paths(PlannerInfo *root, RelOptInfo *rel) * If any suitable quals exist in the rel's baserestrict list, generate a * plain (unparameterized) TidPath with them. * - * We skip this when enable_tidscan = false, except when the qual is - * CurrentOfExpr. In that case, a TID scan is the only correct path. + * We skip this when TID scans are disabled for this rel, except when + * the qual is CurrentOfExpr. In that case, a TID scan is the only + * correct path. */ tidquals = TidQualFromRestrictInfoList(root, rel->baserestrictinfo, rel, &isCurrentOf); - if (tidquals != NIL && (enable_tidscan || isCurrentOf)) + if (tidquals != NIL && (REL_CAN_USE_PATH(rel, TIDScan) || isCurrentOf)) { /* * This path uses no join clauses, but it could still have required @@ -532,8 +533,8 @@ create_tidscan_paths(PlannerInfo *root, RelOptInfo *rel) return true; } - /* Skip the rest if TID scans are disabled. */ - if (!enable_tidscan) + /* Skip the rest if TID scans are disabled for this rel. */ + if (!REL_CAN_USE_PATH(rel, TIDScan)) return false; /* diff --git a/src/backend/optimizer/plan/createplan.c b/src/backend/optimizer/plan/createplan.c index 8e0e5977a9..3f3770bfa7 100644 --- a/src/backend/optimizer/plan/createplan.c +++ b/src/backend/optimizer/plan/createplan.c @@ -177,8 +177,8 @@ static List *get_switched_clauses(List *clauses, Relids outerrelids); static List *order_qual_clauses(PlannerInfo *root, List *clauses); static void copy_generic_path_info(Plan *dest, Path *src); static void copy_plan_costsize(Plan *dest, Plan *src); -static void label_sort_with_costsize(PlannerInfo *root, Sort *plan, - double limit_tuples); +static void label_sort_with_costsize(PlannerInfo *root, RelOptInfo *rel, + Sort *plan, double limit_tuples); static SeqScan *make_seqscan(List *qptlist, List *qpqual, Index scanrelid); static SampleScan *make_samplescan(List *qptlist, List *qpqual, Index scanrelid, TableSampleClause *tsc); @@ -1361,7 +1361,8 @@ create_append_plan(PlannerInfo *root, AppendPath *best_path, int flags) sortColIdx, sortOperators, collations, nullsFirst); - label_sort_with_costsize(root, sort, best_path->limit_tuples); + label_sort_with_costsize(root, rel, sort, + best_path->limit_tuples); subplan = (Plan *) sort; } } @@ -1533,7 +1534,7 @@ create_merge_append_plan(PlannerInfo *root, MergeAppendPath *best_path, sortColIdx, sortOperators, collations, nullsFirst); - label_sort_with_costsize(root, sort, best_path->limit_tuples); + label_sort_with_costsize(root, rel, sort, best_path->limit_tuples); subplan = (Plan *) sort; } @@ -1900,7 +1901,7 @@ create_unique_plan(PlannerInfo *root, UniquePath *best_path, int flags) groupColPos++; } sort = make_sort_from_sortclauses(sortList, subplan); - label_sort_with_costsize(root, sort, -1.0); + label_sort_with_costsize(root, best_path->path.parent, sort, -1.0); plan = (Plan *) make_unique_from_sortclauses((Plan *) sort, sortList); } @@ -4527,7 +4528,8 @@ create_mergejoin_plan(PlannerInfo *root, best_path->outersortkeys, outer_relids); - label_sort_with_costsize(root, sort, -1.0); + label_sort_with_costsize(root, best_path->jpath.path.parent, + sort, -1.0); outer_plan = (Plan *) sort; outerpathkeys = best_path->outersortkeys; } @@ -4541,7 +4543,8 @@ create_mergejoin_plan(PlannerInfo *root, best_path->innersortkeys, inner_relids); - label_sort_with_costsize(root, sort, -1.0); + label_sort_with_costsize(root, best_path->jpath.path.parent, + sort, -1.0); inner_plan = (Plan *) sort; innerpathkeys = best_path->innersortkeys; } @@ -5442,7 +5445,8 @@ copy_plan_costsize(Plan *dest, Plan *src) * limit_tuples is as for cost_sort (in particular, pass -1 if no limit) */ static void -label_sort_with_costsize(PlannerInfo *root, Sort *plan, double limit_tuples) +label_sort_with_costsize(PlannerInfo *root, RelOptInfo *rel, Sort *plan, + double limit_tuples) { Plan *lefttree = plan->plan.lefttree; Path sort_path; /* dummy for result of cost_sort */ @@ -5453,7 +5457,7 @@ label_sort_with_costsize(PlannerInfo *root, Sort *plan, double limit_tuples) */ Assert(IsA(plan, Sort)); - cost_sort(&sort_path, root, NIL, + cost_sort(&sort_path, root, rel, NIL, lefttree->total_cost, plan->plan.disabled_nodes, lefttree->plan_rows, @@ -6524,7 +6528,7 @@ make_material(Plan *lefttree) * Path representation, but it's not worth the trouble yet. */ Plan * -materialize_finished_plan(Plan *subplan) +materialize_finished_plan(Plan *subplan, RelOptInfo *rel) { Plan *matplan; Path matpath; /* dummy for result of cost_material */ @@ -6549,7 +6553,7 @@ materialize_finished_plan(Plan *subplan) subplan->total_cost -= initplan_cost; /* Set cost data */ - cost_material(&matpath, + cost_material(&matpath, rel, subplan->disabled_nodes, subplan->startup_cost, subplan->total_cost, diff --git a/src/backend/optimizer/plan/planner.c b/src/backend/optimizer/plan/planner.c index b5827d3980..c0f431cf0d 100644 --- a/src/backend/optimizer/plan/planner.c +++ b/src/backend/optimizer/plan/planner.c @@ -427,7 +427,7 @@ standard_planner(Query *parse, const char *query_string, int cursorOptions, if (cursorOptions & CURSOR_OPT_SCROLL) { if (!ExecSupportsBackwardScan(top_plan)) - top_plan = materialize_finished_plan(top_plan); + top_plan = materialize_finished_plan(top_plan, final_rel); } /* @@ -3831,7 +3831,8 @@ create_grouping_paths(PlannerInfo *root, * support grouping sets. create_ordinary_grouping_paths() will check * additional conditions, such as whether input_rel is partitioned. */ - if (enable_partitionwise_aggregate && !parse->groupingSets) + if (REL_CAN_USE_PATH(grouped_rel, PartitionwiseAggregate) && + !parse->groupingSets) extra.patype = PARTITIONWISE_AGGREGATE_FULL; else extra.patype = PARTITIONWISE_AGGREGATE_NONE; @@ -4634,7 +4635,8 @@ create_one_window_path(PlannerInfo *root, * No presorted keys or incremental sort disabled, just perform a * complete sort. */ - if (presorted_keys == 0 || !enable_incremental_sort) + if (presorted_keys == 0 || + !REL_CAN_USE_PATH(window_rel, IncrementalSort)) path = (Path *) create_sort_path(root, window_rel, path, window_pathkeys, @@ -4893,7 +4895,8 @@ create_partial_distinct_paths(PlannerInfo *root, RelOptInfo *input_rel, * cheapest partial path). */ if (input_path != cheapest_partial_path && - (presorted_keys == 0 || !enable_incremental_sort)) + (presorted_keys == 0 || + !REL_CAN_USE_PATH(partial_distinct_rel, IncrementalSort))) continue; /* @@ -4901,7 +4904,8 @@ create_partial_distinct_paths(PlannerInfo *root, RelOptInfo *input_rel, * We'll just do a sort if there are no presorted keys and an * incremental sort when there are presorted keys. */ - if (presorted_keys == 0 || !enable_incremental_sort) + if (presorted_keys == 0 || + !REL_CAN_USE_PATH(partial_distinct_rel, IncrementalSort)) sorted_path = (Path *) create_sort_path(root, partial_distinct_rel, input_path, @@ -4961,10 +4965,12 @@ create_partial_distinct_paths(PlannerInfo *root, RelOptInfo *input_rel, /* * Now try hash aggregate paths, if enabled and hashing is possible. Since * we're not on the hook to ensure we do our best to create at least one - * path here, we treat enable_hashagg as a hard off-switch rather than the - * slightly softer variant in create_final_distinct_paths. + * path here, we treat completely skip this if hash aggregation is not + * enabled. (In contrast, create_final_distinct_paths sometimes considers + * hash aggregation even when it's disabled, to avoid failing completely.) */ - if (enable_hashagg && grouping_is_hashable(root->processed_distinctClause)) + if (REL_CAN_USE_PATH(partial_distinct_rel, HashAgg) && + grouping_is_hashable(root->processed_distinctClause)) { add_partial_path(partial_distinct_rel, (Path *) create_agg_path(root, @@ -5105,7 +5111,8 @@ create_final_distinct_paths(PlannerInfo *root, RelOptInfo *input_rel, * cheapest input path). */ if (input_path != cheapest_input_path && - (presorted_keys == 0 || !enable_incremental_sort)) + (presorted_keys == 0 || + !REL_CAN_USE_PATH(distinct_rel, IncrementalSort))) continue; /* @@ -5113,7 +5120,8 @@ create_final_distinct_paths(PlannerInfo *root, RelOptInfo *input_rel, * We'll just do a sort if there are no presorted keys and an * incremental sort when there are presorted keys. */ - if (presorted_keys == 0 || !enable_incremental_sort) + if (presorted_keys == 0 || + !REL_CAN_USE_PATH(distinct_rel, IncrementalSort)) sorted_path = (Path *) create_sort_path(root, distinct_rel, input_path, @@ -5177,14 +5185,14 @@ create_final_distinct_paths(PlannerInfo *root, RelOptInfo *input_rel, * die trying. If we do have other choices, there are two things that * should prevent selection of hashing: if the query uses DISTINCT ON * (because it won't really have the expected behavior if we hash), or if - * enable_hashagg is off. + * hash aggregation is disabled. * * Note: grouping_is_hashable() is much more expensive to check than the * other gating conditions, so we want to do it last. */ if (distinct_rel->pathlist == NIL) allow_hash = true; /* we have no alternatives */ - else if (parse->hasDistinctOn || !enable_hashagg) + else if (parse->hasDistinctOn || !REL_CAN_USE_PATH(distinct_rel, HashAgg)) allow_hash = false; /* policy-based decision not to hash */ else allow_hash = true; /* default */ @@ -5277,7 +5285,8 @@ create_ordered_paths(PlannerInfo *root, * input path). */ if (input_path != cheapest_input_path && - (presorted_keys == 0 || !enable_incremental_sort)) + (presorted_keys == 0 || + !REL_CAN_USE_PATH(ordered_rel, IncrementalSort))) continue; /* @@ -5285,7 +5294,8 @@ create_ordered_paths(PlannerInfo *root, * We'll just do a sort if there are no presorted keys and an * incremental sort when there are presorted keys. */ - if (presorted_keys == 0 || !enable_incremental_sort) + if (presorted_keys == 0 || + !REL_CAN_USE_PATH(ordered_rel, IncrementalSort)) sorted_path = (Path *) create_sort_path(root, ordered_rel, input_path, @@ -5349,7 +5359,8 @@ create_ordered_paths(PlannerInfo *root, * partial path). */ if (input_path != cheapest_partial_path && - (presorted_keys == 0 || !enable_incremental_sort)) + (presorted_keys == 0 || + !REL_CAN_USE_PATH(ordered_rel, IncrementalSort))) continue; /* @@ -5357,7 +5368,8 @@ create_ordered_paths(PlannerInfo *root, * We'll just do a sort if there are no presorted keys and an * incremental sort when there are presorted keys. */ - if (presorted_keys == 0 || !enable_incremental_sort) + if (presorted_keys == 0 || + !REL_CAN_USE_PATH(ordered_rel, IncrementalSort)) sorted_path = (Path *) create_sort_path(root, ordered_rel, input_path, @@ -6747,7 +6759,7 @@ plan_cluster_use_sort(Oid tableOid, Oid indexOid) /* Estimate the cost of seq scan + sort */ seqScanPath = create_seqscan_path(root, rel, NULL, 0); - cost_sort(&seqScanAndSortPath, root, NIL, + cost_sort(&seqScanAndSortPath, root, rel, NIL, seqScanPath->disabled_nodes, seqScanPath->total_cost, rel->tuples, rel->reltarget->width, comparisonCost, maintenance_work_mem, -1.0); @@ -6931,7 +6943,8 @@ make_ordered_path(PlannerInfo *root, RelOptInfo *rel, Path *path, * disabled unless it's the cheapest input path). */ if (path != cheapest_path && - (presorted_keys == 0 || !enable_incremental_sort)) + (presorted_keys == 0 || + !REL_CAN_USE_PATH(rel, IncrementalSort))) return NULL; /* @@ -6939,7 +6952,8 @@ make_ordered_path(PlannerInfo *root, RelOptInfo *rel, Path *path, * just do a sort if there are no presorted keys and an incremental * sort when there are presorted keys. */ - if (presorted_keys == 0 || !enable_incremental_sort) + if (presorted_keys == 0 || + !REL_CAN_USE_PATH(rel, IncrementalSort)) path = (Path *) create_sort_path(root, rel, path, @@ -7540,7 +7554,8 @@ gather_grouping_paths(PlannerInfo *root, RelOptInfo *rel) * disabled unless it's the cheapest input path). */ if (path != cheapest_partial_path && - (presorted_keys == 0 || !enable_incremental_sort)) + (presorted_keys == 0 || + !REL_CAN_USE_PATH(rel, IncrementalSort))) continue; /* @@ -7548,7 +7563,8 @@ gather_grouping_paths(PlannerInfo *root, RelOptInfo *rel) * just do a sort if there are no presorted keys and an incremental * sort when there are presorted keys. */ - if (presorted_keys == 0 || !enable_incremental_sort) + if (presorted_keys == 0 || + !REL_CAN_USE_PATH(rel, IncrementalSort)) path = (Path *) create_sort_path(root, rel, path, groupby_pathkeys, -1.0); diff --git a/src/backend/optimizer/plan/subselect.c b/src/backend/optimizer/plan/subselect.c index 6d003cc8e5..6dbcf6e0aa 100644 --- a/src/backend/optimizer/plan/subselect.c +++ b/src/backend/optimizer/plan/subselect.c @@ -525,13 +525,14 @@ build_subplan(PlannerInfo *root, Plan *plan, Path *path, * is pointless for a direct-correlated subplan, since we'd have to * recompute its results each time anyway. For uncorrelated/undirect * correlated subplans, we add Material unless the subplan's top plan - * node would materialize its output anyway. Also, if enable_material - * is false, then the user does not want us to materialize anything + * node would materialize its output anyway. Also, if Materialize is + * dissabled, then the user does not want us to materialize anything * unnecessarily, so we don't. */ - else if (splan->parParam == NIL && enable_material && + else if (splan->parParam == NIL && + REL_CAN_USE_PATH(path->parent, Material) && !ExecMaterializesOutput(nodeTag(plan))) - plan = materialize_finished_plan(plan); + plan = materialize_finished_plan(plan, path->parent); result = (Node *) splan; isInitPlan = false; diff --git a/src/backend/optimizer/prep/prepunion.c b/src/backend/optimizer/prep/prepunion.c index a0baf6d4a1..f8fd5db66b 100644 --- a/src/backend/optimizer/prep/prepunion.c +++ b/src/backend/optimizer/prep/prepunion.c @@ -587,7 +587,8 @@ build_setop_child_paths(PlannerInfo *root, RelOptInfo *rel, * input path). */ if (subpath != cheapest_input_path && - (presorted_keys == 0 || !enable_incremental_sort)) + (presorted_keys == 0 || + !REL_CAN_USE_PATH(final_rel, IncrementalSort))) continue; /* @@ -595,7 +596,8 @@ build_setop_child_paths(PlannerInfo *root, RelOptInfo *rel, * We'll just do a sort if there are no presorted keys and an * incremental sort when there are presorted keys. */ - if (presorted_keys == 0 || !enable_incremental_sort) + if (presorted_keys == 0 || + !REL_CAN_USE_PATH(final_rel, IncrementalSort)) subpath = (Path *) create_sort_path(rel->subroot, final_rel, subpath, @@ -867,7 +869,7 @@ generate_union_paths(SetOperationStmt *op, PlannerInfo *root, * the children. The precise formula is just a guess; see * add_paths_to_append_rel. */ - if (enable_parallel_append) + if (REL_CAN_USE_PATH(result_rel, ParallelAppend)) { parallel_workers = Max(parallel_workers, pg_leftmost_one_pos32(list_length(partial_pathlist)) + 1); @@ -879,7 +881,8 @@ generate_union_paths(SetOperationStmt *op, PlannerInfo *root, papath = (Path *) create_append_path(root, result_rel, NIL, partial_pathlist, NIL, NULL, parallel_workers, - enable_parallel_append, -1); + REL_CAN_USE_PATH(result_rel, ParallelAppend), + -1); gpath = (Path *) create_gather_path(root, result_rel, papath, result_rel->reltarget, NULL, NULL); @@ -1319,8 +1322,8 @@ choose_hashed_setop(PlannerInfo *root, List *groupClauses, errmsg("could not implement %s", construct), errdetail("Some of the datatypes only support hashing, while others only support sorting."))); - /* Prefer sorting when enable_hashagg is off */ - if (!enable_hashagg) + /* Prefer sorting when hash aggregation is disabled */ + if (!REL_CAN_USE_PATH(input_path->parent, HashAgg)) return false; /* @@ -1343,7 +1346,7 @@ choose_hashed_setop(PlannerInfo *root, List *groupClauses, * These path variables are dummies that just hold cost fields; we don't * make actual Paths for these steps. */ - cost_agg(&hashed_p, root, AGG_HASHED, NULL, + cost_agg(&hashed_p, root, input_path->parent, AGG_HASHED, NULL, numGroupCols, dNumGroups, NIL, input_path->disabled_nodes, @@ -1358,7 +1361,8 @@ choose_hashed_setop(PlannerInfo *root, List *groupClauses, sorted_p.startup_cost = input_path->startup_cost; sorted_p.total_cost = input_path->total_cost; /* XXX cost_sort doesn't actually look at pathkeys, so just pass NIL */ - cost_sort(&sorted_p, root, NIL, sorted_p.disabled_nodes, + cost_sort(&sorted_p, root, input_path->parent, NIL, + sorted_p.disabled_nodes, sorted_p.total_cost, input_path->rows, input_path->pathtarget->width, 0.0, work_mem, -1.0); diff --git a/src/backend/optimizer/util/pathnode.c b/src/backend/optimizer/util/pathnode.c index fc97bf6ee2..77ed747437 100644 --- a/src/backend/optimizer/util/pathnode.c +++ b/src/backend/optimizer/util/pathnode.c @@ -1537,6 +1537,7 @@ create_merge_append_path(PlannerInfo *root, cost_sort(&sort_path, root, + rel, pathkeys, subpath->disabled_nodes, subpath->total_cost, @@ -1649,7 +1650,7 @@ create_material_path(RelOptInfo *rel, Path *subpath) pathnode->subpath = subpath; - cost_material(&pathnode->path, + cost_material(&pathnode->path, rel, subpath->disabled_nodes, subpath->startup_cost, subpath->total_cost, @@ -1698,7 +1699,7 @@ create_memoize_path(PlannerInfo *root, RelOptInfo *rel, Path *subpath, pathnode->est_entries = 0; /* we should not generate this path type when enable_memoize=false */ - Assert(enable_memoize); + Assert(REL_CAN_USE_PATH(rel, Memoize)); pathnode->path.disabled_nodes = subpath->disabled_nodes; /* @@ -1866,7 +1867,7 @@ create_unique_path(PlannerInfo *root, RelOptInfo *rel, Path *subpath, /* * Estimate cost for sort+unique implementation */ - cost_sort(&sort_path, root, NIL, + cost_sort(&sort_path, root, rel, NIL, subpath->disabled_nodes, subpath->total_cost, rel->rows, @@ -1901,7 +1902,7 @@ create_unique_path(PlannerInfo *root, RelOptInfo *rel, Path *subpath, sjinfo->semi_can_hash = false; } else - cost_agg(&agg_path, root, + cost_agg(&agg_path, root, rel, AGG_HASHED, NULL, numCols, pathnode->path.rows, NIL, @@ -3101,7 +3102,7 @@ create_sort_path(PlannerInfo *root, pathnode->subpath = subpath; - cost_sort(&pathnode->path, root, pathkeys, + cost_sort(&pathnode->path, root, rel, pathkeys, subpath->disabled_nodes, subpath->total_cost, subpath->rows, @@ -3288,7 +3289,7 @@ create_agg_path(PlannerInfo *root, pathnode->groupClause = groupClause; pathnode->qual = qual; - cost_agg(&pathnode->path, root, + cost_agg(&pathnode->path, root, rel, aggstrategy, aggcosts, list_length(groupClause), numGroups, qual, @@ -3395,7 +3396,7 @@ create_groupingsets_path(PlannerInfo *root, */ if (is_first) { - cost_agg(&pathnode->path, root, + cost_agg(&pathnode->path, root, rel, aggstrategy, agg_costs, numGroupCols, @@ -3421,7 +3422,7 @@ create_groupingsets_path(PlannerInfo *root, * Account for cost of aggregation, but don't charge input * cost again */ - cost_agg(&agg_path, root, + cost_agg(&agg_path, root, rel, rollup->is_hashed ? AGG_HASHED : AGG_SORTED, agg_costs, numGroupCols, @@ -3436,7 +3437,7 @@ create_groupingsets_path(PlannerInfo *root, else { /* Account for cost of sort, but don't charge input cost again */ - cost_sort(&sort_path, root, NIL, 0, + cost_sort(&sort_path, root, rel, NIL, 0, 0.0, subpath->rows, subpath->pathtarget->width, @@ -3446,7 +3447,7 @@ create_groupingsets_path(PlannerInfo *root, /* Account for cost of aggregation */ - cost_agg(&agg_path, root, + cost_agg(&agg_path, root, rel, AGG_SORTED, agg_costs, numGroupCols, diff --git a/src/backend/optimizer/util/plancat.c b/src/backend/optimizer/util/plancat.c index 78a3cfafde..3b9a3746ee 100644 --- a/src/backend/optimizer/util/plancat.c +++ b/src/backend/optimizer/util/plancat.c @@ -570,7 +570,8 @@ get_relation_info(PlannerInfo *root, Oid relationObjectId, bool inhparent, /* * Allow a plugin to editorialize on the info we obtained from the * catalogs. Actions might include altering the assumed relation size, - * removing an index, or adding a hypothetical index to the indexlist. + * removing an index, adding a hypothetical index to the indexlist, or + * changing the path type mask. */ if (get_relation_info_hook) (*get_relation_info_hook) (root, relationObjectId, inhparent, rel); diff --git a/src/backend/optimizer/util/relnode.c b/src/backend/optimizer/util/relnode.c index d7266e4cdb..88e468795a 100644 --- a/src/backend/optimizer/util/relnode.c +++ b/src/backend/optimizer/util/relnode.c @@ -211,6 +211,7 @@ build_simple_rel(PlannerInfo *root, int relid, RelOptInfo *parent) rel->consider_startup = (root->tuple_fraction > 0); rel->consider_param_startup = false; /* might get changed later */ rel->consider_parallel = false; /* might get changed later */ + rel->path_type_mask = default_path_type_mask; rel->reltarget = create_empty_pathtarget(); rel->pathlist = NIL; rel->ppilist = NIL; @@ -707,6 +708,7 @@ build_join_rel(PlannerInfo *root, joinrel->consider_startup = (root->tuple_fraction > 0); joinrel->consider_param_startup = false; joinrel->consider_parallel = false; + joinrel->path_type_mask = default_path_type_mask; joinrel->reltarget = create_empty_pathtarget(); joinrel->pathlist = NIL; joinrel->ppilist = NIL; @@ -900,6 +902,7 @@ build_child_join_rel(PlannerInfo *root, RelOptInfo *outer_rel, joinrel->consider_startup = (root->tuple_fraction > 0); joinrel->consider_param_startup = false; joinrel->consider_parallel = false; + joinrel->path_type_mask = default_path_type_mask; joinrel->reltarget = create_empty_pathtarget(); joinrel->pathlist = NIL; joinrel->ppilist = NIL; @@ -1484,6 +1487,7 @@ fetch_upper_rel(PlannerInfo *root, UpperRelationKind kind, Relids relids) upperrel->consider_startup = (root->tuple_fraction > 0); upperrel->consider_param_startup = false; upperrel->consider_parallel = false; /* might get changed later */ + upperrel->path_type_mask = default_path_type_mask; upperrel->reltarget = create_empty_pathtarget(); upperrel->pathlist = NIL; upperrel->cheapest_startup_path = NULL; @@ -2010,7 +2014,7 @@ build_joinrel_partition_info(PlannerInfo *root, PartitionScheme part_scheme; /* Nothing to do if partitionwise join technique is disabled. */ - if (!enable_partitionwise_join) + if (!REL_CAN_USE_PATH(joinrel, PartitionwiseJoin)) { Assert(!IS_PARTITIONED_REL(joinrel)); return; diff --git a/src/backend/utils/misc/guc_tables.c b/src/backend/utils/misc/guc_tables.c index af227b1f24..1bd21bbe34 100644 --- a/src/backend/utils/misc/guc_tables.c +++ b/src/backend/utils/misc/guc_tables.c @@ -55,6 +55,7 @@ #include "optimizer/geqo.h" #include "optimizer/optimizer.h" #include "optimizer/paths.h" +#include "optimizer/pathnode.h" #include "optimizer/planmain.h" #include "parser/parse_expr.h" #include "parser/parser.h" @@ -777,7 +778,7 @@ struct config_bool ConfigureNamesBool[] = }, &enable_seqscan, true, - NULL, NULL, NULL + NULL, enable_seqscan_assign_hook, NULL }, { {"enable_indexscan", PGC_USERSET, QUERY_TUNING_METHOD, @@ -787,7 +788,7 @@ struct config_bool ConfigureNamesBool[] = }, &enable_indexscan, true, - NULL, NULL, NULL + NULL, enable_indexscan_assign_hook, NULL }, { {"enable_indexonlyscan", PGC_USERSET, QUERY_TUNING_METHOD, @@ -797,7 +798,7 @@ struct config_bool ConfigureNamesBool[] = }, &enable_indexonlyscan, true, - NULL, NULL, NULL + NULL, enable_indexonlyscan_assign_hook, NULL }, { {"enable_bitmapscan", PGC_USERSET, QUERY_TUNING_METHOD, @@ -807,7 +808,7 @@ struct config_bool ConfigureNamesBool[] = }, &enable_bitmapscan, true, - NULL, NULL, NULL + NULL, enable_bitmapscan_assign_hook, NULL }, { {"enable_tidscan", PGC_USERSET, QUERY_TUNING_METHOD, @@ -817,7 +818,7 @@ struct config_bool ConfigureNamesBool[] = }, &enable_tidscan, true, - NULL, NULL, NULL + NULL, enable_tidscan_assign_hook, NULL }, { {"enable_sort", PGC_USERSET, QUERY_TUNING_METHOD, @@ -827,7 +828,7 @@ struct config_bool ConfigureNamesBool[] = }, &enable_sort, true, - NULL, NULL, NULL + NULL, enable_sort_assign_hook, NULL }, { {"enable_incremental_sort", PGC_USERSET, QUERY_TUNING_METHOD, @@ -837,7 +838,7 @@ struct config_bool ConfigureNamesBool[] = }, &enable_incremental_sort, true, - NULL, NULL, NULL + NULL, enable_incremental_sort_assign_hook, NULL }, { {"enable_hashagg", PGC_USERSET, QUERY_TUNING_METHOD, @@ -847,7 +848,7 @@ struct config_bool ConfigureNamesBool[] = }, &enable_hashagg, true, - NULL, NULL, NULL + NULL, enable_hashagg_assign_hook, NULL }, { {"enable_material", PGC_USERSET, QUERY_TUNING_METHOD, @@ -857,7 +858,7 @@ struct config_bool ConfigureNamesBool[] = }, &enable_material, true, - NULL, NULL, NULL + NULL, enable_material_assign_hook, NULL }, { {"enable_memoize", PGC_USERSET, QUERY_TUNING_METHOD, @@ -867,7 +868,7 @@ struct config_bool ConfigureNamesBool[] = }, &enable_memoize, true, - NULL, NULL, NULL + NULL, enable_memoize_assign_hook, NULL }, { {"enable_nestloop", PGC_USERSET, QUERY_TUNING_METHOD, @@ -877,7 +878,7 @@ struct config_bool ConfigureNamesBool[] = }, &enable_nestloop, true, - NULL, NULL, NULL + NULL, enable_nestloop_assign_hook, NULL }, { {"enable_mergejoin", PGC_USERSET, QUERY_TUNING_METHOD, @@ -887,7 +888,7 @@ struct config_bool ConfigureNamesBool[] = }, &enable_mergejoin, true, - NULL, NULL, NULL + NULL, enable_mergejoin_assign_hook, NULL }, { {"enable_hashjoin", PGC_USERSET, QUERY_TUNING_METHOD, @@ -897,7 +898,7 @@ struct config_bool ConfigureNamesBool[] = }, &enable_hashjoin, true, - NULL, NULL, NULL + NULL, enable_hashjoin_assign_hook, NULL }, { {"enable_gathermerge", PGC_USERSET, QUERY_TUNING_METHOD, @@ -907,7 +908,7 @@ struct config_bool ConfigureNamesBool[] = }, &enable_gathermerge, true, - NULL, NULL, NULL + NULL, enable_gathermerge_assign_hook, NULL }, { {"enable_partitionwise_join", PGC_USERSET, QUERY_TUNING_METHOD, @@ -917,7 +918,7 @@ struct config_bool ConfigureNamesBool[] = }, &enable_partitionwise_join, false, - NULL, NULL, NULL + NULL, enable_partitionwise_join_assign_hook, NULL }, { {"enable_partitionwise_aggregate", PGC_USERSET, QUERY_TUNING_METHOD, @@ -927,7 +928,7 @@ struct config_bool ConfigureNamesBool[] = }, &enable_partitionwise_aggregate, false, - NULL, NULL, NULL + NULL, enable_partitionwise_aggregate_assign_hook, NULL }, { {"enable_parallel_append", PGC_USERSET, QUERY_TUNING_METHOD, @@ -937,7 +938,7 @@ struct config_bool ConfigureNamesBool[] = }, &enable_parallel_append, true, - NULL, NULL, NULL + NULL, enable_parallel_append_assign_hook, NULL }, { {"enable_parallel_hash", PGC_USERSET, QUERY_TUNING_METHOD, @@ -947,7 +948,7 @@ struct config_bool ConfigureNamesBool[] = }, &enable_parallel_hash, true, - NULL, NULL, NULL + NULL, enable_parallel_hash_assign_hook, NULL }, { {"enable_partition_pruning", PGC_USERSET, QUERY_TUNING_METHOD, diff --git a/src/include/nodes/pathnodes.h b/src/include/nodes/pathnodes.h index 540d021592..bbff482cec 100644 --- a/src/include/nodes/pathnodes.h +++ b/src/include/nodes/pathnodes.h @@ -80,6 +80,26 @@ typedef enum UpperRelationKind /* NB: UPPERREL_FINAL must be last enum entry; it's used to size arrays */ } UpperRelationKind; +#define PathTypeBitmapScan 0x00000001 +#define PathTypeGatherMerge 0x00000002 +#define PathTypeHashAgg 0x00000004 +#define PathTypeHashJoin 0x00000008 +#define PathTypeIncrementalSort 0x00000010 +#define PathTypeIndexScan 0x00000020 +#define PathTypeIndexOnlyScan 0x00000040 +#define PathTypeMaterial 0x00000080 +#define PathTypeMemoize 0x00000100 +#define PathTypeMergeJoin 0x00000200 +#define PathTypeNestLoop 0x00000400 +#define PathTypeParallelAppend 0x00000800 +#define PathTypeParallelHash 0x00001000 +#define PathTypePartitionwiseJoin 0x00002000 +#define PathTypePartitionwiseAggregate 0x00004000 +#define PathTypeSeqScan 0x00008000 +#define PathTypeSort 0x00010000 +#define PathTypeTIDScan 0x00020000 +#define PathTypeMaskAll 0x0003FFFF + /*---------- * PlannerGlobal * Global information for planning/optimization @@ -879,6 +899,8 @@ typedef struct RelOptInfo bool consider_param_startup; /* consider parallel paths? */ bool consider_parallel; + /* path type mask for this rel */ + uint32 path_type_mask; /* * default result targetlist for Paths scanning this relation; list of @@ -1065,6 +1087,13 @@ typedef struct RelOptInfo ((rel)->part_scheme && (rel)->boundinfo && (rel)->nparts > 0 && \ (rel)->part_rels && (rel)->partexprs && (rel)->nullable_partexprs) +/* + * Convenience macro to test for whether a certain a PathTypeXXX bit is + * set in a relation's path_type_mask. + */ +#define REL_CAN_USE_PATH(rel, type) \ + (((rel)->path_type_mask & PathType##type) != 0) + /* * IndexOptInfo * Per-index information for planning/optimization diff --git a/src/include/optimizer/cost.h b/src/include/optimizer/cost.h index 854a782944..2cd1d8c34c 100644 --- a/src/include/optimizer/cost.h +++ b/src/include/optimizer/cost.h @@ -71,6 +71,26 @@ extern PGDLLIMPORT bool enable_partition_pruning; extern PGDLLIMPORT bool enable_presorted_aggregate; extern PGDLLIMPORT bool enable_async_append; extern PGDLLIMPORT int constraint_exclusion; +extern PGDLLIMPORT uint32 default_path_type_mask; + +extern void enable_bitmapscan_assign_hook(bool newval, void *extra); +extern void enable_gathermerge_assign_hook(bool newval, void *extra); +extern void enable_hashagg_assign_hook(bool newval, void *extra); +extern void enable_hashjoin_assign_hook(bool newval, void *extra); +extern void enable_incremental_sort_assign_hook(bool newval, void *extra); +extern void enable_indexscan_assign_hook(bool newval, void *extra); +extern void enable_indexonlyscan_assign_hook(bool newval, void *extra); +extern void enable_material_assign_hook(bool newval, void *extra); +extern void enable_memoize_assign_hook(bool newval, void *extra); +extern void enable_mergejoin_assign_hook(bool newval, void *extra); +extern void enable_nestloop_assign_hook(bool newval, void *extra); +extern void enable_parallel_append_assign_hook(bool newval, void *extra); +extern void enable_parallel_hash_assign_hook(bool newval, void *extra); +extern void enable_partitionwise_join_assign_hook(bool newval, void *extra); +extern void enable_partitionwise_aggregate_assign_hook(bool newval, void *extra); +extern void enable_seqscan_assign_hook(bool newval, void *extra); +extern void enable_sort_assign_hook(bool newval, void *extra); +extern void enable_tidscan_assign_hook(bool newval, void *extra); extern double index_pages_fetched(double tuples_fetched, BlockNumber pages, double index_pages, PlannerInfo *root); @@ -107,7 +127,7 @@ extern void cost_namedtuplestorescan(Path *path, PlannerInfo *root, extern void cost_resultscan(Path *path, PlannerInfo *root, RelOptInfo *baserel, ParamPathInfo *param_info); extern void cost_recursive_union(Path *runion, Path *nrterm, Path *rterm); -extern void cost_sort(Path *path, PlannerInfo *root, +extern void cost_sort(Path *path, PlannerInfo *root, RelOptInfo *rel, List *pathkeys, int disabled_nodes, Cost input_cost, double tuples, int width, Cost comparison_cost, int sort_mem, @@ -124,11 +144,11 @@ extern void cost_merge_append(Path *path, PlannerInfo *root, int input_disabled_nodes, Cost input_startup_cost, Cost input_total_cost, double tuples); -extern void cost_material(Path *path, +extern void cost_material(Path *path, RelOptInfo *rel, int input_disabled_nodes, Cost input_startup_cost, Cost input_total_cost, double tuples, int width); -extern void cost_agg(Path *path, PlannerInfo *root, +extern void cost_agg(Path *path, PlannerInfo *root, RelOptInfo *rel, AggStrategy aggstrategy, const AggClauseCosts *aggcosts, int numGroupCols, double numGroups, List *quals, @@ -148,6 +168,7 @@ extern void cost_group(Path *path, PlannerInfo *root, double input_tuples); extern void initial_cost_nestloop(PlannerInfo *root, JoinCostWorkspace *workspace, + RelOptInfo *joinrel, JoinType jointype, Path *outer_path, Path *inner_path, JoinPathExtraData *extra); @@ -156,6 +177,7 @@ extern void final_cost_nestloop(PlannerInfo *root, NestPath *path, JoinPathExtraData *extra); extern void initial_cost_mergejoin(PlannerInfo *root, JoinCostWorkspace *workspace, + RelOptInfo *joinrel, JoinType jointype, List *mergeclauses, Path *outer_path, Path *inner_path, @@ -166,6 +188,7 @@ extern void final_cost_mergejoin(PlannerInfo *root, MergePath *path, JoinPathExtraData *extra); extern void initial_cost_hashjoin(PlannerInfo *root, JoinCostWorkspace *workspace, + RelOptInfo *joinrel, JoinType jointype, List *hashclauses, Path *outer_path, Path *inner_path, diff --git a/src/include/optimizer/planmain.h b/src/include/optimizer/planmain.h index aafc173792..07623eff79 100644 --- a/src/include/optimizer/planmain.h +++ b/src/include/optimizer/planmain.h @@ -45,7 +45,7 @@ extern ForeignScan *make_foreignscan(List *qptlist, List *qpqual, Plan *outer_plan); extern Plan *change_plan_targetlist(Plan *subplan, List *tlist, bool tlist_parallel_safe); -extern Plan *materialize_finished_plan(Plan *subplan); +extern Plan *materialize_finished_plan(Plan *subplan, RelOptInfo *rel); extern bool is_projection_capable_path(Path *path); extern bool is_projection_capable_plan(Plan *plan); -- 2.39.3 (Apple Git-145)