diff --git a/contrib/pg_trgm/expected/pg_trgm.out b/contrib/pg_trgm/expected/pg_trgm.out index 20141ce7f3..ce4bf1d4e5 100644 --- a/contrib/pg_trgm/expected/pg_trgm.out +++ b/contrib/pg_trgm/expected/pg_trgm.out @@ -5366,10 +5366,10 @@ SELECT similarity('Szczecin', 'Warsaw'); EXPLAIN (COSTS OFF) SELECT DISTINCT city, similarity(city, 'Warsaw'), show_limit() FROM restaurants WHERE city % 'Warsaw'; - QUERY PLAN -------------------------------------------------------------------- + QUERY PLAN +------------------------------------------------------- HashAggregate - Group Key: city, similarity(city, 'Warsaw'::text), show_limit() + Group Key: city, similarity(city, 'Warsaw'::text) -> Bitmap Heap Scan on restaurants Recheck Cond: (city % 'Warsaw'::text) -> Bitmap Index Scan on restaurants_city_idx diff --git a/contrib/postgres_fdw/expected/postgres_fdw.out b/contrib/postgres_fdw/expected/postgres_fdw.out index 385b76a8cb..2ac19eb2ab 100644 --- a/contrib/postgres_fdw/expected/postgres_fdw.out +++ b/contrib/postgres_fdw/expected/postgres_fdw.out @@ -2293,7 +2293,7 @@ SELECT t1."C 1" FROM "S 1"."T 1" t1, LATERAL (SELECT DISTINCT t2.c1, t3.c1 FROM -> Subquery Scan on q -> HashAggregate Output: t2.c1, t3.c1 - Group Key: t2.c1, t3.c1 + Group Key: t2.c1 -> Foreign Scan Output: t2.c1, t3.c1 Relations: (public.ft1 t2) INNER JOIN (public.ft2 t3) diff --git a/src/backend/optimizer/plan/planner.c b/src/backend/optimizer/plan/planner.c index a2fa081cdd..70bd4ec94d 100644 --- a/src/backend/optimizer/plan/planner.c +++ b/src/backend/optimizer/plan/planner.c @@ -636,6 +636,7 @@ subquery_planner(PlannerGlobal *glob, Query *parse, memset(root->upper_rels, 0, sizeof(root->upper_rels)); memset(root->upper_targets, 0, sizeof(root->upper_targets)); root->processed_groupClause = NIL; + root->processed_distinctClause = NIL; root->processed_tlist = NIL; root->update_colnos = NIL; root->grouping_map = NULL; @@ -3427,12 +3428,27 @@ standard_qp_callback(PlannerInfo *root, void *extra) else root->window_pathkeys = NIL; - if (parse->distinctClause && - grouping_is_sortable(parse->distinctClause)) + /* + * As with GROUP BY, we can discard any DISTINCT items that are proven + * redundant by EquivalenceClass processing. The non-redundant list is + * kept in root->processed_distinctClause, leaving the original + * parse->distinctClause alone. + */ + if (parse->distinctClause) + { + bool sortable; + + /* Make a copy since pathkey processing can modify the list */ + root->processed_distinctClause = list_copy(parse->distinctClause); root->distinct_pathkeys = - make_pathkeys_for_sortclauses(root, - parse->distinctClause, - tlist); + make_pathkeys_for_sortclauses_extended(root, + &root->processed_distinctClause, + tlist, + true, + &sortable); + if (!sortable) + root->distinct_pathkeys = NIL; + } else root->distinct_pathkeys = NIL; @@ -4679,7 +4695,7 @@ create_partial_distinct_paths(PlannerInfo *root, RelOptInfo *input_rel, cheapest_partial_path = linitial(input_rel->partial_pathlist); - distinctExprs = get_sortgrouplist_exprs(parse->distinctClause, + distinctExprs = get_sortgrouplist_exprs(root->processed_distinctClause, parse->targetList); /* estimate how many distinct rows we'll get from each worker */ @@ -4691,7 +4707,7 @@ create_partial_distinct_paths(PlannerInfo *root, RelOptInfo *input_rel, * Try sorting the cheapest path and incrementally sorting any paths with * presorted keys and put a unique paths atop of those. */ - if (grouping_is_sortable(parse->distinctClause)) + if (grouping_is_sortable(root->processed_distinctClause)) { foreach(lc, input_rel->partial_pathlist) { @@ -4753,7 +4769,7 @@ create_partial_distinct_paths(PlannerInfo *root, RelOptInfo *input_rel, * path here, we treat enable_hashagg as a hard off-switch rather than the * slightly softer variant in create_final_distinct_paths. */ - if (enable_hashagg && grouping_is_hashable(parse->distinctClause)) + if (enable_hashagg && grouping_is_hashable(root->processed_distinctClause)) { add_partial_path(partial_distinct_rel, (Path *) create_agg_path(root, @@ -4762,7 +4778,7 @@ create_partial_distinct_paths(PlannerInfo *root, RelOptInfo *input_rel, cheapest_partial_path->pathtarget, AGG_HASHED, AGGSPLIT_SIMPLE, - parse->distinctClause, + root->processed_distinctClause, NIL, NULL, numDistinctRows)); @@ -4834,7 +4850,7 @@ create_final_distinct_paths(PlannerInfo *root, RelOptInfo *input_rel, */ List *distinctExprs; - distinctExprs = get_sortgrouplist_exprs(parse->distinctClause, + distinctExprs = get_sortgrouplist_exprs(root->processed_distinctClause, parse->targetList); numDistinctRows = estimate_num_groups(root, distinctExprs, cheapest_input_path->rows, @@ -4844,7 +4860,7 @@ create_final_distinct_paths(PlannerInfo *root, RelOptInfo *input_rel, /* * Consider sort-based implementations of DISTINCT, if possible. */ - if (grouping_is_sortable(parse->distinctClause)) + if (grouping_is_sortable(root->processed_distinctClause)) { /* * Firstly, if we have any adequately-presorted paths, just stick a @@ -4978,7 +4994,7 @@ create_final_distinct_paths(PlannerInfo *root, RelOptInfo *input_rel, else allow_hash = true; /* default */ - if (allow_hash && grouping_is_hashable(parse->distinctClause)) + if (allow_hash && grouping_is_hashable(root->processed_distinctClause)) { /* Generate hashed aggregate path --- no sort needed */ add_path(distinct_rel, (Path *) @@ -4988,7 +5004,7 @@ create_final_distinct_paths(PlannerInfo *root, RelOptInfo *input_rel, cheapest_input_path->pathtarget, AGG_HASHED, AGGSPLIT_SIMPLE, - parse->distinctClause, + root->processed_distinctClause, NIL, NULL, numDistinctRows)); diff --git a/src/backend/optimizer/prep/prepjointree.c b/src/backend/optimizer/prep/prepjointree.c index 08ae3b3d1c..37a7af8c66 100644 --- a/src/backend/optimizer/prep/prepjointree.c +++ b/src/backend/optimizer/prep/prepjointree.c @@ -1009,6 +1009,7 @@ pull_up_simple_subquery(PlannerInfo *root, Node *jtnode, RangeTblEntry *rte, memset(subroot->upper_rels, 0, sizeof(subroot->upper_rels)); memset(subroot->upper_targets, 0, sizeof(subroot->upper_targets)); subroot->processed_groupClause = NIL; + subroot->processed_distinctClause = NIL; subroot->processed_tlist = NIL; subroot->update_colnos = NIL; subroot->grouping_map = NULL; diff --git a/src/include/nodes/pathnodes.h b/src/include/nodes/pathnodes.h index 9c2be6cca7..2d1d8f4bcd 100644 --- a/src/include/nodes/pathnodes.h +++ b/src/include/nodes/pathnodes.h @@ -422,6 +422,18 @@ struct PlannerInfo */ List *processed_groupClause; + /* + * The fully-processed distinctClause is kept here. It differs from + * parse->distinctClause in that we remove any items that we can prove + * redundant, so that only the columns named here actually need to be + * compared to determine uniqueness. Note that it's possible for *all* + * the items to be proven redundant, implying that there should be only + * one output row. Hence, if you want to check whether DISTINCT was + * specified, test for nonempty parse->distinctClause, not for nonempty + * processed_distinctClause. + */ + List *processed_distinctClause; + /* * The fully-processed targetlist is kept here. It differs from * parse->targetList in that (for INSERT) it's been reordered to match the diff --git a/src/test/regress/expected/select_distinct.out b/src/test/regress/expected/select_distinct.out index 1fc07f220f..9d44ea8056 100644 --- a/src/test/regress/expected/select_distinct.out +++ b/src/test/regress/expected/select_distinct.out @@ -136,7 +136,7 @@ SELECT count(*) FROM Output: count(*) -> HashAggregate Output: tenk1.two, tenk1.four, tenk1.two - Group Key: tenk1.two, tenk1.four, tenk1.two + Group Key: tenk1.two, tenk1.four -> Seq Scan on public.tenk1 Output: tenk1.two, tenk1.four, tenk1.two (7 rows)