From 08142f2c450ec5763875583923e00daaefd88c09 Mon Sep 17 00:00:00 2001 From: Richard Guo Date: Thu, 6 Jun 2024 19:23:55 +0900 Subject: [PATCH v3] Reordering DISTINCT keys to match input path's pathkeys Similar to what we did to GROUP BY keys in 0452b461bc, we can do the same to DISTINCT keys, i.e. reordering DISTINCT keys to match input path's pathkeys, which can help reduce cost by avoiding unnecessary re-sort, or allowing us to use incremental-sort to save efforts. Please note that the parser has ensured that the DISTINCT pathkeys matches the order of ORDER BY clauses. So there is no need to do this part in this commit. In principle, we can perform such reordering for DISTINCT ON too, but we need to make sure that the resulting pathkeys matches initial ORDER BY keys, which seems not trivial. So don't bother with that. This introduces a new GUC enable_distinct_reordering so that the optimization can be disabled if needed. --- src/backend/optimizer/path/pathkeys.c | 36 ++ src/backend/optimizer/plan/planner.c | 457 ++++++++++-------- src/backend/utils/misc/guc_tables.c | 10 + src/backend/utils/misc/postgresql.conf.sample | 1 + src/include/optimizer/optimizer.h | 1 + src/test/regress/expected/select_distinct.out | 112 +++++ src/test/regress/expected/sysviews.out | 3 +- src/test/regress/sql/select_distinct.sql | 69 +++ 8 files changed, 490 insertions(+), 199 deletions(-) diff --git a/src/backend/optimizer/path/pathkeys.c b/src/backend/optimizer/path/pathkeys.c index 416fc4e240..55a59d894c 100644 --- a/src/backend/optimizer/path/pathkeys.c +++ b/src/backend/optimizer/path/pathkeys.c @@ -2188,6 +2188,39 @@ pathkeys_useful_for_grouping(PlannerInfo *root, List *pathkeys) return n; } +/* + * pathkeys_useful_for_distinct + * Count the number of pathkeys that are useful for DISTINCT clause. + * + * DISTINCT keys could also be reordered to benefit from the ordering. As with + * pathkeys_useful_for_grouping, we return the number of leading keys in the + * list that are shared by the distinctClause pathkeys. + */ +static int +pathkeys_useful_for_distinct(PlannerInfo *root, List *pathkeys) +{ + int n_common_pathkeys; + ListCell *lc; + + if (root->distinct_pathkeys == NIL) + return 0; /* no special ordering requested for DISTINCT */ + + /* walk the pathkeys and search for matching DISTINCT key */ + n_common_pathkeys = 0; + foreach(lc, pathkeys) + { + PathKey *pathkey = (PathKey *) lfirst(lc); + + /* no matching DISTINCT key, we're done */ + if (!list_member_ptr(root->distinct_pathkeys, pathkey)) + break; + + n_common_pathkeys++; + } + + return n_common_pathkeys; +} + /* * pathkeys_useful_for_setop * Count the number of leading common pathkeys root's 'setop_pathkeys' in @@ -2221,6 +2254,9 @@ truncate_useless_pathkeys(PlannerInfo *root, if (nuseful2 > nuseful) nuseful = nuseful2; nuseful2 = pathkeys_useful_for_grouping(root, pathkeys); + if (nuseful2 > nuseful) + nuseful = nuseful2; + nuseful2 = pathkeys_useful_for_distinct(root, pathkeys); if (nuseful2 > nuseful) nuseful = nuseful2; nuseful2 = pathkeys_useful_for_setop(root, pathkeys); diff --git a/src/backend/optimizer/plan/planner.c b/src/backend/optimizer/plan/planner.c index 4711f91239..57f21392cb 100644 --- a/src/backend/optimizer/plan/planner.c +++ b/src/backend/optimizer/plan/planner.c @@ -66,6 +66,7 @@ double cursor_tuple_fraction = DEFAULT_CURSOR_TUPLE_FRACTION; int debug_parallel_query = DEBUG_PARALLEL_OFF; bool parallel_leader_participation = true; +bool enable_distinct_reordering = true; /* Hook for plugins to get control in planner() */ planner_hook_type planner_hook = NULL; @@ -196,6 +197,9 @@ static void create_partial_distinct_paths(PlannerInfo *root, static RelOptInfo *create_final_distinct_paths(PlannerInfo *root, RelOptInfo *input_rel, RelOptInfo *distinct_rel); +static List *get_useful_pathkeys_for_distinct(PlannerInfo *root, + List *distinct_pathkeys, + List *path_pathkeys); static RelOptInfo *create_ordered_paths(PlannerInfo *root, RelOptInfo *input_rel, PathTarget *target, @@ -233,6 +237,12 @@ static RelOptInfo *create_partial_grouping_paths(PlannerInfo *root, grouping_sets_data *gd, GroupPathExtraData *extra, bool force_rel_creation); +static Path *make_ordered_path(PlannerInfo *root, + RelOptInfo *rel, + Path *path, + Path *cheapest_path, + List *pathkeys, + double limit_tuples); static void gather_grouping_paths(PlannerInfo *root, RelOptInfo *rel); static bool can_partial_agg(PlannerInfo *root); static void apply_scanjoin_target_to_paths(PlannerInfo *root, @@ -4874,86 +4884,68 @@ create_partial_distinct_paths(PlannerInfo *root, RelOptInfo *input_rel, { Path *input_path = (Path *) lfirst(lc); Path *sorted_path; - bool is_sorted; - int presorted_keys; + List *useful_pathkeys_list = NIL; + ListCell *lc2; - is_sorted = pathkeys_count_contained_in(root->distinct_pathkeys, - input_path->pathkeys, - &presorted_keys); + useful_pathkeys_list = + get_useful_pathkeys_for_distinct(root, + root->distinct_pathkeys, + input_path->pathkeys); + Assert(list_length(useful_pathkeys_list) > 0); - if (is_sorted) - sorted_path = input_path; - else + foreach(lc2, useful_pathkeys_list) { - /* - * Try at least sorting the cheapest path and also try - * incrementally sorting any path which is partially sorted - * already (no need to deal with paths which have presorted - * keys when incremental sort is disabled unless it's the - * cheapest partial path). - */ - if (input_path != cheapest_partial_path && - (presorted_keys == 0 || !enable_incremental_sort)) + List *useful_pathkeys = (List *) lfirst(lc2); + + sorted_path = make_ordered_path(root, + partial_distinct_rel, + input_path, + cheapest_partial_path, + useful_pathkeys, + -1.0); + + if (sorted_path == NULL) continue; /* - * We've no need to consider both a sort and incremental sort. - * We'll just do a sort if there are no presorted keys and an - * incremental sort when there are presorted keys. + * An empty distinct_pathkeys means all tuples have the same value + * for the DISTINCT clause. See create_final_distinct_paths() */ - if (presorted_keys == 0 || !enable_incremental_sort) - sorted_path = (Path *) create_sort_path(root, - partial_distinct_rel, - input_path, - root->distinct_pathkeys, - -1.0); - else - sorted_path = (Path *) create_incremental_sort_path(root, - partial_distinct_rel, - input_path, - root->distinct_pathkeys, - presorted_keys, - -1.0); - } - - /* - * An empty distinct_pathkeys means all tuples have the same value - * for the DISTINCT clause. See create_final_distinct_paths() - */ - if (root->distinct_pathkeys == NIL) - { - Node *limitCount; + if (root->distinct_pathkeys == NIL) + { + Node *limitCount; - limitCount = (Node *) makeConst(INT8OID, -1, InvalidOid, - sizeof(int64), - Int64GetDatum(1), false, - FLOAT8PASSBYVAL); + limitCount = (Node *) makeConst(INT8OID, -1, InvalidOid, + sizeof(int64), + Int64GetDatum(1), false, + FLOAT8PASSBYVAL); - /* - * Apply a LimitPath onto the partial path to restrict the - * tuples from each worker to 1. create_final_distinct_paths - * will need to apply an additional LimitPath to restrict this - * to a single row after the Gather node. If the query - * already has a LIMIT clause, then we could end up with three - * Limit nodes in the final plan. Consolidating the top two - * of these could be done, but does not seem worth troubling - * over. - */ - add_partial_path(partial_distinct_rel, (Path *) - create_limit_path(root, partial_distinct_rel, - sorted_path, - NULL, - limitCount, - LIMIT_OPTION_COUNT, - 0, 1)); - } - else - { - add_partial_path(partial_distinct_rel, (Path *) - create_upper_unique_path(root, partial_distinct_rel, - sorted_path, - list_length(root->distinct_pathkeys), - numDistinctRows)); + /* + * Apply a LimitPath onto the partial path to restrict the + * tuples from each worker to 1. create_final_distinct_paths + * will need to apply an additional LimitPath to restrict this + * to a single row after the Gather node. If the query + * already has a LIMIT clause, then we could end up with three + * Limit nodes in the final plan. Consolidating the top two + * of these could be done, but does not seem worth troubling + * over. + */ + add_partial_path(partial_distinct_rel, (Path *) + create_limit_path(root, partial_distinct_rel, + sorted_path, + NULL, + limitCount, + LIMIT_OPTION_COUNT, + 0, 1)); + } + else + { + add_partial_path(partial_distinct_rel, (Path *) + create_upper_unique_path(root, partial_distinct_rel, + sorted_path, + list_length(root->distinct_pathkeys), + numDistinctRows)); + } } } } @@ -5086,86 +5078,69 @@ create_final_distinct_paths(PlannerInfo *root, RelOptInfo *input_rel, { Path *input_path = (Path *) lfirst(lc); Path *sorted_path; - bool is_sorted; - int presorted_keys; + List *useful_pathkeys_list = NIL; + ListCell *lc2; - is_sorted = pathkeys_count_contained_in(needed_pathkeys, - input_path->pathkeys, - &presorted_keys); + useful_pathkeys_list = + get_useful_pathkeys_for_distinct(root, + needed_pathkeys, + input_path->pathkeys); + Assert(list_length(useful_pathkeys_list) > 0); - if (is_sorted) - sorted_path = input_path; - else + foreach(lc2, useful_pathkeys_list) { - /* - * Try at least sorting the cheapest path and also try - * incrementally sorting any path which is partially sorted - * already (no need to deal with paths which have presorted - * keys when incremental sort is disabled unless it's the - * cheapest input path). - */ - if (input_path != cheapest_input_path && - (presorted_keys == 0 || !enable_incremental_sort)) + List *useful_pathkeys = (List *) lfirst(lc2); + + sorted_path = make_ordered_path(root, + distinct_rel, + input_path, + cheapest_input_path, + useful_pathkeys, + limittuples); + + if (sorted_path == NULL) continue; /* - * We've no need to consider both a sort and incremental sort. - * We'll just do a sort if there are no presorted keys and an - * incremental sort when there are presorted keys. + * distinct_pathkeys may have become empty if all of the + * pathkeys were determined to be redundant. If all of the + * pathkeys are redundant then each DISTINCT target must only + * allow a single value, therefore all resulting tuples must be + * identical (or at least indistinguishable by an equality + * check). We can uniquify these tuples simply by just taking + * the first tuple. All we do here is add a path to do "LIMIT + * 1" atop of 'sorted_path'. When doing a DISTINCT ON we may + * still have a non-NIL sort_pathkeys list, so we must still + * only do this with paths which are correctly sorted by + * sort_pathkeys. */ - if (presorted_keys == 0 || !enable_incremental_sort) - sorted_path = (Path *) create_sort_path(root, - distinct_rel, - input_path, - needed_pathkeys, - limittuples); - else - sorted_path = (Path *) create_incremental_sort_path(root, - distinct_rel, - input_path, - needed_pathkeys, - presorted_keys, - limittuples); - } - - /* - * distinct_pathkeys may have become empty if all of the pathkeys - * were determined to be redundant. If all of the pathkeys are - * redundant then each DISTINCT target must only allow a single - * value, therefore all resulting tuples must be identical (or at - * least indistinguishable by an equality check). We can uniquify - * these tuples simply by just taking the first tuple. All we do - * here is add a path to do "LIMIT 1" atop of 'sorted_path'. When - * doing a DISTINCT ON we may still have a non-NIL sort_pathkeys - * list, so we must still only do this with paths which are - * correctly sorted by sort_pathkeys. - */ - if (root->distinct_pathkeys == NIL) - { - Node *limitCount; + if (root->distinct_pathkeys == NIL) + { + Node *limitCount; - limitCount = (Node *) makeConst(INT8OID, -1, InvalidOid, - sizeof(int64), - Int64GetDatum(1), false, - FLOAT8PASSBYVAL); + limitCount = (Node *) makeConst(INT8OID, -1, InvalidOid, + sizeof(int64), + Int64GetDatum(1), false, + FLOAT8PASSBYVAL); - /* - * If the query already has a LIMIT clause, then we could end - * up with a duplicate LimitPath in the final plan. That does - * not seem worth troubling over too much. - */ - add_path(distinct_rel, (Path *) - create_limit_path(root, distinct_rel, sorted_path, - NULL, limitCount, - LIMIT_OPTION_COUNT, 0, 1)); - } - else - { - add_path(distinct_rel, (Path *) - create_upper_unique_path(root, distinct_rel, - sorted_path, - list_length(root->distinct_pathkeys), - numDistinctRows)); + /* + * If the query already has a LIMIT clause, then we could + * end up with a duplicate LimitPath in the final plan. + * That does not seem worth troubling over too much. + */ + add_path(distinct_rel, (Path *) + create_limit_path(root, distinct_rel, sorted_path, + NULL, limitCount, + LIMIT_OPTION_COUNT, 0, 1)); + } + else + { + add_path(distinct_rel, (Path *) + create_upper_unique_path(root, distinct_rel, + sorted_path, + list_length(root->distinct_pathkeys), + numDistinctRows)); + } } } } @@ -5208,6 +5183,88 @@ create_final_distinct_paths(PlannerInfo *root, RelOptInfo *input_rel, return distinct_rel; } +/* + * get_useful_pathkeys_for_distinct + * Get useful orderings of distinctClause by reordering 'distinct_pathkeys' + * to match the given 'path_pathkeys' as much as possible. + * + * This returns a list of pathkeys that can be useful for DISTINCT clause, + * which, for convenience, always includes the given 'distinct_pathkeys'. + */ +static List * +get_useful_pathkeys_for_distinct(PlannerInfo *root, List *distinct_pathkeys, + List *path_pathkeys) +{ + List *useful_pathkeys_list = NIL; + List *useful_pathkeys = NIL; + ListCell *lc; + + /* always include the given 'distinct_pathkeys' */ + useful_pathkeys_list = lappend(useful_pathkeys_list, + distinct_pathkeys); + + if (!enable_distinct_reordering) + return useful_pathkeys_list; + + /* + * Do not try to reorder pathkeys for DISTINCT ON + * + * XXX It might be possible to perform reordering for DISTINCT ON too, but + * we need to make sure that the resulting pathkeys matches initial ORDER + * BY keys, which seems not trivial. So don't bother with that. + */ + if (root->parse->hasDistinctOn) + return useful_pathkeys_list; + + /* + * Scan the given 'path_pathkeys' and construct a list of PathKey nodes + * that match 'distinct_pathkeys', but only as far as we can make a + * matching prefix. + */ + foreach(lc, path_pathkeys) + { + PathKey *pathkey = (PathKey *) lfirst(lc); + + /* + * The PathKey nodes are canonical, so they can be checked for equality + * by simple pointer comparison. + */ + if (!list_member_ptr(distinct_pathkeys, pathkey)) + break; + + useful_pathkeys = lappend(useful_pathkeys, pathkey); + } + + /* If no match at all, no point in reordering distinct_pathkeys */ + if (useful_pathkeys == NIL) + return useful_pathkeys_list; + + /* + * If not full match, the resulting pathkeys is not useful without + * incremental sort. + */ + if (list_length(useful_pathkeys) < list_length(distinct_pathkeys) && + !enable_incremental_sort) + return useful_pathkeys_list; + + /* Append the remaining distinct PathKey nodes */ + useful_pathkeys = list_concat_unique_ptr(useful_pathkeys, + distinct_pathkeys); + + /* + * If the resulting pathkeys is the same as the 'distinct_pathkeys', just + * drop it. + */ + if (compare_pathkeys(distinct_pathkeys, + useful_pathkeys) == PATHKEYS_EQUAL) + return useful_pathkeys_list; + + useful_pathkeys_list = lappend(useful_pathkeys_list, + useful_pathkeys); + + return useful_pathkeys_list; +} + /* * create_ordered_paths * @@ -6905,58 +6962,6 @@ done: return parallel_workers; } -/* - * make_ordered_path - * Return a path ordered by 'pathkeys' based on the given 'path'. May - * return NULL if it doesn't make sense to generate an ordered path in - * this case. - */ -static Path * -make_ordered_path(PlannerInfo *root, RelOptInfo *rel, Path *path, - Path *cheapest_path, List *pathkeys) -{ - bool is_sorted; - int presorted_keys; - - is_sorted = pathkeys_count_contained_in(pathkeys, - path->pathkeys, - &presorted_keys); - - if (!is_sorted) - { - /* - * Try at least sorting the cheapest path and also try incrementally - * sorting any path which is partially sorted already (no need to deal - * with paths which have presorted keys when incremental sort is - * disabled unless it's the cheapest input path). - */ - if (path != cheapest_path && - (presorted_keys == 0 || !enable_incremental_sort)) - return NULL; - - /* - * We've no need to consider both a sort and incremental sort. 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) - path = (Path *) create_sort_path(root, - rel, - path, - pathkeys, - -1.0); - else - path = (Path *) create_incremental_sort_path(root, - rel, - path, - pathkeys, - presorted_keys, - -1.0); - } - - return path; -} - /* * add_paths_to_grouping_rel * @@ -7008,7 +7013,8 @@ add_paths_to_grouping_rel(PlannerInfo *root, RelOptInfo *input_rel, grouped_rel, path, cheapest_path, - info->pathkeys); + info->pathkeys, + -1.0); if (path == NULL) continue; @@ -7089,7 +7095,8 @@ add_paths_to_grouping_rel(PlannerInfo *root, RelOptInfo *input_rel, grouped_rel, path, partially_grouped_rel->cheapest_total_path, - info->pathkeys); + info->pathkeys, + -1.0); if (path == NULL) continue; @@ -7340,7 +7347,8 @@ create_partial_grouping_paths(PlannerInfo *root, partially_grouped_rel, path, cheapest_total_path, - info->pathkeys); + info->pathkeys, + -1.0); if (path == NULL) continue; @@ -7397,7 +7405,8 @@ create_partial_grouping_paths(PlannerInfo *root, partially_grouped_rel, path, cheapest_partial_path, - info->pathkeys); + info->pathkeys, + -1.0); if (path == NULL) continue; @@ -7483,6 +7492,58 @@ create_partial_grouping_paths(PlannerInfo *root, return partially_grouped_rel; } +/* + * make_ordered_path + * Return a path ordered by 'pathkeys' based on the given 'path'. May + * return NULL if it doesn't make sense to generate an ordered path in + * this case. + */ +static Path * +make_ordered_path(PlannerInfo *root, RelOptInfo *rel, Path *path, + Path *cheapest_path, List *pathkeys, double limit_tuples) +{ + bool is_sorted; + int presorted_keys; + + is_sorted = pathkeys_count_contained_in(pathkeys, + path->pathkeys, + &presorted_keys); + + if (!is_sorted) + { + /* + * Try at least sorting the cheapest path and also try incrementally + * sorting any path which is partially sorted already (no need to deal + * with paths which have presorted keys when incremental sort is + * disabled unless it's the cheapest input path). + */ + if (path != cheapest_path && + (presorted_keys == 0 || !enable_incremental_sort)) + return NULL; + + /* + * We've no need to consider both a sort and incremental sort. 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) + path = (Path *) create_sort_path(root, + rel, + path, + pathkeys, + limit_tuples); + else + path = (Path *) create_incremental_sort_path(root, + rel, + path, + pathkeys, + presorted_keys, + limit_tuples); + } + + return path; +} + /* * Generate Gather and Gather Merge paths for a grouping relation or partial * grouping relation. diff --git a/src/backend/utils/misc/guc_tables.c b/src/backend/utils/misc/guc_tables.c index 46c258be28..26d491b80d 100644 --- a/src/backend/utils/misc/guc_tables.c +++ b/src/backend/utils/misc/guc_tables.c @@ -996,6 +996,16 @@ struct config_bool ConfigureNamesBool[] = true, NULL, NULL, NULL }, + { + {"enable_distinct_reordering", PGC_USERSET, QUERY_TUNING_METHOD, + gettext_noop("Enables reordering of DISTINCT pathkeys."), + NULL, + GUC_EXPLAIN + }, + &enable_distinct_reordering, + true, + NULL, NULL, NULL + }, { {"geqo", PGC_USERSET, QUERY_TUNING_GEQO, gettext_noop("Enables genetic query optimization."), diff --git a/src/backend/utils/misc/postgresql.conf.sample b/src/backend/utils/misc/postgresql.conf.sample index e0567de219..672822c46b 100644 --- a/src/backend/utils/misc/postgresql.conf.sample +++ b/src/backend/utils/misc/postgresql.conf.sample @@ -413,6 +413,7 @@ #enable_sort = on #enable_tidscan = on #enable_group_by_reordering = on +#enable_distinct_reordering = on # - Planner Cost Constants - diff --git a/src/include/optimizer/optimizer.h b/src/include/optimizer/optimizer.h index 7b63c5cf71..798b9732b8 100644 --- a/src/include/optimizer/optimizer.h +++ b/src/include/optimizer/optimizer.h @@ -111,6 +111,7 @@ typedef enum /* GUC parameters */ extern PGDLLIMPORT int debug_parallel_query; extern PGDLLIMPORT bool parallel_leader_participation; +extern PGDLLIMPORT bool enable_distinct_reordering; extern struct PlannedStmt *planner(Query *parse, const char *query_string, int cursorOptions, diff --git a/src/test/regress/expected/select_distinct.out b/src/test/regress/expected/select_distinct.out index 82b8e54f5f..febd613694 100644 --- a/src/test/regress/expected/select_distinct.out +++ b/src/test/regress/expected/select_distinct.out @@ -464,3 +464,115 @@ SELECT null IS NOT DISTINCT FROM null as "yes"; t (1 row) +-- +-- Test the planner's ability to reorder the distinctClause Pathkeys to match +-- the input path's ordering +-- +CREATE TABLE distinct_tbl (x int, y int, z int); +INSERT INTO distinct_tbl SELECT i%10, i%10, i FROM generate_series(1, 1000) AS i; +CREATE INDEX distinct_tbl_x_y_idx ON distinct_tbl(x, y); +ANALYZE distinct_tbl; +SET enable_hashagg TO OFF; +SET enable_seqscan TO OFF; +-- Ensure we avoid the Sort operation by reordering the distinctClause Pathkeys +-- to match the ordering of index scan +EXPLAIN (COSTS OFF) +SELECT DISTINCT y, x FROM distinct_tbl; + QUERY PLAN +------------------------------------------------------------------ + Unique + -> Index Only Scan using distinct_tbl_x_y_idx on distinct_tbl +(2 rows) + +-- Ensure we leverage incremental sort to avoid full Sort operation by +-- reordering the distinctClause Pathkeys to partially match the ordering of +-- index scan +EXPLAIN (COSTS OFF) +SELECT DISTINCT z, y, x FROM distinct_tbl; + QUERY PLAN +------------------------------------------------------------------- + Unique + -> Incremental Sort + Sort Key: x, y, z + Presorted Key: x, y + -> Index Scan using distinct_tbl_x_y_idx on distinct_tbl +(5 rows) + +-- Ensure we avoid the Sort operation by reordering the distinctClause Pathkeys +-- to match the ordering of subquery scan +EXPLAIN (COSTS OFF) +SELECT DISTINCT x, z, y + FROM (SELECT * FROM distinct_tbl ORDER BY x, y, z) AS s; + QUERY PLAN +------------------------------------------------------------------------- + Unique + -> Subquery Scan on s + -> Incremental Sort + Sort Key: distinct_tbl.x, distinct_tbl.y, distinct_tbl.z + Presorted Key: distinct_tbl.x, distinct_tbl.y + -> Index Scan using distinct_tbl_x_y_idx on distinct_tbl +(6 rows) + +-- Ensure we leverage incremental sort to avoid full Sort operation by +-- reordering the distinctClause Pathkeys to partially match the ordering of +-- merge join +SET enable_nestloop TO OFF; +SET enable_hashjoin TO OFF; +EXPLAIN (COSTS OFF) +SELECT DISTINCT t1.x, t1.z, t1.y + FROM distinct_tbl t1 JOIN distinct_tbl t2 ON t1.x = t2.x AND t1.y = t2.y; + QUERY PLAN +--------------------------------------------------------------------------------------- + Unique + -> Incremental Sort + Sort Key: t1.x, t1.y, t1.z + Presorted Key: t1.x, t1.y + -> Merge Join + Merge Cond: ((t1.x = t2.x) AND (t1.y = t2.y)) + -> Index Scan using distinct_tbl_x_y_idx on distinct_tbl t1 + -> Materialize + -> Index Only Scan using distinct_tbl_x_y_idx on distinct_tbl t2 +(9 rows) + +RESET enable_hashjoin; +RESET enable_nestloop; +-- Ensure we avoid the Sort operation by reordering the distinctClause Pathkeys +-- to match the ordering of index scan in parallel plan +SET parallel_tuple_cost=0; +SET parallel_setup_cost=0; +SET min_parallel_table_scan_size=0; +SET min_parallel_index_scan_size=0; +SET max_parallel_workers_per_gather=2; +EXPLAIN (COSTS OFF) +SELECT DISTINCT y, x FROM distinct_tbl limit 10; + QUERY PLAN +--------------------------------------------------------------------------------------------- + Limit + -> Unique + -> Gather Merge + Workers Planned: 1 + -> Unique + -> Parallel Index Only Scan using distinct_tbl_x_y_idx on distinct_tbl +(6 rows) + +RESET max_parallel_workers_per_gather; +RESET min_parallel_index_scan_size; +RESET min_parallel_table_scan_size; +RESET parallel_setup_cost; +RESET parallel_tuple_cost; +-- Ensure we reorder the distinctClause Pathkeys to match the ordering of index +-- scan even if there is ORDER BY clause +EXPLAIN (COSTS OFF) +SELECT DISTINCT y, x FROM distinct_tbl ORDER BY y limit 1; + QUERY PLAN +------------------------------------------------------------------------------ + Limit + -> Sort + Sort Key: y + -> Unique + -> Index Only Scan using distinct_tbl_x_y_idx on distinct_tbl +(5 rows) + +RESET enable_seqscan; +RESET enable_hashagg; +DROP TABLE distinct_tbl; diff --git a/src/test/regress/expected/sysviews.out b/src/test/regress/expected/sysviews.out index dbfd0c13d4..4bb87801fa 100644 --- a/src/test/regress/expected/sysviews.out +++ b/src/test/regress/expected/sysviews.out @@ -136,6 +136,7 @@ select name, setting from pg_settings where name like 'enable%'; --------------------------------+--------- enable_async_append | on enable_bitmapscan | on + enable_distinct_reordering | on enable_gathermerge | on enable_group_by_reordering | on enable_hashagg | on @@ -156,7 +157,7 @@ select name, setting from pg_settings where name like 'enable%'; enable_seqscan | on enable_sort | on enable_tidscan | on -(22 rows) +(23 rows) -- There are always wait event descriptions for various types. select type, count(*) > 0 as ok FROM pg_wait_events diff --git a/src/test/regress/sql/select_distinct.sql b/src/test/regress/sql/select_distinct.sql index da92c197ab..f63469d401 100644 --- a/src/test/regress/sql/select_distinct.sql +++ b/src/test/regress/sql/select_distinct.sql @@ -221,3 +221,72 @@ SELECT 1 IS NOT DISTINCT FROM 2 as "no"; SELECT 2 IS NOT DISTINCT FROM 2 as "yes"; SELECT 2 IS NOT DISTINCT FROM null as "no"; SELECT null IS NOT DISTINCT FROM null as "yes"; + +-- +-- Test the planner's ability to reorder the distinctClause Pathkeys to match +-- the input path's ordering +-- + +CREATE TABLE distinct_tbl (x int, y int, z int); +INSERT INTO distinct_tbl SELECT i%10, i%10, i FROM generate_series(1, 1000) AS i; +CREATE INDEX distinct_tbl_x_y_idx ON distinct_tbl(x, y); +ANALYZE distinct_tbl; + +SET enable_hashagg TO OFF; +SET enable_seqscan TO OFF; + +-- Ensure we avoid the Sort operation by reordering the distinctClause Pathkeys +-- to match the ordering of index scan +EXPLAIN (COSTS OFF) +SELECT DISTINCT y, x FROM distinct_tbl; + +-- Ensure we leverage incremental sort to avoid full Sort operation by +-- reordering the distinctClause Pathkeys to partially match the ordering of +-- index scan +EXPLAIN (COSTS OFF) +SELECT DISTINCT z, y, x FROM distinct_tbl; + +-- Ensure we avoid the Sort operation by reordering the distinctClause Pathkeys +-- to match the ordering of subquery scan +EXPLAIN (COSTS OFF) +SELECT DISTINCT x, z, y + FROM (SELECT * FROM distinct_tbl ORDER BY x, y, z) AS s; + +-- Ensure we leverage incremental sort to avoid full Sort operation by +-- reordering the distinctClause Pathkeys to partially match the ordering of +-- merge join +SET enable_nestloop TO OFF; +SET enable_hashjoin TO OFF; +EXPLAIN (COSTS OFF) +SELECT DISTINCT t1.x, t1.z, t1.y + FROM distinct_tbl t1 JOIN distinct_tbl t2 ON t1.x = t2.x AND t1.y = t2.y; + +RESET enable_hashjoin; +RESET enable_nestloop; + +-- Ensure we avoid the Sort operation by reordering the distinctClause Pathkeys +-- to match the ordering of index scan in parallel plan +SET parallel_tuple_cost=0; +SET parallel_setup_cost=0; +SET min_parallel_table_scan_size=0; +SET min_parallel_index_scan_size=0; +SET max_parallel_workers_per_gather=2; + +EXPLAIN (COSTS OFF) +SELECT DISTINCT y, x FROM distinct_tbl limit 10; + +RESET max_parallel_workers_per_gather; +RESET min_parallel_index_scan_size; +RESET min_parallel_table_scan_size; +RESET parallel_setup_cost; +RESET parallel_tuple_cost; + +-- Ensure we reorder the distinctClause Pathkeys to match the ordering of index +-- scan even if there is ORDER BY clause +EXPLAIN (COSTS OFF) +SELECT DISTINCT y, x FROM distinct_tbl ORDER BY y limit 1; + +RESET enable_seqscan; +RESET enable_hashagg; + +DROP TABLE distinct_tbl; -- 2.43.0