diff --git a/contrib/postgres_fdw/deparse.c b/contrib/postgres_fdw/deparse.c index 6ef1e48..8388ea7 100644 --- a/contrib/postgres_fdw/deparse.c +++ b/contrib/postgres_fdw/deparse.c @@ -1064,6 +1064,7 @@ deparseFromExpr(List *quals, deparse_expr_cxt *context) /* For upper relations, scanrel must be either a joinrel or a baserel */ Assert(context->foreignrel->reloptkind != RELOPT_UPPER_REL || IS_JOIN_REL(scanrel) || + scanrel->reloptkind == RELOPT_OTHER_MEMBER_REL || scanrel->reloptkind == RELOPT_BASEREL); /* Construct FROM clause */ diff --git a/contrib/postgres_fdw/expected/postgres_fdw.out b/contrib/postgres_fdw/expected/postgres_fdw.out index 059c5c3..d968832 100644 --- a/contrib/postgres_fdw/expected/postgres_fdw.out +++ b/contrib/postgres_fdw/expected/postgres_fdw.out @@ -7181,3 +7181,115 @@ AND ftoptions @> array['fetch_size=60000']; (1 row) ROLLBACK; +-- Partition-wise aggregates with FDW +CREATE TABLE plt1 (a int, b int, c text) PARTITION BY RANGE(a); +CREATE TABLE plt1_p1 (a int, b int, c text); +CREATE TABLE plt1_p2 (a int, b int, c text); +CREATE TABLE plt1_p3 (a int, b int, c text); +INSERT INTO plt1_p1 SELECT i % 30, i % 50, to_char(i/30, 'FM0000') FROM generate_series(1, 3000) i WHERE (i % 30) < 10; +INSERT INTO plt1_p2 SELECT i % 30, i % 50, to_char(i/30, 'FM0000') FROM generate_series(1, 3000) i WHERE (i % 30) < 20 and (i % 30) >= 10; +INSERT INTO plt1_p3 SELECT i % 30, i % 50, to_char(i/30, 'FM0000') FROM generate_series(1, 3000) i WHERE (i % 30) < 30 and (i % 30) >= 20; +-- Create foreign partitions +CREATE FOREIGN TABLE fplt1_p1 PARTITION OF plt1 FOR VALUES FROM (0) TO (10) SERVER loopback OPTIONS (table_name 'plt1_p1'); +CREATE FOREIGN TABLE fplt1_p2 PARTITION OF plt1 FOR VALUES FROM (10) TO (20) SERVER loopback OPTIONS (table_name 'plt1_p2');; +CREATE FOREIGN TABLE fplt1_p3 PARTITION OF plt1 FOR VALUES FROM (20) TO (30) SERVER loopback OPTIONS (table_name 'plt1_p3');; +ANALYZE plt1; +ANALYZE fplt1_p1; +ANALYZE fplt1_p2; +ANALYZE fplt1_p3; +-- When GROUP BY clause matches with PARTITION KEY. +-- Plan when partition-wise-agg is disabled +SET enable_partition_wise_agg TO false; +EXPLAIN (VERBOSE, COSTS OFF) +SELECT a, sum(b), min(b), count(*) FROM plt1 GROUP BY a ORDER BY 1; + QUERY PLAN +----------------------------------------------------------------- + Sort + Output: plt1.a, (sum(plt1.b)), (min(plt1.b)), (count(*)) + Sort Key: plt1.a + -> HashAggregate + Output: plt1.a, sum(plt1.b), min(plt1.b), count(*) + Group Key: plt1.a + -> Append + -> Seq Scan on public.plt1 + Output: plt1.a, plt1.b + -> Foreign Scan on public.fplt1_p1 + Output: fplt1_p1.a, fplt1_p1.b + Remote SQL: SELECT a, b FROM public.plt1_p1 + -> Foreign Scan on public.fplt1_p2 + Output: fplt1_p2.a, fplt1_p2.b + Remote SQL: SELECT a, b FROM public.plt1_p2 + -> Foreign Scan on public.fplt1_p3 + Output: fplt1_p3.a, fplt1_p3.b + Remote SQL: SELECT a, b FROM public.plt1_p3 +(18 rows) + +-- Plan when partition-wise-agg is enabled +SET enable_partition_wise_agg TO true; +EXPLAIN (VERBOSE, COSTS OFF) +SELECT a, sum(b), min(b), count(*) FROM plt1 GROUP BY a ORDER BY 1; +NOTICE: partition-wise grouping is possible. + QUERY PLAN +--------------------------------------------------------------------------------------------- + Sort + Output: fplt1_p1.a, (sum(fplt1_p1.b)), (min(fplt1_p1.b)), (count(*)) + Sort Key: fplt1_p1.a + -> Append + -> Foreign Scan + Output: fplt1_p1.a, (sum(fplt1_p1.b)), (min(fplt1_p1.b)), (count(*)) + Relations: Aggregate on (public.fplt1_p1 plt1) + Remote SQL: SELECT a, sum(b), min(b), count(*) FROM public.plt1_p1 GROUP BY a + -> Foreign Scan + Output: fplt1_p2.a, (sum(fplt1_p2.b)), (min(fplt1_p2.b)), (count(*)) + Relations: Aggregate on (public.fplt1_p2 plt1) + Remote SQL: SELECT a, sum(b), min(b), count(*) FROM public.plt1_p2 GROUP BY a + -> Foreign Scan + Output: fplt1_p3.a, (sum(fplt1_p3.b)), (min(fplt1_p3.b)), (count(*)) + Relations: Aggregate on (public.fplt1_p3 plt1) + Remote SQL: SELECT a, sum(b), min(b), count(*) FROM public.plt1_p3 GROUP BY a +(16 rows) + +SELECT a, sum(b), min(b), count(*) FROM plt1 GROUP BY a ORDER BY 1; +NOTICE: partition-wise grouping is possible. + a | sum | min | count +----+------+-----+------- + 0 | 2000 | 0 | 100 + 1 | 2100 | 1 | 100 + 2 | 2200 | 2 | 100 + 3 | 2300 | 3 | 100 + 4 | 2400 | 4 | 100 + 5 | 2500 | 5 | 100 + 6 | 2600 | 6 | 100 + 7 | 2700 | 7 | 100 + 8 | 2800 | 8 | 100 + 9 | 2900 | 9 | 100 + 10 | 2000 | 0 | 100 + 11 | 2100 | 1 | 100 + 12 | 2200 | 2 | 100 + 13 | 2300 | 3 | 100 + 14 | 2400 | 4 | 100 + 15 | 2500 | 5 | 100 + 16 | 2600 | 6 | 100 + 17 | 2700 | 7 | 100 + 18 | 2800 | 8 | 100 + 19 | 2900 | 9 | 100 + 20 | 2000 | 0 | 100 + 21 | 2100 | 1 | 100 + 22 | 2200 | 2 | 100 + 23 | 2300 | 3 | 100 + 24 | 2400 | 4 | 100 + 25 | 2500 | 5 | 100 + 26 | 2600 | 6 | 100 + 27 | 2700 | 7 | 100 + 28 | 2800 | 8 | 100 + 29 | 2900 | 9 | 100 +(30 rows) + +-- Clean-up +DROP FOREIGN TABLE fplt1_p3; +DROP FOREIGN TABLE fplt1_p2; +DROP FOREIGN TABLE fplt1_p1; +DROP TABLE plt1_p3; +DROP TABLE plt1_p2; +DROP TABLE plt1_p1; +DROP TABLE plt1; diff --git a/contrib/postgres_fdw/postgres_fdw.c b/contrib/postgres_fdw/postgres_fdw.c index 22acba8..630c374 100644 --- a/contrib/postgres_fdw/postgres_fdw.c +++ b/contrib/postgres_fdw/postgres_fdw.c @@ -349,7 +349,8 @@ static bool postgresRecheckForeignScan(ForeignScanState *node, static void postgresGetForeignUpperPaths(PlannerInfo *root, UpperRelationKind stage, RelOptInfo *input_rel, - RelOptInfo *output_rel); + RelOptInfo *output_rel, + PathTarget *target); /* * Helper functions @@ -415,7 +416,8 @@ static void add_paths_with_pathkeys_for_rel(PlannerInfo *root, RelOptInfo *rel, Path *epq_path); static void add_foreign_grouping_paths(PlannerInfo *root, RelOptInfo *input_rel, - RelOptInfo *grouped_rel); + RelOptInfo *grouped_rel, + PathTarget *target); /* @@ -2688,7 +2690,7 @@ estimate_path_cost_size(PlannerInfo *root, else if (foreignrel->reloptkind == RELOPT_UPPER_REL) { PgFdwRelationInfo *ofpinfo; - PathTarget *ptarget = root->upper_targets[UPPERREL_GROUP_AGG]; + PathTarget *ptarget = fpinfo->grouped_target; AggClauseCosts aggcosts; double input_rows; int numGroupCols; @@ -4536,7 +4538,7 @@ foreign_grouping_ok(PlannerInfo *root, RelOptInfo *grouped_rel) * different from those in the plan's targetlist. Use a copy of path * target to record the new sortgrouprefs. */ - grouping_target = copy_pathtarget(root->upper_targets[UPPERREL_GROUP_AGG]); + grouping_target = copy_pathtarget(fpinfo->grouped_target); /* * Evaluate grouping targets and check whether they are safe to push down @@ -4715,7 +4717,8 @@ foreign_grouping_ok(PlannerInfo *root, RelOptInfo *grouped_rel) */ static void postgresGetForeignUpperPaths(PlannerInfo *root, UpperRelationKind stage, - RelOptInfo *input_rel, RelOptInfo *output_rel) + RelOptInfo *input_rel, RelOptInfo *output_rel, + PathTarget *target) { PgFdwRelationInfo *fpinfo; @@ -4735,7 +4738,7 @@ postgresGetForeignUpperPaths(PlannerInfo *root, UpperRelationKind stage, fpinfo->pushdown_safe = false; output_rel->fdw_private = fpinfo; - add_foreign_grouping_paths(root, input_rel, output_rel); + add_foreign_grouping_paths(root, input_rel, output_rel, target); } /* @@ -4747,13 +4750,12 @@ postgresGetForeignUpperPaths(PlannerInfo *root, UpperRelationKind stage, */ static void add_foreign_grouping_paths(PlannerInfo *root, RelOptInfo *input_rel, - RelOptInfo *grouped_rel) + RelOptInfo *grouped_rel, PathTarget *target) { Query *parse = root->parse; PgFdwRelationInfo *ifpinfo = input_rel->fdw_private; PgFdwRelationInfo *fpinfo = grouped_rel->fdw_private; ForeignPath *grouppath; - PathTarget *grouping_target; double rows; int width; Cost startup_cost; @@ -4764,7 +4766,8 @@ add_foreign_grouping_paths(PlannerInfo *root, RelOptInfo *input_rel, !root->hasHavingQual) return; - grouping_target = root->upper_targets[UPPERREL_GROUP_AGG]; + /* Store passed-in target in fpinfo for later use */ + fpinfo->grouped_target = target; /* save the input_rel as outerrel in fpinfo */ fpinfo->outerrel = input_rel; @@ -4795,7 +4798,7 @@ add_foreign_grouping_paths(PlannerInfo *root, RelOptInfo *input_rel, /* Create and add foreign path to the grouping relation. */ grouppath = create_foreignscan_path(root, grouped_rel, - grouping_target, + target, rows, startup_cost, total_cost, diff --git a/contrib/postgres_fdw/postgres_fdw.h b/contrib/postgres_fdw/postgres_fdw.h index 57dbb79..99cecb7 100644 --- a/contrib/postgres_fdw/postgres_fdw.h +++ b/contrib/postgres_fdw/postgres_fdw.h @@ -95,6 +95,7 @@ typedef struct PgFdwRelationInfo /* Grouping information */ List *grouped_tlist; + PathTarget *grouped_target; /* Subquery information */ bool make_outerrel_subquery; /* do we deparse outerrel as a diff --git a/contrib/postgres_fdw/sql/postgres_fdw.sql b/contrib/postgres_fdw/sql/postgres_fdw.sql index 8f3edc1..f02ec8a 100644 --- a/contrib/postgres_fdw/sql/postgres_fdw.sql +++ b/contrib/postgres_fdw/sql/postgres_fdw.sql @@ -1706,3 +1706,47 @@ WHERE ftrelid = 'table30000'::regclass AND ftoptions @> array['fetch_size=60000']; ROLLBACK; + + +-- Partition-wise aggregates with FDW +CREATE TABLE plt1 (a int, b int, c text) PARTITION BY RANGE(a); + +CREATE TABLE plt1_p1 (a int, b int, c text); +CREATE TABLE plt1_p2 (a int, b int, c text); +CREATE TABLE plt1_p3 (a int, b int, c text); + +INSERT INTO plt1_p1 SELECT i % 30, i % 50, to_char(i/30, 'FM0000') FROM generate_series(1, 3000) i WHERE (i % 30) < 10; +INSERT INTO plt1_p2 SELECT i % 30, i % 50, to_char(i/30, 'FM0000') FROM generate_series(1, 3000) i WHERE (i % 30) < 20 and (i % 30) >= 10; +INSERT INTO plt1_p3 SELECT i % 30, i % 50, to_char(i/30, 'FM0000') FROM generate_series(1, 3000) i WHERE (i % 30) < 30 and (i % 30) >= 20; + +-- Create foreign partitions +CREATE FOREIGN TABLE fplt1_p1 PARTITION OF plt1 FOR VALUES FROM (0) TO (10) SERVER loopback OPTIONS (table_name 'plt1_p1'); +CREATE FOREIGN TABLE fplt1_p2 PARTITION OF plt1 FOR VALUES FROM (10) TO (20) SERVER loopback OPTIONS (table_name 'plt1_p2');; +CREATE FOREIGN TABLE fplt1_p3 PARTITION OF plt1 FOR VALUES FROM (20) TO (30) SERVER loopback OPTIONS (table_name 'plt1_p3');; + +ANALYZE plt1; +ANALYZE fplt1_p1; +ANALYZE fplt1_p2; +ANALYZE fplt1_p3; + +-- When GROUP BY clause matches with PARTITION KEY. +-- Plan when partition-wise-agg is disabled +SET enable_partition_wise_agg TO false; +EXPLAIN (VERBOSE, COSTS OFF) +SELECT a, sum(b), min(b), count(*) FROM plt1 GROUP BY a ORDER BY 1; + +-- Plan when partition-wise-agg is enabled +SET enable_partition_wise_agg TO true; +EXPLAIN (VERBOSE, COSTS OFF) +SELECT a, sum(b), min(b), count(*) FROM plt1 GROUP BY a ORDER BY 1; +SELECT a, sum(b), min(b), count(*) FROM plt1 GROUP BY a ORDER BY 1; + + +-- Clean-up +DROP FOREIGN TABLE fplt1_p3; +DROP FOREIGN TABLE fplt1_p2; +DROP FOREIGN TABLE fplt1_p1; +DROP TABLE plt1_p3; +DROP TABLE plt1_p2; +DROP TABLE plt1_p1; +DROP TABLE plt1; diff --git a/src/backend/optimizer/path/allpaths.c b/src/backend/optimizer/path/allpaths.c index 8143f80..0ab5c56 100644 --- a/src/backend/optimizer/path/allpaths.c +++ b/src/backend/optimizer/path/allpaths.c @@ -130,8 +130,6 @@ static void subquery_push_qual(Query *subquery, static void recurse_push_qual(Node *setOp, Query *topquery, RangeTblEntry *rte, Index rti, Node *qual); static void remove_unused_subquery_outputs(Query *subquery, RelOptInfo *rel); -static void add_paths_to_append_rel(PlannerInfo *root, RelOptInfo *rel, - List *live_childrels); /* @@ -1338,7 +1336,7 @@ set_append_rel_pathlist(PlannerInfo *root, RelOptInfo *rel, * parameterization or ordering. Similarly it collects partial paths from * non-dummy children to create partial append paths. */ -static void +void add_paths_to_append_rel(PlannerInfo *root, RelOptInfo *rel, List *live_childrels) { diff --git a/src/backend/optimizer/path/costsize.c b/src/backend/optimizer/path/costsize.c index 220c81c..b2edaca 100644 --- a/src/backend/optimizer/path/costsize.c +++ b/src/backend/optimizer/path/costsize.c @@ -128,6 +128,7 @@ bool enable_mergejoin = true; bool enable_hashjoin = true; bool enable_gathermerge = true; bool enable_partition_wise_join = false; +bool enable_partition_wise_agg = true; typedef struct { diff --git a/src/backend/optimizer/plan/createplan.c b/src/backend/optimizer/plan/createplan.c index 0aae4ca..929e0a6 100644 --- a/src/backend/optimizer/plan/createplan.c +++ b/src/backend/optimizer/plan/createplan.c @@ -1610,6 +1610,7 @@ create_sort_plan(PlannerInfo *root, SortPath *best_path, int flags) { Sort *plan; Plan *subplan; + Relids relids; /* * We don't want any excess columns in the sorted tuples, so request a @@ -1619,7 +1620,12 @@ create_sort_plan(PlannerInfo *root, SortPath *best_path, int flags) subplan = create_plan_recurse(root, best_path->subpath, flags | CP_SMALL_TLIST); - plan = make_sort_from_pathkeys(subplan, best_path->path.pathkeys, NULL); + /* + * TODO: we need to fix something here. The "other" upper rels are not + * marked as "OTHER" rels and may not have relids. + */ + relids = IS_OTHER_REL(best_path->subpath->parent) ? best_path->path.parent->relids : NULL; + plan = make_sort_from_pathkeys(subplan, best_path->path.pathkeys, relids); copy_generic_path_info(&plan->plan, (Path *) best_path); @@ -3393,15 +3399,8 @@ create_foreignscan_plan(PlannerInfo *root, ForeignPath *best_path, /* Copy foreign server OID; likewise, no need to make FDW do this */ scan_plan->fs_server = rel->serverid; - /* - * Likewise, copy the relids that are represented by this foreign scan. An - * upper rel doesn't have relids set, but it covers all the base relations - * participating in the underlying scan, so use root's all_baserels. - */ - if (rel->reloptkind == RELOPT_UPPER_REL) - scan_plan->fs_relids = root->all_baserels; - else - scan_plan->fs_relids = best_path->path.parent->relids; + /* Likewise, copy the relids from Path to Plan */ + scan_plan->fs_relids = best_path->path.parent->relids; /* * If this is a foreign join, and to make it valid to push down we had to diff --git a/src/backend/optimizer/plan/planner.c b/src/backend/optimizer/plan/planner.c index 17fae4f..9f7db45 100644 --- a/src/backend/optimizer/plan/planner.c +++ b/src/backend/optimizer/plan/planner.c @@ -157,6 +157,15 @@ static PathTarget *make_sort_input_target(PlannerInfo *root, bool *have_postponed_srfs); static void adjust_paths_for_srfs(PlannerInfo *root, RelOptInfo *rel, List *targets, List *targets_contain_srfs); +static void try_partition_wise_grouping(PlannerInfo *root, + RelOptInfo *input_rel, + RelOptInfo *grouped_rel, + PathTarget *target, + const AggClauseCosts *agg_costs, + List *rollup_lists, + List *rollup_groupclauses); +static bool have_grouping_by_partkey(RelOptInfo *input_rel, PathTarget *target, + List *groupClause); /***************************************************************************** @@ -2067,7 +2076,8 @@ grouping_planner(PlannerInfo *root, bool inheritance_update, if (final_rel->fdwroutine && final_rel->fdwroutine->GetForeignUpperPaths) final_rel->fdwroutine->GetForeignUpperPaths(root, UPPERREL_FINAL, - current_rel, final_rel); + current_rel, final_rel, + NULL); /* Let extensions possibly add some more paths */ if (create_upper_paths_hook) @@ -3283,7 +3293,18 @@ create_grouping_paths(PlannerInfo *root, ListCell *lc; /* For now, do all work in the (GROUP_AGG, NULL) upperrel */ - grouped_rel = fetch_upper_rel(root, UPPERREL_GROUP_AGG, NULL); + if (IS_OTHER_REL(input_rel)) + { + + /* + * TODO: We should mark these rels as "other upper" rels similar to + * "other" join and base relations. + */ + grouped_rel = fetch_upper_rel(root, UPPERREL_GROUP_AGG, + input_rel->relids); + } + else + grouped_rel = fetch_upper_rel(root, UPPERREL_GROUP_AGG, NULL); /* * If the input relation is not parallel-safe, then the grouped relation @@ -3303,6 +3324,9 @@ create_grouping_paths(PlannerInfo *root, grouped_rel->useridiscurrent = input_rel->useridiscurrent; grouped_rel->fdwroutine = input_rel->fdwroutine; + /* Copy input rels's relids to grouped rel */ + grouped_rel->relids = input_rel->relids; + /* * Check for degenerate grouping. */ @@ -3377,6 +3401,34 @@ create_grouping_paths(PlannerInfo *root, rollup_groupclauses); /* + * Number of groups estimated above is based on parent relation. However + * we need to estimate the number of groups for the child. For that we + * must know the number of partitions. Find that and devise new estimate + * for number of groups. + * + * FIXME: We might need to do this in get_number_of_groups() itself. But + * not sure at this time. Need to revise the logic. + */ + if (IS_OTHER_REL(input_rel)) + { + RelOptInfo *rel; + + /* Find top-most parent rel */ + if (IS_JOIN_REL(input_rel)) + rel = find_join_rel(root, input_rel->top_parent_relids); + else + rel = find_base_rel(root, + bms_singleton_member(input_rel->top_parent_relids)); + + /* + * Divide estimated number of groups by number of children to get + * number of groups estimate for child rel. + */ + if (rel->part_scheme->nparts > 0) + dNumGroups = clamp_row_est(dNumGroups / rel->part_scheme->nparts); + } + + /* * Determine whether it's possible to perform sort-based implementations * of grouping. (Note that if groupClause is empty, * grouping_is_sortable() is trivially true, and all the @@ -3441,6 +3493,11 @@ create_grouping_paths(PlannerInfo *root, /* Insufficient support for partial mode. */ try_parallel_aggregation = false; } + else if (IS_OTHER_REL(input_rel)) + { + /* TODO: enable parallel query for partition-wise grouping. */ + try_parallel_aggregation = false; + } else { /* Everything looks good. */ @@ -3855,13 +3912,21 @@ create_grouping_paths(PlannerInfo *root, errdetail("Some of the datatypes only support hashing, while others only support sorting."))); /* + * If input relation is partitioned check if we can perform partition-wise + * grouping and/or aggregation. + */ + try_partition_wise_grouping(root, input_rel, grouped_rel, target, + agg_costs, rollup_lists, rollup_groupclauses); + + /* * If there is an FDW that's responsible for all baserels of the query, * let it consider adding ForeignPaths. */ if (grouped_rel->fdwroutine && grouped_rel->fdwroutine->GetForeignUpperPaths) grouped_rel->fdwroutine->GetForeignUpperPaths(root, UPPERREL_GROUP_AGG, - input_rel, grouped_rel); + input_rel, grouped_rel, + target); /* Let extensions possibly add some more paths */ if (create_upper_paths_hook) @@ -3885,6 +3950,191 @@ create_grouping_paths(PlannerInfo *root, } /* + * If the input relation is partitioned and the partition keys are leading + * group by clauses, each partition produces a different set of groups. + * Aggregates within each such group can be computed partition-wise. This + * might be optimal because of presence of suitable paths with pathkeys or + * because the hash tables for most of the partitions fit in the memory. + */ +static void +try_partition_wise_grouping(PlannerInfo *root, + RelOptInfo *input_rel, + RelOptInfo *grouped_rel, + PathTarget *target, + const AggClauseCosts *agg_costs, + List *rollup_lists, + List *rollup_groupclauses) +{ + Query *query = root->parse; + int nparts; + int cnt_parts; + PartitionScheme part_scheme = input_rel->part_scheme; + RelOptInfo **part_rels; + List *live_children = NIL; + PathTarget *scanjoin_target; + ListCell *lc; + + /* Nothing to do, if user disabled partition-wise aggregation. */ + if (!enable_partition_wise_agg) + return; + + /* Do not handle grouping sets for now. */ + if (rollup_groupclauses || rollup_lists) + return; + + /* Nothing to do, if the input relation is not partitioned. */ + if (!part_scheme) + return; + + Assert(input_rel->part_rels); + + /* + * TODO: for now do nothing if partition keys are not leading group by + * clauses. In general we may calculate partial aggregates for each + * partition and combine them. + */ + if (!have_grouping_by_partkey(input_rel, target, query->groupClause)) + return; + + /* TODO: should be removed in final version */ + elog(NOTICE, "partition-wise grouping is possible."); + + nparts = part_scheme->nparts; + grouped_rel->part_scheme = input_rel->part_scheme; + part_rels = (RelOptInfo **) palloc(nparts * sizeof(RelOptInfo *)); + grouped_rel->part_rels = part_rels; + + /* Add paths for partition-wise aggregation/grouping. */ + for (cnt_parts = 0; cnt_parts < nparts; cnt_parts++) + { + RelOptInfo *input_child_rel = input_rel->part_rels[cnt_parts]; + PathTarget *child_target = copy_pathtarget(target); + List *appinfos = find_appinfos_by_relids(root, + input_child_rel->relids); + + /* + * Now that there can be multiple grouping relations, if we have to + * manage those in the root, we need separate identifiers for those. + * What better identifier than the input relids themselves? + */ + part_rels[cnt_parts] = fetch_upper_rel(root, UPPERREL_GROUP_AGG, + input_child_rel->relids); + + /* Ignore empty children. They contribute nothing. */ + if (IS_DUMMY_REL(input_child_rel)) + { + mark_dummy_rel(part_rels[cnt_parts]); + continue; + } + else + live_children = lappend(live_children, part_rels[cnt_parts]); + + /* + * Forcibly apply scan/join target to all the Paths for the scan/join + * rel. + * + * In principle we should re-run set_cheapest() here to identify the + * cheapest path, but it seems unlikely that adding the same tlist + * eval costs to all the paths would change that, so we don't bother. + * Instead, just assume that the cheapest-startup and cheapest-total + * paths remain so. (There should be no parameterized paths anymore, + * so we needn't worry about updating cheapest_parameterized_paths.) + */ + scanjoin_target = copy_pathtarget(input_rel->cheapest_startup_path->pathtarget); + scanjoin_target->exprs = (List *) adjust_appendrel_attrs(root, (Node *) scanjoin_target->exprs, + appinfos); + + foreach(lc, input_child_rel->pathlist) + { + Path *subpath = (Path *) lfirst(lc); + Path *path; + + Assert(subpath->param_info == NULL); + path = apply_projection_to_path(root, input_child_rel, + subpath, scanjoin_target); + /* If we had to add a Result, path is different from subpath */ + if (path != subpath) + { + lfirst(lc) = path; + if (subpath == input_child_rel->cheapest_startup_path) + input_child_rel->cheapest_startup_path = path; + if (subpath == input_child_rel->cheapest_total_path) + input_child_rel->cheapest_total_path = path; + } + } + + /* + * TODO: + * We should somehow make this target available for FDWs, which are + * expected to fetch it directly from root->upper_targets. That array + * can hold only one target for each kind of upper rel. We will now + * have many such upper relations. + */ + child_target->exprs = (List *) adjust_appendrel_attrs(root, + (Node *) target->exprs, + appinfos); + + create_grouping_paths(root, input_child_rel, child_target, agg_costs, + rollup_lists, rollup_groupclauses); + + } + + /* + * add_paths_to_append_rel() sets the path target from the given relation. + * In this case grouped_rel doesn't have a target set. So temporarily set + * it. + * TODO: probably we should do something better than this. + */ + grouped_rel->reltarget = target; + add_paths_to_append_rel(root, grouped_rel, live_children); + grouped_rel->reltarget = NULL; +} + +/* + * Returns true if partition keys of the given relation are leading group by + * clauses. + */ +static bool +have_grouping_by_partkey(RelOptInfo *input_rel, PathTarget *target, + List *groupClause) +{ + PartitionScheme part_scheme = input_rel->part_scheme; + ListCell *lc; + List *tlist = make_tlist_from_pathtarget(target); + List *group_exprs = get_sortgrouplist_exprs(groupClause, tlist); + int cnt_pk = 0; + int num_pks; + + /* Input relation should be partitioned. */ + Assert(part_scheme); + + num_pks = part_scheme->partnatts; + + foreach(lc, group_exprs) + { + Expr *group_expr = lfirst(lc); + List *pk_exprs; + + /* All partition keys are present in the group clause. */ + if (cnt_pk >= num_pks) + return true; + + pk_exprs = input_rel->partexprs[cnt_pk]; + + if (!list_member(pk_exprs, group_expr)) + return false; + + cnt_pk++; + } + + /* All partition keys are present in the group clause. */ + if (cnt_pk >= num_pks) + return true; + + return false; +} + +/* * create_window_paths * * Build a new upperrel containing Paths for window-function evaluation. @@ -3959,7 +4209,8 @@ create_window_paths(PlannerInfo *root, if (window_rel->fdwroutine && window_rel->fdwroutine->GetForeignUpperPaths) window_rel->fdwroutine->GetForeignUpperPaths(root, UPPERREL_WINDOW, - input_rel, window_rel); + input_rel, window_rel, + NULL); /* Let extensions possibly add some more paths */ if (create_upper_paths_hook) @@ -4263,7 +4514,8 @@ create_distinct_paths(PlannerInfo *root, if (distinct_rel->fdwroutine && distinct_rel->fdwroutine->GetForeignUpperPaths) distinct_rel->fdwroutine->GetForeignUpperPaths(root, UPPERREL_DISTINCT, - input_rel, distinct_rel); + input_rel, distinct_rel, + NULL); /* Let extensions possibly add some more paths */ if (create_upper_paths_hook) @@ -4405,7 +4657,8 @@ create_ordered_paths(PlannerInfo *root, if (ordered_rel->fdwroutine && ordered_rel->fdwroutine->GetForeignUpperPaths) ordered_rel->fdwroutine->GetForeignUpperPaths(root, UPPERREL_ORDERED, - input_rel, ordered_rel); + input_rel, ordered_rel, + NULL); /* Let extensions possibly add some more paths */ if (create_upper_paths_hook) diff --git a/src/backend/utils/misc/guc.c b/src/backend/utils/misc/guc.c index 7f423c9..0cce5e4 100644 --- a/src/backend/utils/misc/guc.c +++ b/src/backend/utils/misc/guc.c @@ -920,6 +920,15 @@ static struct config_bool ConfigureNamesBool[] = false, NULL, NULL, NULL }, + { + {"enable_partition_wise_agg", PGC_USERSET, QUERY_TUNING_METHOD, + gettext_noop("Enables partition-wise aggregation and grouping."), + NULL + }, + &enable_partition_wise_agg, + true, + NULL, NULL, NULL + }, { {"geqo", PGC_USERSET, QUERY_TUNING_GEQO, diff --git a/src/include/foreign/fdwapi.h b/src/include/foreign/fdwapi.h index 6ca44f7..10fdf6d 100644 --- a/src/include/foreign/fdwapi.h +++ b/src/include/foreign/fdwapi.h @@ -62,7 +62,8 @@ typedef void (*GetForeignJoinPaths_function) (PlannerInfo *root, typedef void (*GetForeignUpperPaths_function) (PlannerInfo *root, UpperRelationKind stage, RelOptInfo *input_rel, - RelOptInfo *output_rel); + RelOptInfo *output_rel, + PathTarget *target); typedef void (*AddForeignUpdateTargets_function) (Query *parsetree, RangeTblEntry *target_rte, diff --git a/src/include/optimizer/cost.h b/src/include/optimizer/cost.h index e7949d37..7cd8e2c 100644 --- a/src/include/optimizer/cost.h +++ b/src/include/optimizer/cost.h @@ -68,6 +68,7 @@ extern bool enable_mergejoin; extern bool enable_hashjoin; extern bool enable_gathermerge; extern bool enable_partition_wise_join; +extern bool enable_partition_wise_agg; extern int constraint_exclusion; extern double clamp_row_est(double nrows); diff --git a/src/include/optimizer/paths.h b/src/include/optimizer/paths.h index f31b70e..77388cc 100644 --- a/src/include/optimizer/paths.h +++ b/src/include/optimizer/paths.h @@ -60,6 +60,8 @@ extern void create_partial_bitmap_paths(PlannerInfo *root, RelOptInfo *rel, Path *bitmapqual); extern void generate_partition_wise_join_paths(PlannerInfo *root, RelOptInfo *rel); +extern void add_paths_to_append_rel(PlannerInfo *root, RelOptInfo *rel, + List *live_childrels); #ifdef OPTIMIZER_DEBUG extern void debug_print_rel(PlannerInfo *root, RelOptInfo *rel); diff --git a/src/test/regress/expected/partition_agg.out b/src/test/regress/expected/partition_agg.out new file mode 100644 index 0000000..315d396 --- /dev/null +++ b/src/test/regress/expected/partition_agg.out @@ -0,0 +1,192 @@ +-- +-- PARTITION_AGG +-- Test partition-wise aggregation on partitioned tables +-- +-- Enable partition-wise join, which by default is disabled. +SET enable_partition_wise_join TO true; +-- +-- Tests for list partitioned tables. +-- +CREATE TABLE ptab1 (a int, b int, c text) PARTITION BY LIST(c); +CREATE TABLE ptab1_p1 PARTITION OF ptab1 FOR VALUES IN ('0000', '0003', '0004', '0010'); +CREATE TABLE ptab1_p2 PARTITION OF ptab1 FOR VALUES IN ('0001', '0005', '0002', '0009'); +CREATE TABLE ptab1_p3 PARTITION OF ptab1 FOR VALUES IN ('0006', '0007', '0008', '0011'); +INSERT INTO ptab1 SELECT i, i, to_char(i/50, 'FM0000') FROM generate_series(0, 599, 2) i; +ANALYZE ptab1; +ANALYZE ptab1_p1; +ANALYZE ptab1_p2; +ANALYZE ptab1_p3; +-- TODO: This table is created only for testing the results. Remove once +-- results are tested. +CREATE TABLE uptab1 AS SELECT * FROM ptab1; +ANALYZE uptab1; +EXPLAIN (VERBOSE, COSTS OFF) +SELECT c, sum(a), avg(b), COUNT(*) FROM ptab1 GROUP BY c ORDER BY 1, 2, 3; +NOTICE: partition-wise grouping is possible. + QUERY PLAN +------------------------------------------------------------------------------ + Sort + Output: ptab1_p1.c, (sum(ptab1_p1.a)), (avg(ptab1_p1.b)), (count(*)) + Sort Key: ptab1_p1.c, (sum(ptab1_p1.a)), (avg(ptab1_p1.b)) + -> Append + -> HashAggregate + Output: ptab1_p1.c, sum(ptab1_p1.a), avg(ptab1_p1.b), count(*) + Group Key: ptab1_p1.c + -> Seq Scan on public.ptab1_p1 + Output: ptab1_p1.c, ptab1_p1.a, ptab1_p1.b + -> HashAggregate + Output: ptab1_p2.c, sum(ptab1_p2.a), avg(ptab1_p2.b), count(*) + Group Key: ptab1_p2.c + -> Seq Scan on public.ptab1_p2 + Output: ptab1_p2.c, ptab1_p2.a, ptab1_p2.b + -> HashAggregate + Output: ptab1_p3.c, sum(ptab1_p3.a), avg(ptab1_p3.b), count(*) + Group Key: ptab1_p3.c + -> Seq Scan on public.ptab1_p3 + Output: ptab1_p3.c, ptab1_p3.a, ptab1_p3.b +(19 rows) + +SELECT c, sum(a), avg(b), COUNT(*) FROM ptab1 GROUP BY c ORDER BY 1, 2, 3; +NOTICE: partition-wise grouping is possible. + c | sum | avg | count +------+-------+----------------------+------- + 0000 | 600 | 24.0000000000000000 | 25 + 0001 | 1850 | 74.0000000000000000 | 25 + 0002 | 3100 | 124.0000000000000000 | 25 + 0003 | 4350 | 174.0000000000000000 | 25 + 0004 | 5600 | 224.0000000000000000 | 25 + 0005 | 6850 | 274.0000000000000000 | 25 + 0006 | 8100 | 324.0000000000000000 | 25 + 0007 | 9350 | 374.0000000000000000 | 25 + 0008 | 10600 | 424.0000000000000000 | 25 + 0009 | 11850 | 474.0000000000000000 | 25 + 0010 | 13100 | 524.0000000000000000 | 25 + 0011 | 14350 | 574.0000000000000000 | 25 +(12 rows) + +SELECT c, sum(a), avg(b), COUNT(*) FROM uptab1 GROUP BY c ORDER BY 1, 2, 3; + c | sum | avg | count +------+-------+----------------------+------- + 0000 | 600 | 24.0000000000000000 | 25 + 0001 | 1850 | 74.0000000000000000 | 25 + 0002 | 3100 | 124.0000000000000000 | 25 + 0003 | 4350 | 174.0000000000000000 | 25 + 0004 | 5600 | 224.0000000000000000 | 25 + 0005 | 6850 | 274.0000000000000000 | 25 + 0006 | 8100 | 324.0000000000000000 | 25 + 0007 | 9350 | 374.0000000000000000 | 25 + 0008 | 10600 | 424.0000000000000000 | 25 + 0009 | 11850 | 474.0000000000000000 | 25 + 0010 | 13100 | 524.0000000000000000 | 25 + 0011 | 14350 | 574.0000000000000000 | 25 +(12 rows) + +-- JOIN query +EXPLAIN (VERBOSE, COSTS OFF) +SELECT t1.c, sum(t1.a), avg(t1.b), COUNT(*) FROM ptab1 t1, ptab1 t2 WHERE t1.c = t2.c GROUP BY t1.c ORDER BY 1, 2, 3; +NOTICE: partition-wise grouping is possible. + QUERY PLAN +------------------------------------------------------------------ + Sort + Output: t1.c, (sum(t1.a)), (avg(t1.b)), (count(*)) + Sort Key: t1.c, (sum(t1.a)), (avg(t1.b)) + -> Append + -> HashAggregate + Output: t1.c, sum(t1.a), avg(t1.b), count(*) + Group Key: t1.c + -> Hash Join + Output: t1.c, t1.a, t1.b + Hash Cond: (t1.c = t2.c) + -> Seq Scan on public.ptab1_p1 t1 + Output: t1.c, t1.a, t1.b + -> Hash + Output: t2.c + -> Seq Scan on public.ptab1_p1 t2 + Output: t2.c + -> HashAggregate + Output: t1_1.c, sum(t1_1.a), avg(t1_1.b), count(*) + Group Key: t1_1.c + -> Hash Join + Output: t1_1.c, t1_1.a, t1_1.b + Hash Cond: (t1_1.c = t2_1.c) + -> Seq Scan on public.ptab1_p2 t1_1 + Output: t1_1.c, t1_1.a, t1_1.b + -> Hash + Output: t2_1.c + -> Seq Scan on public.ptab1_p2 t2_1 + Output: t2_1.c + -> HashAggregate + Output: t1_2.c, sum(t1_2.a), avg(t1_2.b), count(*) + Group Key: t1_2.c + -> Hash Join + Output: t1_2.c, t1_2.a, t1_2.b + Hash Cond: (t1_2.c = t2_2.c) + -> Seq Scan on public.ptab1_p3 t1_2 + Output: t1_2.c, t1_2.a, t1_2.b + -> Hash + Output: t2_2.c + -> Seq Scan on public.ptab1_p3 t2_2 + Output: t2_2.c +(40 rows) + +SELECT t1.c, sum(t1.a), avg(t1.b), COUNT(*) FROM ptab1 t1, ptab1 t2 WHERE t1.c = t2.c GROUP BY t1.c ORDER BY 1, 2, 3; +NOTICE: partition-wise grouping is possible. + c | sum | avg | count +------+--------+----------------------+------- + 0000 | 15000 | 24.0000000000000000 | 625 + 0001 | 46250 | 74.0000000000000000 | 625 + 0002 | 77500 | 124.0000000000000000 | 625 + 0003 | 108750 | 174.0000000000000000 | 625 + 0004 | 140000 | 224.0000000000000000 | 625 + 0005 | 171250 | 274.0000000000000000 | 625 + 0006 | 202500 | 324.0000000000000000 | 625 + 0007 | 233750 | 374.0000000000000000 | 625 + 0008 | 265000 | 424.0000000000000000 | 625 + 0009 | 296250 | 474.0000000000000000 | 625 + 0010 | 327500 | 524.0000000000000000 | 625 + 0011 | 358750 | 574.0000000000000000 | 625 +(12 rows) + +SELECT t1.c, sum(t1.a), avg(t1.b), COUNT(*) FROM uptab1 t1, uptab1 t2 WHERE t1.c = t2.c GROUP BY t1.c ORDER BY 1, 2, 3; + c | sum | avg | count +------+--------+----------------------+------- + 0000 | 15000 | 24.0000000000000000 | 625 + 0001 | 46250 | 74.0000000000000000 | 625 + 0002 | 77500 | 124.0000000000000000 | 625 + 0003 | 108750 | 174.0000000000000000 | 625 + 0004 | 140000 | 224.0000000000000000 | 625 + 0005 | 171250 | 274.0000000000000000 | 625 + 0006 | 202500 | 324.0000000000000000 | 625 + 0007 | 233750 | 374.0000000000000000 | 625 + 0008 | 265000 | 424.0000000000000000 | 625 + 0009 | 296250 | 474.0000000000000000 | 625 + 0010 | 327500 | 524.0000000000000000 | 625 + 0011 | 358750 | 574.0000000000000000 | 625 +(12 rows) + +-- Negative testcase +EXPLAIN (VERBOSE, COSTS OFF) +SELECT COUNT(*) FROM ptab1 GROUP BY a; + QUERY PLAN +----------------------------------------- + HashAggregate + Output: count(*), ptab1.a + Group Key: ptab1.a + -> Append + -> Seq Scan on public.ptab1 + Output: ptab1.a + -> Seq Scan on public.ptab1_p1 + Output: ptab1_p1.a + -> Seq Scan on public.ptab1_p2 + Output: ptab1_p2.a + -> Seq Scan on public.ptab1_p3 + Output: ptab1_p3.a +(12 rows) + +-- Cleanup +DROP TABLE uptab1; +DROP TABLE ptab1_p3; +DROP TABLE ptab1_p2; +DROP TABLE ptab1_p1; +DROP TABLE ptab1; +RESET enable_partition_wise_join; diff --git a/src/test/regress/expected/partition_join.out b/src/test/regress/expected/partition_join.out index 27f09fa..67c2041 100644 --- a/src/test/regress/expected/partition_join.out +++ b/src/test/regress/expected/partition_join.out @@ -1399,44 +1399,49 @@ ANALYZE plt1_e; -- test partition matching with N-way join EXPLAIN (COSTS OFF) SELECT avg(t1.a), avg(t2.b), avg(t3.a + t3.b), t1.c, t2.c, t3.c FROM plt1 t1, plt2 t2, plt1_e t3 WHERE t1.c = t2.c AND ltrim(t3.c, 'A') = t1.c GROUP BY t1.c, t2.c, t3.c ORDER BY t1.c, t2.c, t3.c; - QUERY PLAN --------------------------------------------------------------------------------------- +NOTICE: partition-wise grouping is possible. + QUERY PLAN +-------------------------------------------------------------------------------- Sort Sort Key: t1.c, t3.c - -> HashAggregate - Group Key: t1.c, t2.c, t3.c - -> Result - -> Append - -> Hash Join - Hash Cond: (t1.c = t2.c) - -> Seq Scan on plt1_p1 t1 - -> Hash - -> Hash Join - Hash Cond: (t2.c = ltrim(t3.c, 'A'::text)) - -> Seq Scan on plt2_p1 t2 - -> Hash - -> Seq Scan on plt1_e_p1 t3 - -> Hash Join - Hash Cond: (t1_1.c = t2_1.c) - -> Seq Scan on plt1_p2 t1_1 - -> Hash - -> Hash Join - Hash Cond: (t2_1.c = ltrim(t3_1.c, 'A'::text)) - -> Seq Scan on plt2_p2 t2_1 - -> Hash - -> Seq Scan on plt1_e_p2 t3_1 - -> Hash Join - Hash Cond: (t1_2.c = t2_2.c) - -> Seq Scan on plt1_p3 t1_2 - -> Hash - -> Hash Join - Hash Cond: (t2_2.c = ltrim(t3_2.c, 'A'::text)) - -> Seq Scan on plt2_p3 t2_2 - -> Hash - -> Seq Scan on plt1_e_p3 t3_2 -(33 rows) + -> Append + -> HashAggregate + Group Key: t1.c, t2.c, t3.c + -> Hash Join + Hash Cond: (t1.c = t2.c) + -> Seq Scan on plt1_p1 t1 + -> Hash + -> Hash Join + Hash Cond: (t2.c = ltrim(t3.c, 'A'::text)) + -> Seq Scan on plt2_p1 t2 + -> Hash + -> Seq Scan on plt1_e_p1 t3 + -> HashAggregate + Group Key: t1_1.c, t2_1.c, t3_1.c + -> Hash Join + Hash Cond: (t1_1.c = t2_1.c) + -> Seq Scan on plt1_p2 t1_1 + -> Hash + -> Hash Join + Hash Cond: (t2_1.c = ltrim(t3_1.c, 'A'::text)) + -> Seq Scan on plt2_p2 t2_1 + -> Hash + -> Seq Scan on plt1_e_p2 t3_1 + -> HashAggregate + Group Key: t1_2.c, t2_2.c, t3_2.c + -> Hash Join + Hash Cond: (t1_2.c = t2_2.c) + -> Seq Scan on plt1_p3 t1_2 + -> Hash + -> Hash Join + Hash Cond: (t2_2.c = ltrim(t3_2.c, 'A'::text)) + -> Seq Scan on plt2_p3 t2_2 + -> Hash + -> Seq Scan on plt1_e_p3 t3_2 +(36 rows) SELECT avg(t1.a), avg(t2.b), avg(t3.a + t3.b), t1.c, t2.c, t3.c FROM plt1 t1, plt2 t2, plt1_e t3 WHERE t1.c = t2.c AND ltrim(t3.c, 'A') = t1.c GROUP BY t1.c, t2.c, t3.c ORDER BY t1.c, t2.c, t3.c; +NOTICE: partition-wise grouping is possible. avg | avg | avg | c | c | c ----------------------+----------------------+-----------------------+------+------+------- 24.0000000000000000 | 24.0000000000000000 | 48.0000000000000000 | 0000 | 0000 | A0000 diff --git a/src/test/regress/expected/sysviews.out b/src/test/regress/expected/sysviews.out index cd1f7f3..f4cd466 100644 --- a/src/test/regress/expected/sysviews.out +++ b/src/test/regress/expected/sysviews.out @@ -81,11 +81,12 @@ select name, setting from pg_settings where name like 'enable%'; enable_material | on enable_mergejoin | on enable_nestloop | on + enable_partition_wise_agg | on enable_partition_wise_join | off enable_seqscan | on enable_sort | on enable_tidscan | on -(13 rows) +(14 rows) -- Test that the pg_timezone_names and pg_timezone_abbrevs views are -- more-or-less working. We can't test their contents in any great detail diff --git a/src/test/regress/parallel_schedule b/src/test/regress/parallel_schedule index 966984d..56c07d3 100644 --- a/src/test/regress/parallel_schedule +++ b/src/test/regress/parallel_schedule @@ -104,6 +104,10 @@ test: publication subscription # Another group of parallel tests # ---------- test: select_views portals_p2 foreign_key cluster dependency guc bitmapops combocid tsearch tsdicts foreign_data window xmlmap functional_deps advisory_lock json jsonb json_encoding indirect_toast equivclass partition_join multi_level_partition_join +# TODO: should be added in parallel tests above, but before that need to make +# sure we have unique objects to avoid any concurrency issues. +test: partition_agg + # ---------- # Another group of parallel tests # NB: temp.sql does a reconnect which transiently uses 2 connections, diff --git a/src/test/regress/sql/partition_agg.sql b/src/test/regress/sql/partition_agg.sql new file mode 100644 index 0000000..df6dd9c --- /dev/null +++ b/src/test/regress/sql/partition_agg.sql @@ -0,0 +1,48 @@ +-- +-- PARTITION_AGG +-- Test partition-wise aggregation on partitioned tables +-- + +-- Enable partition-wise join, which by default is disabled. +SET enable_partition_wise_join TO true; + +-- +-- Tests for list partitioned tables. +-- +CREATE TABLE ptab1 (a int, b int, c text) PARTITION BY LIST(c); +CREATE TABLE ptab1_p1 PARTITION OF ptab1 FOR VALUES IN ('0000', '0003', '0004', '0010'); +CREATE TABLE ptab1_p2 PARTITION OF ptab1 FOR VALUES IN ('0001', '0005', '0002', '0009'); +CREATE TABLE ptab1_p3 PARTITION OF ptab1 FOR VALUES IN ('0006', '0007', '0008', '0011'); +INSERT INTO ptab1 SELECT i, i, to_char(i/50, 'FM0000') FROM generate_series(0, 599, 2) i; +ANALYZE ptab1; +ANALYZE ptab1_p1; +ANALYZE ptab1_p2; +ANALYZE ptab1_p3; +-- TODO: This table is created only for testing the results. Remove once +-- results are tested. +CREATE TABLE uptab1 AS SELECT * FROM ptab1; +ANALYZE uptab1; + +EXPLAIN (VERBOSE, COSTS OFF) +SELECT c, sum(a), avg(b), COUNT(*) FROM ptab1 GROUP BY c ORDER BY 1, 2, 3; +SELECT c, sum(a), avg(b), COUNT(*) FROM ptab1 GROUP BY c ORDER BY 1, 2, 3; +SELECT c, sum(a), avg(b), COUNT(*) FROM uptab1 GROUP BY c ORDER BY 1, 2, 3; + +-- JOIN query +EXPLAIN (VERBOSE, COSTS OFF) +SELECT t1.c, sum(t1.a), avg(t1.b), COUNT(*) FROM ptab1 t1, ptab1 t2 WHERE t1.c = t2.c GROUP BY t1.c ORDER BY 1, 2, 3; +SELECT t1.c, sum(t1.a), avg(t1.b), COUNT(*) FROM ptab1 t1, ptab1 t2 WHERE t1.c = t2.c GROUP BY t1.c ORDER BY 1, 2, 3; +SELECT t1.c, sum(t1.a), avg(t1.b), COUNT(*) FROM uptab1 t1, uptab1 t2 WHERE t1.c = t2.c GROUP BY t1.c ORDER BY 1, 2, 3; + + +-- Negative testcase +EXPLAIN (VERBOSE, COSTS OFF) +SELECT COUNT(*) FROM ptab1 GROUP BY a; + +-- Cleanup +DROP TABLE uptab1; +DROP TABLE ptab1_p3; +DROP TABLE ptab1_p2; +DROP TABLE ptab1_p1; +DROP TABLE ptab1; +RESET enable_partition_wise_join;