diff --git a/src/backend/nodes/copyfuncs.c b/src/backend/nodes/copyfuncs.c new file mode 100644 index 930f2f1..59836ba *** a/src/backend/nodes/copyfuncs.c --- b/src/backend/nodes/copyfuncs.c *************** _copyAggref(const Aggref *from) *** 1245,1250 **** --- 1245,1251 ---- COPY_SCALAR_FIELD(aggstar); COPY_SCALAR_FIELD(aggvariadic); COPY_SCALAR_FIELD(aggkind); + COPY_SCALAR_FIELD(aggtransmultifn); COPY_SCALAR_FIELD(agglevelsup); COPY_SCALAR_FIELD(aggsplit); COPY_LOCATION_FIELD(location); diff --git a/src/backend/nodes/outfuncs.c b/src/backend/nodes/outfuncs.c new file mode 100644 index 806d0a9..8e789fe *** a/src/backend/nodes/outfuncs.c --- b/src/backend/nodes/outfuncs.c *************** _outPlannerInfo(StringInfo str, const Pl *** 2046,2051 **** --- 2046,2053 ---- WRITE_NODE_FIELD(append_rel_list); WRITE_NODE_FIELD(rowMarks); WRITE_NODE_FIELD(placeholder_list); + WRITE_NODE_FIELD(grouped_var_list); + WRITE_BOOL_FIELD(all_baserels_grouped); WRITE_NODE_FIELD(fkey_list); WRITE_NODE_FIELD(query_pathkeys); WRITE_NODE_FIELD(group_pathkeys); diff --git a/src/backend/optimizer/geqo/geqo_eval.c b/src/backend/optimizer/geqo/geqo_eval.c new file mode 100644 index b5cab0c..f89406d *** a/src/backend/optimizer/geqo/geqo_eval.c --- b/src/backend/optimizer/geqo/geqo_eval.c *************** merge_clump(PlannerInfo *root, List *clu *** 265,271 **** if (joinrel) { /* Create GatherPaths for any useful partial paths for rel */ ! generate_gather_paths(root, joinrel); /* Find and save the cheapest paths for this joinrel */ set_cheapest(joinrel); --- 265,271 ---- if (joinrel) { /* Create GatherPaths for any useful partial paths for rel */ ! generate_gather_paths(root, joinrel, false); /* Find and save the cheapest paths for this joinrel */ set_cheapest(joinrel); diff --git a/src/backend/optimizer/path/allpaths.c b/src/backend/optimizer/path/allpaths.c new file mode 100644 index 46d7d06..46a6d18 *** a/src/backend/optimizer/path/allpaths.c --- b/src/backend/optimizer/path/allpaths.c *************** *** 20,29 **** --- 20,35 ---- #include "access/sysattr.h" #include "access/tsmapi.h" + /* + * TODO Consider moving COUNTFNOID away from pg_aggregate.h so it doesn't + * have to be included. + */ + #include "catalog/pg_aggregate.h" #include "catalog/pg_class.h" #include "catalog/pg_operator.h" #include "catalog/pg_proc.h" #include "foreign/fdwapi.h" + #include "miscadmin.h" #include "nodes/makefuncs.h" #include "nodes/nodeFuncs.h" #ifdef OPTIMIZER_DEBUG *************** *** 44,50 **** #include "parser/parsetree.h" #include "rewrite/rewriteManip.h" #include "utils/lsyscache.h" ! /* results of subquery_is_pushdown_safe */ typedef struct pushdown_safety_info --- 50,56 ---- #include "parser/parsetree.h" #include "rewrite/rewriteManip.h" #include "utils/lsyscache.h" ! #include "utils/selfuncs.h" /* results of subquery_is_pushdown_safe */ typedef struct pushdown_safety_info *************** static void set_rel_pathlist(PlannerInfo *** 76,81 **** --- 82,89 ---- static void set_plain_rel_size(PlannerInfo *root, RelOptInfo *rel, RangeTblEntry *rte); static void create_plain_partial_paths(PlannerInfo *root, RelOptInfo *rel); + static void create_plain_grouped_path(PlannerInfo *root, RelOptInfo *rel, + Path *subpath, bool partial); static void set_rel_consider_parallel(PlannerInfo *root, RelOptInfo *rel, RangeTblEntry *rte); static void set_plain_rel_pathlist(PlannerInfo *root, RelOptInfo *rel, *************** RelOptInfo * *** 137,143 **** make_one_rel(PlannerInfo *root, List *joinlist) { RelOptInfo *rel; ! Index rti; /* * Construct the all_baserels Relids set. --- 145,151 ---- make_one_rel(PlannerInfo *root, List *joinlist) { RelOptInfo *rel; ! Index rti; /* * Construct the all_baserels Relids set. *************** make_one_rel(PlannerInfo *root, List *jo *** 151,157 **** if (brel == NULL) continue; ! Assert(brel->relid == rti); /* sanity check on array */ /* ignore RTEs that are "other rels" */ if (brel->reloptkind != RELOPT_BASEREL) --- 159,165 ---- if (brel == NULL) continue; ! Assert(brel->relid == rti); /* sanity check on array */ /* ignore RTEs that are "other rels" */ if (brel->reloptkind != RELOPT_BASEREL) *************** set_rel_pathlist(PlannerInfo *root, RelO *** 457,463 **** * we'll consider gathering partial paths for the parent appendrel.) */ if (rel->reloptkind == RELOPT_BASEREL) ! generate_gather_paths(root, rel); /* * Allow a plugin to editorialize on the set of Paths for this base --- 465,474 ---- * we'll consider gathering partial paths for the parent appendrel.) */ if (rel->reloptkind == RELOPT_BASEREL) ! { ! generate_gather_paths(root, rel, false); ! generate_gather_paths(root, rel, true); ! } /* * Allow a plugin to editorialize on the set of Paths for this base *************** static void *** 647,652 **** --- 658,664 ---- set_plain_rel_pathlist(PlannerInfo *root, RelOptInfo *rel, RangeTblEntry *rte) { Relids required_outer; + Path *seq_path; /* * We don't support pushing join clauses into the quals of a seqscan, but *************** set_plain_rel_pathlist(PlannerInfo *root *** 655,664 **** */ required_outer = rel->lateral_relids; ! /* Consider sequential scan */ ! add_path(rel, create_seqscan_path(root, rel, required_outer, 0)); ! /* If appropriate, consider parallel sequential scan */ if (rel->consider_parallel && required_outer == NULL) create_plain_partial_paths(root, rel); --- 667,679 ---- */ required_outer = rel->lateral_relids; ! /* Consider sequential scan, both plain and grouped. */ ! seq_path = create_seqscan_path(root, rel, required_outer, 0); ! add_path(rel, seq_path, false); ! if (rel->reltarget_grouped != NULL && required_outer == NULL) ! create_plain_grouped_path(root, rel, seq_path, false); ! /* If appropriate, consider parallel sequential scan (plain or grouped) */ if (rel->consider_parallel && required_outer == NULL) create_plain_partial_paths(root, rel); *************** static void *** 677,682 **** --- 692,698 ---- create_plain_partial_paths(PlannerInfo *root, RelOptInfo *rel) { int parallel_workers; + Path *path; /* * If the user has set the parallel_workers reloption, use that; otherwise *************** create_plain_partial_paths(PlannerInfo * *** 727,733 **** return; /* Add an unordered partial path based on a parallel sequential scan. */ ! add_partial_path(rel, create_seqscan_path(root, rel, NULL, parallel_workers)); } /* --- 743,902 ---- return; /* Add an unordered partial path based on a parallel sequential scan. */ ! path = create_seqscan_path(root, rel, NULL, parallel_workers); ! add_partial_path(rel, path, false); ! ! /* ! * Do partial aggregation at base relation level if the relation is ! * eligible for it. (And if we can expect that the final join can be built ! * out of grouped rels.) ! */ ! if (root->all_baserels_grouped && rel->reltarget_grouped != NULL) ! create_plain_grouped_path(root, rel, path, true); ! } ! ! /* ! * Apply (partial) aggregation to a subpath. ! * ! * "partial" argument tells whether both subpath and the resulting path are ! * partial or not. ! * ! * As we modify the subpath here, copy is taken before we adjust it. ! */ ! static void ! create_plain_grouped_path(PlannerInfo *root, RelOptInfo *rel, Path *subpath, ! bool partial) ! { ! Query *parse = root->parse; ! ListCell *lc; ! Expr *texpr; ! AggClauseCosts agg_costs; ! AggPath *agg_path; ! List *group_clause = NIL; ! List *group_exprs = NIL; ! List *agg_exprs = NIL; ! bool can_hash; ! Size hashaggtablesize; ! int i; ! double dNumGroups; ! Path *subpath_tmp; ! PathTarget *target_grouped = rel->reltarget_grouped; ! ! /* Copy the subpath before doing changes. */ ! subpath_tmp = makeNode(Path); ! memcpy(subpath_tmp, subpath, sizeof(Path)); ! subpath = subpath_tmp; ! ! /* The "grouped target" should contain grouping expressions, and these ! * should have non-zero sortgroupref. ! */ ! Assert(target_grouped->sortgrouprefs != NULL); ! ! /* ! * Find one grouping clause per grouping column and make sure ! * subpath->pathtarget entries have sortgroupref initialized. ! */ ! i = 0; ! foreach(lc, target_grouped->exprs) ! { ! Index sortgroupref; ! SortGroupClause *cl; ! ! texpr = (Expr *) lfirst(lc); ! sortgroupref = target_grouped->sortgrouprefs[i++]; ! ! if (sortgroupref == 0) ! { ! /* ! * Looks like "grouped var" representing Aggref - these should ! * appear at the end of the list. ! */ ! break; ! } ! ! /* ! * Find the clause by sortgroupref. ! * ! * All that create_agg_plan eventually needs of the clause is ! * tleSortGroupRef, so we don't have to care that the clause ! * expression might differ from texpr, in case texpr was derived from ! * EC. ! */ ! cl = get_sortgroupref_clause(sortgroupref, root->parse->groupClause); ! group_clause = lappend(group_clause, cl); ! group_exprs = lappend(group_exprs, texpr); ! } ! ! /* Now collect the aggregates. */ ! while (lc != NULL) ! { ! texpr = (Expr *) lfirst(lc); ! ! /* ! * texpr still contains the replacement var, so restore the actual ! * Aggref expression. ! */ ! Assert(IsA(texpr, Var)); ! agg_exprs = lappend(agg_exprs, find_grouped_var_expr(root, ! (Var *) texpr)); ! lc = lnext(lc); ! } ! ! Assert(agg_exprs != NIL); ! MemSet(&agg_costs, 0, sizeof(AggClauseCosts)); ! get_agg_clause_costs(root, (Node *) agg_exprs, AGGSPLIT_INITIAL_SERIAL, ! &agg_costs); ! ! can_hash = (parse->groupClause != NIL && ! parse->groupingSets == NIL && ! agg_costs.numOrderedAggs == 0 && ! grouping_is_hashable(parse->groupClause)); ! ! /* TODO Consider other kinds of aggregation. */ ! if (!can_hash) ! return; ! ! Assert(group_exprs != NIL); ! dNumGroups = estimate_num_groups(root, group_exprs, subpath->rows, NULL); ! ! hashaggtablesize = estimate_hashagg_tablesize(subpath, &agg_costs, ! dNumGroups); ! ! if (hashaggtablesize < work_mem * 1024L) ! { ! /* ! * Create the partial aggregation path. ! * ! * Note that target contains "grouped vars" (see GroupedVarInfo) ! * instead of Aggref expressions so far. Thus set_upper_references can ! * easily link TLEs of the upper node (which is not necessarily the ! * final Agg node) to the output of the patial Agg plan. Once ! * descended to this partial Agg node, set_upper_references will ! * install the Aggref expressions. ! */ ! Assert(group_clause != NIL); ! agg_path = create_agg_path(root, ! rel, ! subpath, ! target_grouped, ! AGG_HASHED, ! AGGSPLIT_INITIAL_SERIAL, ! group_clause, ! NIL, ! &agg_costs, ! dNumGroups); ! ! /* ! * The agg path should require no fewer parameters than the plain one. ! */ ! agg_path->path.param_info = subpath->param_info; ! ! /* Finally add the grouped path to the list of grouped base paths. */ ! if (!partial) ! add_path(rel, (Path *) agg_path, true); ! else ! add_partial_path(rel, (Path *) agg_path, true); ! } } /* *************** set_tablesample_rel_pathlist(PlannerInfo *** 813,819 **** path = (Path *) create_material_path(rel, path); } ! add_path(rel, path); /* For the moment, at least, there are no other paths to consider */ } --- 982,988 ---- path = (Path *) create_material_path(rel, path); } ! add_path(rel, path, false); /* For the moment, at least, there are no other paths to consider */ } *************** set_append_rel_size(PlannerInfo *root, R *** 980,985 **** --- 1149,1279 ---- appinfo); /* + * If grouping is applicable to the parent relation, it's applicable + * to the children too. Make sure it has valid sortgrouprefs. + */ + if (rel->reltarget->sortgrouprefs) + { + Assert(childrel->reltarget->sortgrouprefs == NULL); + childrel->reltarget->sortgrouprefs = rel->reltarget->sortgrouprefs; + } + + /* + * Also the grouped target needs to be adjusted, if one exists. + * + * TODO Move this to separate function? + */ + if (root->all_baserels_grouped && rel->reltarget_grouped != NULL) + { + PathTarget *target; + ListCell *l2; + int i; + List *aggregates = NIL; + Aggref *countagg = NULL; + + target = rel->reltarget_grouped; + Assert(target->sortgrouprefs != NULL); + childrel->reltarget_grouped = create_empty_pathtarget(); + + /* + * It makes sense to treat the grouping expressions separate from + * the aggregates. + * + * TODO As we do similar thing in create_plain_grouped_path, + * consider storing 2 separate lists, or moving the repeated logic + * into a function. + */ + i = 0; + foreach(l2, rel->reltarget_grouped->exprs) + { + Index sortgroupref; + Expr *texpr, *texpr_translated; + + sortgroupref = target->sortgrouprefs[i++]; + if (sortgroupref == 0) + /* The first aggregate in the list. */ + break; + + /* + * Adjust vars so the expression references the child relation + * and add it to the child rel's grouping target. + */ + texpr = (Expr *) lfirst(l2); + texpr_translated = (Expr *) + adjust_appendrel_attrs(root, (Node *) texpr, appinfo); + add_column_to_pathtarget(childrel->reltarget_grouped, + texpr_translated, sortgroupref); + } + /* At least one grouping expression must be there. */ + Assert(list_length(childrel->reltarget_grouped->exprs) > 0); + + /* + * The aggregates should follow, but already in the form of + * "grouped vars". + */ + while (l2 != NULL) + { + Var *gvar; + Aggref *aggref; + GroupedVarInfo *gvi_parent = NULL; + ListCell *l3; + + gvar = (Var *) lfirst(l2); + Assert(IsA(gvar, Var)); + + /* Retrieve the parent's grouped var. */ + foreach(l3, root->grouped_var_list) + { + GroupedVarInfo *gvi = (GroupedVarInfo *) lfirst(l3); + + if (gvi->var->varno == gvar->varno && + gvi->var->varattno == gvar->varattno) + { + gvi_parent = gvi; + break; + } + } + Assert(gvi_parent != NULL); + + /* Translate the aggregate so it references the child rel. */ + aggref = (Aggref *) gvi_parent->expr; + Assert(IsA(aggref, Aggref)); + + if (aggregates == NIL) + { + /* + * The count(*) added by build_base_rel_tlist_grouped + * should be the first aggregate in the targetlist. No + * translation is applicable here. + */ + Assert(aggref->aggfnoid == COUNTFNOID && aggref->aggstar); + countagg = aggref; + } + else + aggref = (Aggref *) + adjust_appendrel_attrs(root, (Node *) aggref, + appinfo); + aggregates = lappend(aggregates, aggref); + + l2 = lnext(l2); + } + + /* At least the count(*) aggregate should be there. */ + Assert(list_length(aggregates) > 0); + + Assert(countagg != NULL); + /* + * The count(*) aggregate needs to be evaluated for child + * relation, but the result will be referenced via the parent + * rel. So don't pass countagg_vars here. + * + * Aggregates are already marked as partial. + */ + add_aggregates_to_grouped_target(root, aggregates, childrel, + countagg, NULL, false); + } + + /* * We have to make child entries in the EquivalenceClass data * structures as well. This is needed either if the parent * participates in some eclass joins (because we will want to consider *************** set_append_rel_pathlist(PlannerInfo *roo *** 1126,1131 **** --- 1420,1427 ---- bool subpaths_valid = true; List *partial_subpaths = NIL; bool partial_subpaths_valid = true; + List *grouped_subpaths = NIL; + bool grouped_subpaths_valid = true; List *all_child_pathkeys = NIL; List *all_child_outers = NIL; ListCell *l; *************** set_append_rel_pathlist(PlannerInfo *roo *** 1197,1202 **** --- 1493,1521 ---- partial_subpaths_valid = false; /* + * For grouped paths, use only the unparameterized subpaths. + * + * XXX Consider if the parameterized subpaths should be processed + * below. It's probably not useful for sequential scans (due to + * repeated aggregation), but might be worthwhile for other child + * nodes. + */ + if (childrel->grouped_pathlist != NIL) + { + Path *path; + + path = (Path *) linitial(childrel->grouped_pathlist); + if (path->param_info == NULL) + grouped_subpaths = accumulate_append_subpath(grouped_subpaths, + path); + else + grouped_subpaths_valid = false; + } + else + grouped_subpaths_valid = false; + + + /* * Collect lists of all the available path orderings and * parameterizations for all the children. We use these as a * heuristic to indicate which sort orderings and parameterizations we *************** set_append_rel_pathlist(PlannerInfo *roo *** 1267,1273 **** * if we have zero or one live subpath due to constraint exclusion.) */ if (subpaths_valid) ! add_path(rel, (Path *) create_append_path(rel, subpaths, NULL, 0)); /* * Consider an append of partial unordered, unparameterized partial paths. --- 1586,1593 ---- * if we have zero or one live subpath due to constraint exclusion.) */ if (subpaths_valid) ! add_path(rel, (Path *) create_append_path(rel, subpaths, NULL, 0), ! false); /* * Consider an append of partial unordered, unparameterized partial paths. *************** set_append_rel_pathlist(PlannerInfo *roo *** 1295,1301 **** /* Generate a partial append path. */ appendpath = create_append_path(rel, partial_subpaths, NULL, parallel_workers); ! add_partial_path(rel, (Path *) appendpath); } /* --- 1615,1631 ---- /* Generate a partial append path. */ appendpath = create_append_path(rel, partial_subpaths, NULL, parallel_workers); ! add_partial_path(rel, (Path *) appendpath, false); ! } ! ! if (grouped_subpaths_valid) ! { ! Path *path; ! ! path = (Path *) create_append_path(rel, grouped_subpaths, NULL, 0); ! /* pathtarget will produce the grouped relation.. */ ! path->pathtarget = rel->reltarget_grouped; ! add_path(rel, path, true); } /* *************** set_append_rel_pathlist(PlannerInfo *roo *** 1346,1352 **** if (subpaths_valid) add_path(rel, (Path *) ! create_append_path(rel, subpaths, required_outer, 0)); } } --- 1676,1683 ---- if (subpaths_valid) add_path(rel, (Path *) ! create_append_path(rel, subpaths, required_outer, 0), ! false); } } *************** generate_mergeappend_paths(PlannerInfo * *** 1438,1450 **** rel, startup_subpaths, pathkeys, ! NULL)); if (startup_neq_total) add_path(rel, (Path *) create_merge_append_path(root, rel, total_subpaths, pathkeys, ! NULL)); } } --- 1769,1781 ---- rel, startup_subpaths, pathkeys, ! NULL), false); if (startup_neq_total) add_path(rel, (Path *) create_merge_append_path(root, rel, total_subpaths, pathkeys, ! NULL), false); } } *************** set_dummy_rel_pathlist(RelOptInfo *rel) *** 1576,1582 **** rel->pathlist = NIL; rel->partial_pathlist = NIL; ! add_path(rel, (Path *) create_append_path(rel, NIL, NULL, 0)); /* * We set the cheapest path immediately, to ensure that IS_DUMMY_REL() --- 1907,1913 ---- rel->pathlist = NIL; rel->partial_pathlist = NIL; ! add_path(rel, (Path *) create_append_path(rel, NIL, NULL, 0), false); /* * We set the cheapest path immediately, to ensure that IS_DUMMY_REL() *************** set_subquery_pathlist(PlannerInfo *root, *** 1789,1795 **** /* Generate outer path using this subpath */ add_path(rel, (Path *) create_subqueryscan_path(root, rel, subpath, ! pathkeys, required_outer)); } } --- 2120,2126 ---- /* Generate outer path using this subpath */ add_path(rel, (Path *) create_subqueryscan_path(root, rel, subpath, ! pathkeys, required_outer), false); } } *************** set_function_pathlist(PlannerInfo *root, *** 1858,1864 **** /* Generate appropriate path */ add_path(rel, create_functionscan_path(root, rel, ! pathkeys, required_outer)); } /* --- 2189,2195 ---- /* Generate appropriate path */ add_path(rel, create_functionscan_path(root, rel, ! pathkeys, required_outer), false); } /* *************** set_values_pathlist(PlannerInfo *root, R *** 1878,1884 **** required_outer = rel->lateral_relids; /* Generate appropriate path */ ! add_path(rel, create_valuesscan_path(root, rel, required_outer)); } /* --- 2209,2215 ---- required_outer = rel->lateral_relids; /* Generate appropriate path */ ! add_path(rel, create_valuesscan_path(root, rel, required_outer), false); } /* *************** set_cte_pathlist(PlannerInfo *root, RelO *** 1944,1950 **** required_outer = rel->lateral_relids; /* Generate appropriate path */ ! add_path(rel, create_ctescan_path(root, rel, required_outer)); } /* --- 2275,2281 ---- required_outer = rel->lateral_relids; /* Generate appropriate path */ ! add_path(rel, create_ctescan_path(root, rel, required_outer), false); } /* *************** set_worktable_pathlist(PlannerInfo *root *** 1994,2000 **** required_outer = rel->lateral_relids; /* Generate appropriate path */ ! add_path(rel, create_worktablescan_path(root, rel, required_outer)); } /* --- 2325,2332 ---- required_outer = rel->lateral_relids; /* Generate appropriate path */ ! add_path(rel, create_worktablescan_path(root, rel, required_outer), ! false); } /* *************** set_worktable_pathlist(PlannerInfo *root *** 2007,2019 **** * path that some GatherPath has a reference to.) */ void ! generate_gather_paths(PlannerInfo *root, RelOptInfo *rel) { Path *cheapest_partial_path; Path *simple_gather_path; /* If there are no partial paths, there's nothing to do here. */ ! if (rel->partial_pathlist == NIL) return; /* --- 2339,2356 ---- * path that some GatherPath has a reference to.) */ void ! generate_gather_paths(PlannerInfo *root, RelOptInfo *rel, bool grouped) { Path *cheapest_partial_path; Path *simple_gather_path; + List *pathlist; + PathTarget *partial_target; + + pathlist = !grouped ? rel->partial_pathlist : + rel->partial_grouped_pathlist; /* If there are no partial paths, there's nothing to do here. */ ! if (pathlist == NIL) return; /* *************** generate_gather_paths(PlannerInfo *root, *** 2027,2037 **** * could usefully generate such a path from each partial path that has * non-NIL pathkeys. */ ! cheapest_partial_path = linitial(rel->partial_pathlist); simple_gather_path = (Path *) ! create_gather_path(root, rel, cheapest_partial_path, rel->reltarget, NULL, NULL); ! add_path(rel, simple_gather_path); } /* --- 2364,2377 ---- * could usefully generate such a path from each partial path that has * non-NIL pathkeys. */ ! cheapest_partial_path = linitial(pathlist); ! ! partial_target = !grouped ? rel->reltarget : rel->reltarget_grouped; ! simple_gather_path = (Path *) ! create_gather_path(root, rel, cheapest_partial_path, partial_target, NULL, NULL); ! add_path(rel, simple_gather_path, grouped); } /* *************** standard_join_search(PlannerInfo *root, *** 2196,2202 **** rel = (RelOptInfo *) lfirst(lc); /* Create GatherPaths for any useful partial paths for rel */ ! generate_gather_paths(root, rel); /* Find and save the cheapest paths for this rel */ set_cheapest(rel); --- 2536,2542 ---- rel = (RelOptInfo *) lfirst(lc); /* Create GatherPaths for any useful partial paths for rel */ ! generate_gather_paths(root, rel, false); /* Find and save the cheapest paths for this rel */ set_cheapest(rel); diff --git a/src/backend/optimizer/path/indxpath.c b/src/backend/optimizer/path/indxpath.c new file mode 100644 index 7b43c4a..7c44938 *** a/src/backend/optimizer/path/indxpath.c --- b/src/backend/optimizer/path/indxpath.c *************** create_index_paths(PlannerInfo *root, Re *** 338,344 **** bitmapqual = choose_bitmap_and(root, rel, bitindexpaths); bpath = create_bitmap_heap_path(root, rel, bitmapqual, rel->lateral_relids, 1.0); ! add_path(rel, (Path *) bpath); } /* --- 338,344 ---- bitmapqual = choose_bitmap_and(root, rel, bitindexpaths); bpath = create_bitmap_heap_path(root, rel, bitmapqual, rel->lateral_relids, 1.0); ! add_path(rel, (Path *) bpath, false); } /* *************** create_index_paths(PlannerInfo *root, Re *** 411,417 **** loop_count = get_loop_count(root, rel->relid, required_outer); bpath = create_bitmap_heap_path(root, rel, bitmapqual, required_outer, loop_count); ! add_path(rel, (Path *) bpath); } } } --- 411,417 ---- loop_count = get_loop_count(root, rel->relid, required_outer); bpath = create_bitmap_heap_path(root, rel, bitmapqual, required_outer, loop_count); ! add_path(rel, (Path *) bpath, false); } } } *************** get_index_paths(PlannerInfo *root, RelOp *** 785,791 **** IndexPath *ipath = (IndexPath *) lfirst(lc); if (index->amhasgettuple) ! add_path(rel, (Path *) ipath); if (index->amhasgetbitmap && (ipath->path.pathkeys == NIL || --- 785,791 ---- IndexPath *ipath = (IndexPath *) lfirst(lc); if (index->amhasgettuple) ! add_path(rel, (Path *) ipath, false); if (index->amhasgetbitmap && (ipath->path.pathkeys == NIL || diff --git a/src/backend/optimizer/path/joinpath.c b/src/backend/optimizer/path/joinpath.c new file mode 100644 index 7c30ec6..45318c8 *** a/src/backend/optimizer/path/joinpath.c --- b/src/backend/optimizer/path/joinpath.c *************** static void consider_parallel_nestloop(P *** 39,48 **** RelOptInfo *outerrel, RelOptInfo *innerrel, JoinType jointype, ! JoinPathExtraData *extra); static void hash_inner_and_outer(PlannerInfo *root, RelOptInfo *joinrel, RelOptInfo *outerrel, RelOptInfo *innerrel, ! JoinType jointype, JoinPathExtraData *extra); static List *select_mergejoin_clauses(PlannerInfo *root, RelOptInfo *joinrel, RelOptInfo *outerrel, --- 39,49 ---- RelOptInfo *outerrel, RelOptInfo *innerrel, JoinType jointype, ! JoinPathExtraData *extra, ! bool grouped); static void hash_inner_and_outer(PlannerInfo *root, RelOptInfo *joinrel, RelOptInfo *outerrel, RelOptInfo *innerrel, ! JoinType jointype, JoinPathExtraData *extra, bool grouped); static List *select_mergejoin_clauses(PlannerInfo *root, RelOptInfo *joinrel, RelOptInfo *outerrel, *************** add_paths_to_joinrel(PlannerInfo *root, *** 217,224 **** * joins, because there may be no other alternative. */ if (enable_hashjoin || jointype == JOIN_FULL) hash_inner_and_outer(root, joinrel, outerrel, innerrel, ! jointype, &extra); /* * 5. If inner and outer relations are foreign tables (or joins) belonging --- 218,229 ---- * joins, because there may be no other alternative. */ if (enable_hashjoin || jointype == JOIN_FULL) + { hash_inner_and_outer(root, joinrel, outerrel, innerrel, ! jointype, &extra, false); ! hash_inner_and_outer(root, joinrel, outerrel, innerrel, ! jointype, &extra, true); ! } /* * 5. If inner and outer relations are foreign tables (or joins) belonging *************** try_nestloop_path(PlannerInfo *root, *** 323,329 **** if (add_path_precheck(joinrel, workspace.startup_cost, workspace.total_cost, ! pathkeys, required_outer)) { add_path(joinrel, (Path *) create_nestloop_path(root, --- 328,334 ---- if (add_path_precheck(joinrel, workspace.startup_cost, workspace.total_cost, ! pathkeys, required_outer, false)) { add_path(joinrel, (Path *) create_nestloop_path(root, *************** try_nestloop_path(PlannerInfo *root, *** 336,342 **** inner_path, extra->restrictlist, pathkeys, ! required_outer)); } else { --- 341,348 ---- inner_path, extra->restrictlist, pathkeys, ! required_outer), ! false); } else { *************** try_partial_nestloop_path(PlannerInfo *r *** 357,363 **** Path *inner_path, List *pathkeys, JoinType jointype, ! JoinPathExtraData *extra) { JoinCostWorkspace workspace; --- 363,370 ---- Path *inner_path, List *pathkeys, JoinType jointype, ! JoinPathExtraData *extra, ! bool grouped) { JoinCostWorkspace workspace; *************** try_partial_nestloop_path(PlannerInfo *r *** 383,389 **** initial_cost_nestloop(root, &workspace, jointype, outer_path, inner_path, extra->sjinfo, &extra->semifactors); ! if (!add_partial_path_precheck(joinrel, workspace.total_cost, pathkeys)) return; /* Might be good enough to be worth trying, so let's try it. */ --- 390,397 ---- initial_cost_nestloop(root, &workspace, jointype, outer_path, inner_path, extra->sjinfo, &extra->semifactors); ! if (!add_partial_path_precheck(joinrel, workspace.total_cost, pathkeys, ! false)) return; /* Might be good enough to be worth trying, so let's try it. */ *************** try_partial_nestloop_path(PlannerInfo *r *** 398,404 **** inner_path, extra->restrictlist, pathkeys, ! NULL)); } /* --- 406,413 ---- inner_path, extra->restrictlist, pathkeys, ! NULL), ! grouped); } /* *************** try_mergejoin_path(PlannerInfo *root, *** 456,462 **** if (add_path_precheck(joinrel, workspace.startup_cost, workspace.total_cost, ! pathkeys, required_outer)) { add_path(joinrel, (Path *) create_mergejoin_path(root, --- 465,471 ---- if (add_path_precheck(joinrel, workspace.startup_cost, workspace.total_cost, ! pathkeys, required_outer, false)) { add_path(joinrel, (Path *) create_mergejoin_path(root, *************** try_mergejoin_path(PlannerInfo *root, *** 471,477 **** required_outer, mergeclauses, outersortkeys, ! innersortkeys)); } else { --- 480,486 ---- required_outer, mergeclauses, outersortkeys, ! innersortkeys), false); } else { *************** try_hashjoin_path(PlannerInfo *root, *** 492,498 **** Path *inner_path, List *hashclauses, JoinType jointype, ! JoinPathExtraData *extra) { Relids required_outer; JoinCostWorkspace workspace; --- 501,508 ---- Path *inner_path, List *hashclauses, JoinType jointype, ! JoinPathExtraData *extra, ! bool grouped) { Relids required_outer; JoinCostWorkspace workspace; *************** try_hashjoin_path(PlannerInfo *root, *** 521,527 **** if (add_path_precheck(joinrel, workspace.startup_cost, workspace.total_cost, ! NIL, required_outer)) { add_path(joinrel, (Path *) create_hashjoin_path(root, --- 531,537 ---- if (add_path_precheck(joinrel, workspace.startup_cost, workspace.total_cost, ! NIL, required_outer, grouped)) { add_path(joinrel, (Path *) create_hashjoin_path(root, *************** try_hashjoin_path(PlannerInfo *root, *** 534,540 **** inner_path, extra->restrictlist, required_outer, ! hashclauses)); } else { --- 544,551 ---- inner_path, extra->restrictlist, required_outer, ! hashclauses, ! grouped), grouped); } else { *************** try_partial_hashjoin_path(PlannerInfo *r *** 555,561 **** Path *inner_path, List *hashclauses, JoinType jointype, ! JoinPathExtraData *extra) { JoinCostWorkspace workspace; --- 566,573 ---- Path *inner_path, List *hashclauses, JoinType jointype, ! JoinPathExtraData *extra, ! bool grouped) { JoinCostWorkspace workspace; *************** try_partial_hashjoin_path(PlannerInfo *r *** 581,587 **** initial_cost_hashjoin(root, &workspace, jointype, hashclauses, outer_path, inner_path, extra->sjinfo, &extra->semifactors); ! if (!add_partial_path_precheck(joinrel, workspace.total_cost, NIL)) return; /* Might be good enough to be worth trying, so let's try it. */ --- 593,599 ---- initial_cost_hashjoin(root, &workspace, jointype, hashclauses, outer_path, inner_path, extra->sjinfo, &extra->semifactors); ! if (!add_partial_path_precheck(joinrel, workspace.total_cost, NIL, false)) return; /* Might be good enough to be worth trying, so let's try it. */ *************** try_partial_hashjoin_path(PlannerInfo *r *** 596,602 **** inner_path, extra->restrictlist, NULL, ! hashclauses)); } /* --- 608,616 ---- inner_path, extra->restrictlist, NULL, ! hashclauses, ! grouped), ! grouped); } /* *************** match_unsorted_outer(PlannerInfo *root, *** 1233,1240 **** if (joinrel->consider_parallel && nestjoinOK && save_jointype != JOIN_UNIQUE_OUTER && bms_is_empty(joinrel->lateral_relids)) consider_parallel_nestloop(root, joinrel, outerrel, innerrel, ! save_jointype, extra); } /* --- 1247,1258 ---- if (joinrel->consider_parallel && nestjoinOK && save_jointype != JOIN_UNIQUE_OUTER && bms_is_empty(joinrel->lateral_relids)) + { consider_parallel_nestloop(root, joinrel, outerrel, innerrel, ! save_jointype, extra, false); ! consider_parallel_nestloop(root, joinrel, outerrel, innerrel, ! save_jointype, extra, true); ! } } /* *************** consider_parallel_nestloop(PlannerInfo * *** 1254,1268 **** RelOptInfo *outerrel, RelOptInfo *innerrel, JoinType jointype, ! JoinPathExtraData *extra) { JoinType save_jointype = jointype; ListCell *lc1; if (jointype == JOIN_UNIQUE_INNER) jointype = JOIN_INNER; ! foreach(lc1, outerrel->partial_pathlist) { Path *outerpath = (Path *) lfirst(lc1); List *pathkeys; --- 1272,1291 ---- RelOptInfo *outerrel, RelOptInfo *innerrel, JoinType jointype, ! JoinPathExtraData *extra, ! bool grouped) { JoinType save_jointype = jointype; + List *outerrel_pathlist; ListCell *lc1; if (jointype == JOIN_UNIQUE_INNER) jointype = JOIN_INNER; ! outerrel_pathlist = !grouped ? outerrel->partial_pathlist : ! outerrel->partial_grouped_pathlist; ! ! foreach(lc1, outerrel_pathlist) { Path *outerpath = (Path *) lfirst(lc1); List *pathkeys; *************** consider_parallel_nestloop(PlannerInfo * *** 1304,1310 **** } try_partial_nestloop_path(root, joinrel, outerpath, innerpath, ! pathkeys, jointype, extra); } } } --- 1327,1333 ---- } try_partial_nestloop_path(root, joinrel, outerpath, innerpath, ! pathkeys, jointype, extra, grouped); } } } *************** hash_inner_and_outer(PlannerInfo *root, *** 1326,1332 **** RelOptInfo *outerrel, RelOptInfo *innerrel, JoinType jointype, ! JoinPathExtraData *extra) { JoinType save_jointype = jointype; bool isouterjoin = IS_OUTER_JOIN(jointype); --- 1349,1356 ---- RelOptInfo *outerrel, RelOptInfo *innerrel, JoinType jointype, ! JoinPathExtraData *extra, ! bool grouped) { JoinType save_jointype = jointype; bool isouterjoin = IS_OUTER_JOIN(jointype); *************** hash_inner_and_outer(PlannerInfo *root, *** 1382,1394 **** * can't use a hashjoin. (There's no use looking for alternative * input paths, since these should already be the least-parameterized * available paths.) */ if (PATH_PARAM_BY_REL(cheapest_total_outer, innerrel) || PATH_PARAM_BY_REL(cheapest_total_inner, outerrel)) return; /* Unique-ify if need be; we ignore parameterized possibilities */ ! if (jointype == JOIN_UNIQUE_OUTER) { cheapest_total_outer = (Path *) create_unique_path(root, outerrel, --- 1406,1445 ---- * can't use a hashjoin. (There's no use looking for alternative * input paths, since these should already be the least-parameterized * available paths.) + * + * (The same check should work for grouped paths, as these don't + * differ in parameterization.) */ if (PATH_PARAM_BY_REL(cheapest_total_outer, innerrel) || PATH_PARAM_BY_REL(cheapest_total_inner, outerrel)) return; + if (grouped) + { + /* + * The result of grouped path should be quite different from that + * of the non-grouped one as such, so don't bother combining + * multiple kinds of grouped paths. + * + * TODO As for JOIN_UNIQUE_OUTER and JOIN_UNIQUE_INNER, consider + * if the unique-ificiation is worth the effort. + */ + if (jointype != JOIN_UNIQUE_OUTER && + jointype != JOIN_UNIQUE_INNER && + outerrel->grouped_pathlist && innerrel->grouped_pathlist) + { + try_hashjoin_path(root, + joinrel, + (Path *) linitial(outerrel->grouped_pathlist), + (Path *) linitial(innerrel->grouped_pathlist), + hashclauses, + jointype, + extra, + true); + } + } /* Unique-ify if need be; we ignore parameterized possibilities */ ! else if (jointype == JOIN_UNIQUE_OUTER) { cheapest_total_outer = (Path *) create_unique_path(root, outerrel, *************** hash_inner_and_outer(PlannerInfo *root, *** 1401,1407 **** cheapest_total_inner, hashclauses, jointype, ! extra); /* no possibility of cheap startup here */ } else if (jointype == JOIN_UNIQUE_INNER) --- 1452,1459 ---- cheapest_total_inner, hashclauses, jointype, ! extra, ! false); /* no possibility of cheap startup here */ } else if (jointype == JOIN_UNIQUE_INNER) *************** hash_inner_and_outer(PlannerInfo *root, *** 1417,1423 **** cheapest_total_inner, hashclauses, jointype, ! extra); if (cheapest_startup_outer != NULL && cheapest_startup_outer != cheapest_total_outer) try_hashjoin_path(root, --- 1469,1476 ---- cheapest_total_inner, hashclauses, jointype, ! extra, ! false); if (cheapest_startup_outer != NULL && cheapest_startup_outer != cheapest_total_outer) try_hashjoin_path(root, *************** hash_inner_and_outer(PlannerInfo *root, *** 1426,1432 **** cheapest_total_inner, hashclauses, jointype, ! extra); } else { --- 1479,1486 ---- cheapest_total_inner, hashclauses, jointype, ! extra, ! false); } else { *************** hash_inner_and_outer(PlannerInfo *root, *** 1447,1453 **** cheapest_total_inner, hashclauses, jointype, ! extra); foreach(lc1, outerrel->cheapest_parameterized_paths) { --- 1501,1508 ---- cheapest_total_inner, hashclauses, jointype, ! extra, ! false); foreach(lc1, outerrel->cheapest_parameterized_paths) { *************** hash_inner_and_outer(PlannerInfo *root, *** 1481,1487 **** innerpath, hashclauses, jointype, ! extra); } } } --- 1536,1543 ---- innerpath, hashclauses, jointype, ! extra, ! false); } } } *************** hash_inner_and_outer(PlannerInfo *root, *** 1537,1543 **** try_partial_hashjoin_path(root, joinrel, cheapest_partial_outer, cheapest_safe_inner, ! hashclauses, jointype, extra); } } } --- 1593,1613 ---- try_partial_hashjoin_path(root, joinrel, cheapest_partial_outer, cheapest_safe_inner, ! hashclauses, jointype, extra, ! false); ! ! /* ! * If partial grouped path exists for either side, join the ! * cheapest ones into a new grouped path. ! */ ! if (outerrel->partial_grouped_pathlist && ! innerrel->partial_grouped_pathlist) ! try_partial_hashjoin_path(root, ! joinrel, ! (Path *) linitial(outerrel->partial_grouped_pathlist), ! (Path *) linitial(innerrel->partial_grouped_pathlist), ! hashclauses, jointype, extra, ! true); } } } diff --git a/src/backend/optimizer/path/joinrels.c b/src/backend/optimizer/path/joinrels.c new file mode 100644 index 6f3c20b..51e01d7 *** a/src/backend/optimizer/path/joinrels.c --- b/src/backend/optimizer/path/joinrels.c *************** mark_dummy_rel(RelOptInfo *rel) *** 1197,1203 **** rel->partial_pathlist = NIL; /* Set up the dummy path */ ! add_path(rel, (Path *) create_append_path(rel, NIL, NULL, 0)); /* Set or update cheapest_total_path and related fields */ set_cheapest(rel); --- 1197,1203 ---- rel->partial_pathlist = NIL; /* Set up the dummy path */ ! add_path(rel, (Path *) create_append_path(rel, NIL, NULL, 0), false); /* Set or update cheapest_total_path and related fields */ set_cheapest(rel); diff --git a/src/backend/optimizer/path/tidpath.c b/src/backend/optimizer/path/tidpath.c new file mode 100644 index 240ade6..6c3a77a *** a/src/backend/optimizer/path/tidpath.c --- b/src/backend/optimizer/path/tidpath.c *************** create_tidscan_paths(PlannerInfo *root, *** 263,267 **** if (tidquals) add_path(rel, (Path *) create_tidscan_path(root, rel, tidquals, ! required_outer)); } --- 263,267 ---- if (tidquals) add_path(rel, (Path *) create_tidscan_path(root, rel, tidquals, ! required_outer), false); } diff --git a/src/backend/optimizer/plan/initsplan.c b/src/backend/optimizer/plan/initsplan.c new file mode 100644 index 6ceb801..7a8b3c4 *** a/src/backend/optimizer/plan/initsplan.c --- b/src/backend/optimizer/plan/initsplan.c *************** *** 14,20 **** --- 14,25 ---- */ #include "postgres.h" + #include "access/htup_details.h" + #include "access/sysattr.h" + #include "catalog/pg_aggregate.h" + #include "catalog/pg_operator.h" #include "catalog/pg_type.h" + #include "nodes/makefuncs.h" #include "nodes/nodeFuncs.h" #include "optimizer/clauses.h" #include "optimizer/cost.h" *************** *** 26,36 **** #include "optimizer/planner.h" #include "optimizer/prep.h" #include "optimizer/restrictinfo.h" #include "optimizer/var.h" #include "parser/analyze.h" #include "rewrite/rewriteManip.h" #include "utils/lsyscache.h" ! /* These parameters are set by GUC */ int from_collapse_limit; --- 31,42 ---- #include "optimizer/planner.h" #include "optimizer/prep.h" #include "optimizer/restrictinfo.h" + #include "optimizer/tlist.h" #include "optimizer/var.h" #include "parser/analyze.h" #include "rewrite/rewriteManip.h" #include "utils/lsyscache.h" ! #include "utils/syscache.h" /* These parameters are set by GUC */ int from_collapse_limit; *************** static List *deconstruct_recurse(Planner *** 51,56 **** --- 57,67 ---- bool below_outer_join, Relids *qualscope, Relids *inner_join_rels, List **postponed_qual_list); + static bool build_base_rel_tlist_grouped(PlannerInfo *root, RelOptInfo *rel, + List *aggregates, Aggref *countagg, + List **countagg_vars); + static void finalize_grouped_vars(PlannerInfo *root, List *countagg_vars); + static void add_sortgrouprefs_to_reltarget(RelOptInfo *rel); static SpecialJoinInfo *make_outerjoininfo(PlannerInfo *root, Relids left_rels, Relids right_rels, Relids inner_join_rels, *************** add_vars_to_targetlist(PlannerInfo *root *** 236,241 **** --- 247,820 ---- } } + /* + * Initialize rel->reltarget_grouped where possible. + * + * root->group_pathkeys must be setup before this function is called. + */ + extern void + build_base_rel_tlists_grouped(PlannerInfo *root) + { + List *tlist_vars; + List *aggregates = NIL; + ListCell *lc; + bool aggs_acceptable = true; + Aggref *countagg = NULL; + List *countagg_vars = NIL; + int nbaserels = 0; + int i; + + /* No grouping in the query? */ + if (!root->parse->groupClause || root->group_pathkeys == NIL) + return; + + /* TODO This is just for PoC. Relax the limitation later. */ + if (root->parse->havingQual) + return; + + /* + * If no join is expected, aggregation at base relation level makes no + * sense. XXX Is there simpler way to find out? (We're not interested in + * RELOPT_OTHER_MEMBER_REL, so simple_rel_array_size does not help.) + */ + for (i = 1; i < root->simple_rel_array_size; i++) + { + RelOptInfo *rel; + + rel = find_base_rel(root, i); + if (rel->reloptkind == RELOPT_BASEREL) + { + nbaserels++; + /* + * We only want to know whether the number of relations is greater + * than one. + */ + if (nbaserels > 1) + break; + } + } + if (nbaserels <= 1) + return; + + tlist_vars = pull_var_clause((Node *) root->processed_tlist, + PVC_INCLUDE_AGGREGATES); + if (tlist_vars == NIL) + return; + + /* tlist_vars may also contain Vars, but we only need Aggrefs. */ + foreach(lc, tlist_vars) + { + Expr *expr = (Expr *) lfirst(lc); + + if (!IsA(expr, Var)) + { + Aggref *aggref = (Aggref *) expr; + + Assert(IsA(aggref, Aggref)); + + /* TODO Think if (some of) these can be handled. */ + if (aggref->aggstar || aggref->aggvariadic || aggref->aggdirectargs || + aggref->aggorder || aggref->aggdistinct || aggref->aggfilter) + { + aggs_acceptable = false; + break; + } + + aggregates = lappend(aggregates, expr); + } + } + + root->all_baserels_grouped = false; + if (aggregates != NIL && aggs_acceptable) + { + int i; + bool success = true; + + if (countagg == NULL) + { + /* count(*) aggregate for base relation grouping. */ + countagg = makeNode(Aggref); + countagg->aggfnoid = COUNTFNOID; + countagg->aggkind = AGGKIND_NORMAL; + countagg->aggtype = INT8OID; + countagg->aggtranstype = INT8OID; + countagg->aggstar = true; + } + /* Process the individual base relations. */ + root->all_baserels_grouped = true; + for (i = 1; i < root->simple_rel_array_size; i++) + { + RelOptInfo *rel = root->simple_rel_array[i]; + + /* + * "other rels" will have their targets built later, by + * translation of the target of the parent rel - see + * set_append_rel_size. + */ + if (rel != NULL && rel->reloptkind == RELOPT_BASEREL) + { + if (build_base_rel_tlist_grouped(root, rel, aggregates, countagg, + &countagg_vars)) + { + /* + * The paths generated for this relation may be + * immediately grouped, so the target entries need valid + * sortgroupref. + */ + add_sortgrouprefs_to_reltarget(rel); + } + else + { + /* + * Don't bother processing the rest if the current rel + * prevents us from forming the final "grouped join". + */ + success = false; + break; + } + } + } + + if (success) + { + finalize_grouped_vars(root, countagg_vars); + root->all_baserels_grouped = true; + } + } + + if (aggregates != NIL) + list_free(aggregates); + list_free(tlist_vars); + } + + /* + * Construct target of grouped relation - that can only contain grouping + * expressions and aggregates. Such a target can't be created if anything else + * is required on the output. + * + * Return true iff succeeded. + */ + static bool + build_base_rel_tlist_grouped(PlannerInfo *root, RelOptInfo *rel, + List *aggregates, Aggref *countagg, + List **countagg_vars) + { + RangeTblEntry *rte; + List *rel_aggregates; + ListCell *lc; + Relids agg_arg_rels_all, agg_arg_attrs_all; + PathTarget *reltarget_grouped; + + rte = root->simple_rte_array[rel->relid]; + + /* + * XXX rtekind != RTE_RELATION seem to deserve separate patch. + */ + if ( rte->rtekind != RTE_RELATION) + return false; + + /* Caller should only pass base relations. */ + Assert(rel->reloptkind == RELOPT_BASEREL); + Assert(bms_membership(rel->relids) == BMS_SINGLETON); + + /* + * If any outer join can set the attribute value to NULL, the aggregate + * would receive different input at the base rel level. + * + * TODO This as well as some other limitations below should only apply to + * the PoC version of the patch. In the future we should handle + * non-grouped relations by joining them to the grouped ones and applying + * additional partial aggregation to the final join. + */ + if (bms_overlap(rel->relids, root->nullable_baserels)) + return false; + + /* Collect aggregates applicable to the current relation. */ + rel_aggregates = NIL; + agg_arg_rels_all = NULL; + agg_arg_attrs_all = NULL; + foreach(lc, aggregates) + { + Aggref *aggref = (Aggref *) lfirst(lc); + Relids agg_arg_rels, agg_arg_attrs = NULL; + + /* TODO Does it matter if any argument contains PHV ? */ + agg_arg_rels = pull_varnos((Node *) aggref->args); + + /* Skip aggregates which don't reference rel at all. */ + if (!bms_overlap(rel->relids, agg_arg_rels)) + continue; + + /* + * If the aggregate references multiple rels, it must be processed + * higher in the join tree. + */ + if (bms_membership(agg_arg_rels) != BMS_SINGLETON) + { + /* + * TODO Consider relaxing this limitation by adding one extra + * partial aggregation below the final one. + */ + return false; + } + + /* Accept this aggregate. */ + rel_aggregates = lappend(rel_aggregates, aggref); + agg_arg_rels_all = bms_union(agg_arg_rels_all, agg_arg_rels); + + /* Collect attnos while being here. */ + pull_varattnos((Node *) aggref->args, rel->relid, &agg_arg_attrs); + agg_arg_attrs_all = bms_union(agg_arg_attrs_all, agg_arg_attrs); + } + + Assert(rel->reltarget_grouped == NULL); + + /* + * Create a separate target which represents the actual output of grouped + * relation. This target will have aggregates replaced with special vars + * which will ensure propagation of the result of the partial aggregation + * of the base relation to the final Agg node. + * + * This target won't contain expressions that the grouped relation cannot + * emit. Another difference from rel->reltarget is that sortgroupref is + * set for each grouping expression. This is because the same target will + * be used for the partial aggregation. + * + * (Do not set rel->reltarget_grouped yet, as we might return + * prematurely.) + */ + reltarget_grouped = create_empty_pathtarget(); + + /* + * Check if all the output columns can be used as grouping expressions. + * + * TODO + * + * 1. How about PHVs? + * + * 2. Consider additional grouping expressions, just to be able to emit + * the columns that the query group clause doesn't mention. (These + * additional expressions wouldn't be used during the final aggregation.) + * Does this also mean that we shouldn't check existence of + * parse->groupClause earlier in this function? + */ + foreach(lc, rel->reltarget->exprs) + { + ListCell *lc2; + Expr *texpr = (Expr *) lfirst(lc); + bool is_grouping = false; + bool ec_found = false; + bool agg_arg_only = false; + + /* + * First, check if the query group clause contains exactly this + * expression. + */ + foreach(lc2, root->processed_tlist) + { + TargetEntry *te = (TargetEntry *) lfirst(lc2); + + Assert(IsA(te, TargetEntry)); + + if (equal(texpr, te->expr) && te->ressortgroupref > 0) + { + add_column_to_pathtarget(reltarget_grouped, texpr, + te->ressortgroupref); + is_grouping = true; + break; + } + } + + /* Go for the next expression if matched the current one. */ + if (is_grouping) + continue; + + /* + * If exactly this expression is not there, check if a grouping clause + * exists that belongs to the same equivalence class as the + * expression. + */ + foreach(lc2, root->group_pathkeys) + { + PathKey *pk = (PathKey *) lfirst(lc2); + EquivalenceClass *ec = pk->pk_eclass; + ListCell *lm; + EquivalenceMember *em; + Expr *em_expr = NULL; + Query *query = root->parse; + Index sortgroupref; + + /* + * Single-member EC cannot provide us with additional + * expression. + */ + if (list_length(ec->ec_members) < 2) + continue; + + /* We need equality anywhere in the join tree. */ + if (ec->ec_below_outer_join) + continue; + + /* + * TODO Reconsider this restriction. As the grouping expression is + * only evaluated at the relation level (and only the result will + * be propagated to the final targetlist), volatile function might + * be o.k. Need to think what volatile EC exactly means. + */ + if (ec->ec_has_volatile) + continue; + + foreach(lm, ec->ec_members) + { + em = (EquivalenceMember *) lfirst(lm); + + /* The EC has !ec_below_outer_join. */ + Assert(!em->em_nullable_relids); + if (equal(em->em_expr, texpr)) + { + em_expr = (Expr *) em->em_expr; + break; + } + } + + if (em_expr == NULL) + /* Go for the next EC. */ + continue; + + /* + * Find the corresponding SortGroupClause, which provides us + * with sortgroupref. (It can belong to any EC member.) + */ + sortgroupref = 0; + foreach(lm, ec->ec_members) + { + ListCell *lsg; + + em = (EquivalenceMember *) lfirst(lm); + foreach(lsg, query->groupClause) + { + SortGroupClause *sgc; + Expr *texpr; + + sgc = (SortGroupClause *) lfirst(lsg); + texpr = (Expr *) get_sortgroupclause_expr(sgc, + query->targetList); + if (equal(em->em_expr, texpr)) + { + Assert(sgc->tleSortGroupRef > 0); + sortgroupref = sgc->tleSortGroupRef; + break; + } + } + + if (sortgroupref > 0) + break; + } + + /* + * At least one EM of this EC should have correspond to a + * SortGroupClause, otherwise the EC could hardly exist. + */ + if (sortgroupref == 0) + elog(ERROR, "Grouping EC does not match any grouping clause."); + + /* It's o.k. to use the target expression for grouping. */ + add_column_to_pathtarget(reltarget_grouped, texpr, sortgroupref); + ec_found = true; + break; + } + + /* + * It may still be o.k. if the expression is only contained in Aggref + * - then it's not expected in the grouped output. + * + * TODO Try to handle generic expression, not only Var. That might + * require us to create rel->reltarget of the grouping rel in + * parallel to that of the plain rel, and adding whole expressions + * instead of individual vars. + */ + if (IsA(texpr, Var) && + bms_is_member(((Var *) texpr)->varattno - + FirstLowInvalidHeapAttributeNumber, agg_arg_attrs_all)) + agg_arg_only = true; + + /* + * A single mismatched expression makes the whole relation useless + * for grouping at base level. + */ + if (!ec_found && !agg_arg_only) + return false; + } + + /* + * Add the count(*) aggregate, as its processing is nearly identical to + * that of other aggregates. For convenience, add it in front of the other + * vars. + * + * TODO Avoid this if no aggregate in the query has aggtransmultifn. + */ + rel_aggregates = lcons(countagg, rel_aggregates); + + /* Process all the aggregates at once. */ + rel->reltarget_grouped = reltarget_grouped; + add_aggregates_to_grouped_target(root, rel_aggregates, rel, countagg, + countagg_vars, true); + return true; + } + + /* + * Initialize expr_intermediate of each GroupedVarInfo that requires it. + * This expression will adjust partial state of an aggregate prior to final + * aggregation, so it reflects existence of joins. + * + * If a single relation is aggregated, only the table determines how many + * times each value of aggregate argument appears in the relevant group. But + * if relation is joined to another one, the aggregate executed on the final + * join (i.e. w/o the relation-level aggregation) can actually receive the + * whole input set multiple times: some values of the grouping key present in + * the relation can match multiple values in the other table(s). + * + * sum() is an example of an aggregate where join matters, avg() is one where + * it does not. + * + * We simulate the effect of joins by applying aggtransmultifn (see + * pg_aggregate) to the result of relation-level aggregation. + */ + static void + finalize_grouped_vars(PlannerInfo *root, List *countagg_vars) + { + ListCell *lc; + Oid op_int8mul = InvalidOid; + + foreach(lc, root->grouped_var_list) + { + GroupedVarInfo *gvi = (GroupedVarInfo *) lfirst(lc); + Aggref *aggref = (Aggref *) gvi->expr; + ListCell *l; + Expr *factor = NULL; + + Assert(gvi->expr_intermediate == NULL); + Assert(IsA(aggref, Aggref)); + + /* Is transient state multiplication needed for this aggregate? */ + if (aggref->aggtransmultifn == InvalidOid) + continue; + + /* + * If there was no relation-level aggregation, each table joined to + * the one gvi->varno points at would increase the frequency of a + * value within a group by the factor which equals to the frequency of + * the corresponding grouping key in the table joined. + * + * To prepare the correct input for the final aggregation, the + * relation-level per-group state must be "multiplied" by the number + * of grouping key values that join of the *other* tables (i.e. all + * but the one referenced by the current aggregate) generates. + * + * This is why count(*) was added to each base relation. + */ + foreach(l, countagg_vars) + { + Var *var = (Var *) lfirst(l); + + /* Only the other tables do matter. */ + if (var->varno == gvi->var->varno) + continue; + + if (factor == NULL) + /* The first value. */ + factor = (Expr *) var; + else + { + OpExpr *op = makeNode(OpExpr); + + /* + * Multiply the intermediate result by the result of the next + * count(*) aggregate. + */ + op->opno = OPERATOR_INT8MUL; + if (op_int8mul == InvalidOid) + { + set_opfuncid(op); + op_int8mul = op->opfuncid; + } + else + op->opfuncid = op_int8mul; + + op->opresulttype = INT8OID; + op->opretset = false; + op->opcollid = InvalidOid; + op->inputcollid = InvalidOid; + op->args = list_make2(factor, var); + op->location = -1; + + factor = (Expr *) op; + } + } + + /* Construct the function call if needed. */ + if (factor != NULL) + { + FuncExpr *func = makeNode(FuncExpr); + + func->funcid = aggref->aggtransmultifn; + func->funcresulttype = aggref->aggtranstype; + func->funcretset = false; + func->funcvariadic = false; + func->funccollid = InvalidOid; + func->inputcollid = InvalidOid; + Assert(gvi->var != NULL); + func->args = list_make2(gvi->var, factor); + func->location = -1; + + gvi->expr_intermediate = (Expr *) func; + } + } + } + + /* + * Create a new reltarget, in which the expressions have sortgroupref + * initialized. + */ + static void + add_sortgrouprefs_to_reltarget(RelOptInfo *rel) + { + PathTarget *target_new = create_empty_pathtarget(); + ListCell *lc1; + + /* reltarget_grouped should have sortgrouprefs valid by now. */ + Assert(rel->reltarget_grouped->sortgrouprefs != NULL); + + foreach(lc1, rel->reltarget->exprs) + { + ListCell *lc2; + int i = 0; + Index sortgroupref = 0; + Expr *texpr = (Expr *) lfirst(lc1); + + /* + * Find the expression in the grouped target. (If not found, it should + * be a variable used only as aggregate argument, which is not itself + * emitted by the relation.) + */ + foreach(lc2, rel->reltarget_grouped->exprs) + { + Expr *gexpr = (Expr *) lfirst(lc2); + + if (equal(texpr, gexpr)) + { + sortgroupref = rel->reltarget_grouped->sortgrouprefs[i++]; + break; + } + + i++; + } + + add_column_to_pathtarget(target_new, texpr, sortgroupref); + } + + rel->reltarget = target_new; + } /***************************************************************************** * diff --git a/src/backend/optimizer/plan/planagg.c b/src/backend/optimizer/plan/planagg.c new file mode 100644 index c3fbf3c..5b3bc71 *** a/src/backend/optimizer/plan/planagg.c --- b/src/backend/optimizer/plan/planagg.c *************** preprocess_minmax_aggregates(PlannerInfo *** 223,229 **** create_minmaxagg_path(root, grouped_rel, create_pathtarget(root, tlist), aggs_list, ! (List *) parse->havingQual)); } /* --- 223,229 ---- create_minmaxagg_path(root, grouped_rel, create_pathtarget(root, tlist), aggs_list, ! (List *) parse->havingQual), false); } /* diff --git a/src/backend/optimizer/plan/planmain.c b/src/backend/optimizer/plan/planmain.c new file mode 100644 index e880759..f81e125 *** a/src/backend/optimizer/plan/planmain.c --- b/src/backend/optimizer/plan/planmain.c *************** query_planner(PlannerInfo *root, List *t *** 83,89 **** add_path(final_rel, (Path *) create_result_path(root, final_rel, final_rel->reltarget, ! (List *) parse->jointree->quals)); /* Select cheapest path (pretty easy in this case...) */ set_cheapest(final_rel); --- 83,89 ---- add_path(final_rel, (Path *) create_result_path(root, final_rel, final_rel->reltarget, ! (List *) parse->jointree->quals), false); /* Select cheapest path (pretty easy in this case...) */ set_cheapest(final_rel); *************** query_planner(PlannerInfo *root, List *t *** 114,119 **** --- 114,120 ---- root->full_join_clauses = NIL; root->join_info_list = NIL; root->placeholder_list = NIL; + root->grouped_var_list = NIL; root->fkey_list = NIL; root->initial_rels = NIL; *************** query_planner(PlannerInfo *root, List *t *** 176,181 **** --- 177,184 ---- */ (*qp_callback) (root, qp_extra); + build_base_rel_tlists_grouped(root); + /* * Examine any "placeholder" expressions generated during subquery pullup. * Make sure that the Vars they need are marked as needed at the relevant diff --git a/src/backend/optimizer/plan/planner.c b/src/backend/optimizer/plan/planner.c new file mode 100644 index 207290f..eeac4ac *** a/src/backend/optimizer/plan/planner.c --- b/src/backend/optimizer/plan/planner.c *************** static double get_number_of_groups(Plann *** 109,117 **** double path_rows, List *rollup_lists, List *rollup_groupclauses); - static Size estimate_hashagg_tablesize(Path *path, - const AggClauseCosts *agg_costs, - double dNumGroups); static RelOptInfo *create_grouping_paths(PlannerInfo *root, RelOptInfo *input_rel, PathTarget *target, --- 109,114 ---- *************** inheritance_planner(PlannerInfo *root) *** 1396,1402 **** returningLists, rowMarks, NULL, ! SS_assign_special_param(root))); } /*-------------------- --- 1393,1399 ---- returningLists, rowMarks, NULL, ! SS_assign_special_param(root)), false); } /*-------------------- *************** grouping_planner(PlannerInfo *root, bool *** 2061,2067 **** } /* And shove it into final_rel */ ! add_path(final_rel, path); } /* --- 2058,2064 ---- } /* And shove it into final_rel */ ! add_path(final_rel, path, false); } /* *************** get_number_of_groups(PlannerInfo *root, *** 3270,3304 **** } /* - * estimate_hashagg_tablesize - * estimate the number of bytes that a hash aggregate hashtable will - * require based on the agg_costs, path width and dNumGroups. - */ - static Size - estimate_hashagg_tablesize(Path *path, const AggClauseCosts *agg_costs, - double dNumGroups) - { - Size hashentrysize; - - /* Estimate per-hash-entry space at tuple width... */ - hashentrysize = MAXALIGN(path->pathtarget->width) + - MAXALIGN(SizeofMinimalTupleHeader); - - /* plus space for pass-by-ref transition values... */ - hashentrysize += agg_costs->transitionSpace; - /* plus the per-hash-entry overhead */ - hashentrysize += hash_agg_entry_size(agg_costs->numAggs); - - /* - * Note that this disregards the effect of fill-factor and growth policy - * of the hash-table. That's probably ok, given default the default - * fill-factor is relatively high. It'd be hard to meaningfully factor in - * "double-in-size" growth policies here. - */ - return hashentrysize * dNumGroups; - } - - /* * create_grouping_paths * * Build a new upperrel containing Paths for grouping and/or aggregation. --- 3267,3272 ---- *************** create_grouping_paths(PlannerInfo *root, *** 3419,3425 **** (List *) parse->havingQual); } ! add_path(grouped_rel, path); /* No need to consider any other alternatives. */ set_cheapest(grouped_rel); --- 3387,3393 ---- (List *) parse->havingQual); } ! add_path(grouped_rel, path, false); /* No need to consider any other alternatives. */ set_cheapest(grouped_rel); *************** create_grouping_paths(PlannerInfo *root, *** 3592,3598 **** parse->groupClause, NIL, &agg_partial_costs, ! dNumPartialGroups)); else add_partial_path(grouped_rel, (Path *) create_group_path(root, --- 3560,3567 ---- parse->groupClause, NIL, &agg_partial_costs, ! dNumPartialGroups), ! false); else add_partial_path(grouped_rel, (Path *) create_group_path(root, *************** create_grouping_paths(PlannerInfo *root, *** 3601,3607 **** partial_grouping_target, parse->groupClause, NIL, ! dNumPartialGroups)); } } } --- 3570,3577 ---- partial_grouping_target, parse->groupClause, NIL, ! dNumPartialGroups), ! false); } } } *************** create_grouping_paths(PlannerInfo *root, *** 3632,3638 **** parse->groupClause, NIL, &agg_partial_costs, ! dNumPartialGroups)); } } } --- 3602,3609 ---- parse->groupClause, NIL, &agg_partial_costs, ! dNumPartialGroups), ! false); } } } *************** create_grouping_paths(PlannerInfo *root, *** 3677,3683 **** rollup_lists, rollup_groupclauses, agg_costs, ! dNumGroups)); } else if (parse->hasAggs) { --- 3648,3654 ---- rollup_lists, rollup_groupclauses, agg_costs, ! dNumGroups), false); } else if (parse->hasAggs) { *************** create_grouping_paths(PlannerInfo *root, *** 3695,3701 **** parse->groupClause, (List *) parse->havingQual, agg_costs, ! dNumGroups)); } else if (parse->groupClause) { --- 3666,3672 ---- parse->groupClause, (List *) parse->havingQual, agg_costs, ! dNumGroups), false); } else if (parse->groupClause) { *************** create_grouping_paths(PlannerInfo *root, *** 3710,3716 **** target, parse->groupClause, (List *) parse->havingQual, ! dNumGroups)); } else { --- 3681,3687 ---- target, parse->groupClause, (List *) parse->havingQual, ! dNumGroups), false); } else { *************** create_grouping_paths(PlannerInfo *root, *** 3760,3766 **** parse->groupClause, (List *) parse->havingQual, &agg_final_costs, ! dNumGroups)); else add_path(grouped_rel, (Path *) create_group_path(root, --- 3731,3737 ---- parse->groupClause, (List *) parse->havingQual, &agg_final_costs, ! dNumGroups), false); else add_path(grouped_rel, (Path *) create_group_path(root, *************** create_grouping_paths(PlannerInfo *root, *** 3769,3775 **** target, parse->groupClause, (List *) parse->havingQual, ! dNumGroups)); } } --- 3740,3746 ---- target, parse->groupClause, (List *) parse->havingQual, ! dNumGroups), false); } } *************** create_grouping_paths(PlannerInfo *root, *** 3801,3807 **** parse->groupClause, (List *) parse->havingQual, agg_costs, ! dNumGroups)); } /* --- 3772,3778 ---- parse->groupClause, (List *) parse->havingQual, agg_costs, ! dNumGroups), false); } /* *************** create_grouping_paths(PlannerInfo *root, *** 3838,3846 **** parse->groupClause, (List *) parse->havingQual, &agg_final_costs, ! dNumGroups)); } } } /* Give a helpful error if we failed to find any implementation */ --- 3809,3895 ---- parse->groupClause, (List *) parse->havingQual, &agg_final_costs, ! dNumGroups), false); } } + + /* + * If input_rel has partially aggregated partial paths, perform the + * final aggregation. + * + * TODO Allow havingQual - currently not supported at base relation + * level. + */ + if (input_rel->partial_grouped_pathlist != NIL && + !parse->havingQual) + { + Path *path = (Path *) linitial(input_rel->partial_grouped_pathlist); + double total_groups = path->rows * path->parallel_workers; + + path = (Path *) create_gather_path(root, + input_rel, + path, + path->pathtarget, + NULL, + &total_groups); + + /* + * The input path is partially aggregated and the final + * aggregation - if the path wins - will be done below. So we're + * done with it for now. + */ + add_path(input_rel, path, true); + } + + /* + * If input_rel has partially aggregated paths, perform the final + * aggregation. + * + * TODO Allow havingQual - currently not supported at base relation + * level. + */ + if (input_rel->grouped_pathlist != NIL && + !parse->havingQual) + { + Path *pre_agg = (Path *) linitial(input_rel->grouped_pathlist); + PathTarget *proj_target; + + /* + * For each grouped variable in pre_agg->pathtarget ensure + * evaluation of expr_intermediate (see GroupedVarInfo). + */ + proj_target = + create_intermediate_grouping_target(root, + pre_agg->pathtarget); + pre_agg = (Path *) create_projection_path(root, input_rel, + pre_agg, + proj_target); + + dNumGroups = get_number_of_groups(root, + pre_agg->rows, + rollup_lists, + rollup_groupclauses); + + MemSet(&agg_final_costs, 0, sizeof(AggClauseCosts)); + get_agg_clause_costs(root, (Node *) target->exprs, + AGGSPLIT_FINAL_DESERIAL, + &agg_final_costs); + /* get_agg_clause_costs(root, parse->havingQual, */ + /* AGGSPLIT_FINAL_DESERIAL, */ + /* &agg_final_costs); */ + + add_path(grouped_rel, + (Path *) create_agg_path(root, grouped_rel, + pre_agg, + target, + AGG_HASHED, + AGGSPLIT_FINAL_DESERIAL, + parse->groupClause, + (List *) parse->havingQual, + &agg_final_costs, + dNumGroups), + false); + } } /* Give a helpful error if we failed to find any implementation */ *************** create_one_window_path(PlannerInfo *root *** 4053,4059 **** window_pathkeys); } ! add_path(window_rel, path); } /* --- 4102,4108 ---- window_pathkeys); } ! add_path(window_rel, path, false); } /* *************** create_distinct_paths(PlannerInfo *root, *** 4159,4165 **** create_upper_unique_path(root, distinct_rel, path, list_length(root->distinct_pathkeys), ! numDistinctRows)); } } --- 4208,4214 ---- create_upper_unique_path(root, distinct_rel, path, list_length(root->distinct_pathkeys), ! numDistinctRows), false); } } *************** create_distinct_paths(PlannerInfo *root, *** 4186,4192 **** create_upper_unique_path(root, distinct_rel, path, list_length(root->distinct_pathkeys), ! numDistinctRows)); } /* --- 4235,4241 ---- create_upper_unique_path(root, distinct_rel, path, list_length(root->distinct_pathkeys), ! numDistinctRows), false); } /* *************** create_distinct_paths(PlannerInfo *root, *** 4233,4239 **** parse->distinctClause, NIL, NULL, ! numDistinctRows)); } /* Give a helpful error if we failed to find any implementation */ --- 4282,4288 ---- parse->distinctClause, NIL, NULL, ! numDistinctRows), false); } /* Give a helpful error if we failed to find any implementation */ *************** create_ordered_paths(PlannerInfo *root, *** 4331,4337 **** path = apply_projection_to_path(root, ordered_rel, path, target); ! add_path(ordered_rel, path); } } --- 4380,4386 ---- path = apply_projection_to_path(root, ordered_rel, path, target); ! add_path(ordered_rel, path, false); } } diff --git a/src/backend/optimizer/plan/setrefs.c b/src/backend/optimizer/plan/setrefs.c new file mode 100644 index 413a0d9..632f4bb *** a/src/backend/optimizer/plan/setrefs.c --- b/src/backend/optimizer/plan/setrefs.c *************** set_upper_references(PlannerInfo *root, *** 1677,1686 **** indexed_tlist *subplan_itlist; List *output_targetlist; ListCell *l; ! subplan_itlist = build_tlist_index(subplan->targetlist); output_targetlist = NIL; foreach(l, plan->targetlist) { TargetEntry *tle = (TargetEntry *) lfirst(l); --- 1677,1744 ---- indexed_tlist *subplan_itlist; List *output_targetlist; ListCell *l; + List *sub_tlist_save = NIL; + bool install_partial_aggrefs = false; ! if (root->grouped_var_list != NIL) ! { ! if (IsA(plan, Agg)) ! { ! Agg *agg = (Agg *) plan; ! ! if (agg->aggsplit == AGGSPLIT_FINAL_DESERIAL) ! { ! /* ! * convert_combining_aggrefs could have replaced some vars ! * with Aggref expressions representing the partial ! * aggregation. We need to restore the same Aggrefs in the ! * subplan targetlist, but this would break the subplan if ! * it's something else than the partial aggregation (i.e. the ! * partial aggregation takes place lower in the plan tree). So ! * we'll need restore the original list when done with the ! * references. ! */ ! if (!IsA(subplan, Agg)) ! sub_tlist_save = copyObject(subplan->targetlist); ! #ifdef USE_ASSERT_CHECKING ! else ! Assert(((Agg *) subplan)->aggsplit == AGGSPLIT_INITIAL_SERIAL); ! #endif /* USE_ASSERT_CHECKING */ ! ! /* ! * Restore the aggregate expressions that we might have ! * removed when planning for aggregation at base relation ! * level. ! * ! * TODO Optimize restore_grouping_expressions using a new ! * parameter indicating whether the targetlist can contain ! * "intermediate expression". Only Result (or also Gather if ! * we use its target list to evaluate "intermediate ! * expressions"?) node should contain those. ! */ ! subplan->targetlist = ! restore_grouping_expressions(root, subplan->targetlist); ! } ! else if (agg->aggsplit == AGGSPLIT_INITIAL_SERIAL) ! install_partial_aggrefs = true; ! } ! } + /* + * AGGSPLIT_INITIAL_SERIAL might be there just to implement grouped base + * relation. Since the parent node does not necessarily call + * set_upper_references() (note that there might be various nodes between + * the initial and the final aggregation), special effort is needed to + * ensure that "grouped vars" are replaced with the corresponding + * expressions (see GroupedVarInfo). + */ + if (install_partial_aggrefs) + plan->targetlist = restore_grouping_expressions(root, + plan->targetlist); + + subplan_itlist = build_tlist_index(subplan->targetlist); output_targetlist = NIL; + foreach(l, plan->targetlist) { TargetEntry *tle = (TargetEntry *) lfirst(l); *************** set_upper_references(PlannerInfo *root, *** 1720,1725 **** --- 1778,1787 ---- OUTER_VAR, rtoffset); + /* Restore the original list if appropriate. */ + if (sub_tlist_save != NIL) + subplan->targetlist = sub_tlist_save; + pfree(subplan_itlist); } *************** convert_combining_aggrefs(Node *node, vo *** 1796,1801 **** --- 1858,1864 ---- (void *) context); } + /* * set_dummy_tlist_references * Replace the targetlist of an upper-level plan node with a simple *************** fix_join_expr_mutator(Node *node, fix_jo *** 2235,2240 **** --- 2298,2304 ---- (void *) context); } + /* * fix_upper_expr * Modifies an expression tree so that all Var nodes reference outputs diff --git a/src/backend/optimizer/prep/prepunion.c b/src/backend/optimizer/prep/prepunion.c new file mode 100644 index 1bbbc29..e0b31c3 *** a/src/backend/optimizer/prep/prepunion.c --- b/src/backend/optimizer/prep/prepunion.c *************** plan_set_operations(PlannerInfo *root) *** 208,214 **** root->processed_tlist = top_tlist; /* Add only the final path to the SETOP upperrel. */ ! add_path(setop_rel, path); /* Let extensions possibly add some more paths */ if (create_upper_paths_hook) --- 208,214 ---- root->processed_tlist = top_tlist; /* Add only the final path to the SETOP upperrel. */ ! add_path(setop_rel, path, false); /* Let extensions possibly add some more paths */ if (create_upper_paths_hook) diff --git a/src/backend/optimizer/util/pathnode.c b/src/backend/optimizer/util/pathnode.c new file mode 100644 index 3b7c56d..aefb79e *** a/src/backend/optimizer/util/pathnode.c --- b/src/backend/optimizer/util/pathnode.c *************** set_cheapest(RelOptInfo *parent_rel) *** 409,416 **** * Returns nothing, but modifies parent_rel->pathlist. */ void ! add_path(RelOptInfo *parent_rel, Path *new_path) { bool accept_new = true; /* unless we find a superior old path */ ListCell *insert_after = NULL; /* where to insert new item */ List *new_path_pathkeys; --- 409,417 ---- * Returns nothing, but modifies parent_rel->pathlist. */ void ! add_path(RelOptInfo *parent_rel, Path *new_path, bool grouped) { + List *pathlist; bool accept_new = true; /* unless we find a superior old path */ ListCell *insert_after = NULL; /* where to insert new item */ List *new_path_pathkeys; *************** add_path(RelOptInfo *parent_rel, Path *n *** 427,432 **** --- 428,435 ---- /* Pretend parameterized paths have no pathkeys, per comment above */ new_path_pathkeys = new_path->param_info ? NIL : new_path->pathkeys; + pathlist = !grouped ? parent_rel->pathlist : parent_rel->grouped_pathlist; + /* * Loop to check proposed new path against old paths. Note it is possible * for more than one old path to be tossed out because new_path dominates *************** add_path(RelOptInfo *parent_rel, Path *n *** 436,442 **** * list cell. */ p1_prev = NULL; ! for (p1 = list_head(parent_rel->pathlist); p1 != NULL; p1 = p1_next) { Path *old_path = (Path *) lfirst(p1); bool remove_old = false; /* unless new proves superior */ --- 439,445 ---- * list cell. */ p1_prev = NULL; ! for (p1 = list_head(pathlist); p1 != NULL; p1 = p1_next) { Path *old_path = (Path *) lfirst(p1); bool remove_old = false; /* unless new proves superior */ *************** add_path(RelOptInfo *parent_rel, Path *n *** 582,589 **** */ if (remove_old) { ! parent_rel->pathlist = list_delete_cell(parent_rel->pathlist, ! p1, p1_prev); /* * Delete the data pointed-to by the deleted cell, if possible --- 585,591 ---- */ if (remove_old) { ! pathlist = list_delete_cell(pathlist, p1, p1_prev); /* * Delete the data pointed-to by the deleted cell, if possible *************** add_path(RelOptInfo *parent_rel, Path *n *** 614,622 **** { /* Accept the new path: insert it at proper place in pathlist */ if (insert_after) ! lappend_cell(parent_rel->pathlist, insert_after, new_path); else ! parent_rel->pathlist = lcons(new_path, parent_rel->pathlist); } else { --- 616,624 ---- { /* Accept the new path: insert it at proper place in pathlist */ if (insert_after) ! lappend_cell(pathlist, insert_after, new_path); else ! pathlist = lcons(new_path, pathlist); } else { *************** add_path(RelOptInfo *parent_rel, Path *n *** 624,629 **** --- 626,636 ---- if (!IsA(new_path, IndexPath)) pfree(new_path); } + + if (!grouped) + parent_rel->pathlist = pathlist; + else + parent_rel->grouped_pathlist = pathlist; } /* *************** add_path(RelOptInfo *parent_rel, Path *n *** 646,653 **** bool add_path_precheck(RelOptInfo *parent_rel, Cost startup_cost, Cost total_cost, ! List *pathkeys, Relids required_outer) { List *new_path_pathkeys; bool consider_startup; ListCell *p1; --- 653,661 ---- bool add_path_precheck(RelOptInfo *parent_rel, Cost startup_cost, Cost total_cost, ! List *pathkeys, Relids required_outer, bool grouped) { + List *pathlist; List *new_path_pathkeys; bool consider_startup; ListCell *p1; *************** add_path_precheck(RelOptInfo *parent_rel *** 658,664 **** /* Decide whether new path's startup cost is interesting */ consider_startup = required_outer ? parent_rel->consider_param_startup : parent_rel->consider_startup; ! foreach(p1, parent_rel->pathlist) { Path *old_path = (Path *) lfirst(p1); PathKeysComparison keyscmp; --- 666,674 ---- /* Decide whether new path's startup cost is interesting */ consider_startup = required_outer ? parent_rel->consider_param_startup : parent_rel->consider_startup; ! pathlist = !grouped ? parent_rel->pathlist : parent_rel->grouped_pathlist; ! ! foreach(p1, pathlist) { Path *old_path = (Path *) lfirst(p1); PathKeysComparison keyscmp; *************** add_path_precheck(RelOptInfo *parent_rel *** 750,772 **** * isn't an IndexPath. */ void ! add_partial_path(RelOptInfo *parent_rel, Path *new_path) { bool accept_new = true; /* unless we find a superior old path */ ListCell *insert_after = NULL; /* where to insert new item */ ListCell *p1; ListCell *p1_prev; ListCell *p1_next; /* Check for query cancel. */ CHECK_FOR_INTERRUPTS(); /* * As in add_path, throw out any paths which are dominated by the new * path, but throw out the new path if some existing path dominates it. */ p1_prev = NULL; ! for (p1 = list_head(parent_rel->partial_pathlist); p1 != NULL; p1 = p1_next) { Path *old_path = (Path *) lfirst(p1); --- 760,786 ---- * isn't an IndexPath. */ void ! add_partial_path(RelOptInfo *parent_rel, Path *new_path, bool grouped) { bool accept_new = true; /* unless we find a superior old path */ ListCell *insert_after = NULL; /* where to insert new item */ ListCell *p1; ListCell *p1_prev; ListCell *p1_next; + List *pathlist; /* Check for query cancel. */ CHECK_FOR_INTERRUPTS(); + pathlist = !grouped ? parent_rel->partial_pathlist : + parent_rel->partial_grouped_pathlist; + /* * As in add_path, throw out any paths which are dominated by the new * path, but throw out the new path if some existing path dominates it. */ p1_prev = NULL; ! for (p1 = list_head(pathlist); p1 != NULL; p1 = p1_next) { Path *old_path = (Path *) lfirst(p1); *************** add_partial_path(RelOptInfo *parent_rel, *** 820,831 **** } /* ! * Remove current element from partial_pathlist if dominated by new. */ if (remove_old) { ! parent_rel->partial_pathlist = ! list_delete_cell(parent_rel->partial_pathlist, p1, p1_prev); /* we should not see IndexPaths here, so always safe to delete */ Assert(!IsA(old_path, IndexPath)); pfree(old_path); --- 834,844 ---- } /* ! * Remove current element from pathlist if dominated by new. */ if (remove_old) { ! pathlist = list_delete_cell(pathlist, p1, p1_prev); /* we should not see IndexPaths here, so always safe to delete */ Assert(!IsA(old_path, IndexPath)); pfree(old_path); *************** add_partial_path(RelOptInfo *parent_rel, *** 842,848 **** /* * If we found an old path that dominates new_path, we can quit ! * scanning the partial_pathlist; we will not add new_path, and we * assume new_path cannot dominate any later path. */ if (!accept_new) --- 855,861 ---- /* * If we found an old path that dominates new_path, we can quit ! * scanning the pathlist; we will not add new_path, and we * assume new_path cannot dominate any later path. */ if (!accept_new) *************** add_partial_path(RelOptInfo *parent_rel, *** 853,862 **** { /* Accept the new path: insert it at proper place */ if (insert_after) ! lappend_cell(parent_rel->partial_pathlist, insert_after, new_path); else ! parent_rel->partial_pathlist = ! lcons(new_path, parent_rel->partial_pathlist); } else { --- 866,874 ---- { /* Accept the new path: insert it at proper place */ if (insert_after) ! lappend_cell(pathlist, insert_after, new_path); else ! pathlist = lcons(new_path, pathlist); } else { *************** add_partial_path(RelOptInfo *parent_rel, *** 865,870 **** --- 877,887 ---- /* Reject and recycle the new path */ pfree(new_path); } + + if (!grouped) + parent_rel->partial_pathlist = pathlist; + else + parent_rel->partial_grouped_pathlist = pathlist; } /* *************** add_partial_path(RelOptInfo *parent_rel, *** 879,887 **** */ bool add_partial_path_precheck(RelOptInfo *parent_rel, Cost total_cost, ! List *pathkeys) { ListCell *p1; /* * Our goal here is twofold. First, we want to find out whether this path --- 896,906 ---- */ bool add_partial_path_precheck(RelOptInfo *parent_rel, Cost total_cost, ! List *pathkeys, bool grouped) { ListCell *p1; + List *pathlist = !grouped ? parent_rel->partial_pathlist : + parent_rel->partial_grouped_pathlist; /* * Our goal here is twofold. First, we want to find out whether this path *************** add_partial_path_precheck(RelOptInfo *pa *** 891,900 **** * final cost computations. If so, we definitely want to consider it. * * Unlike add_path(), we always compare pathkeys here. This is because we ! * expect partial_pathlist to be very short, and getting a definitive ! * answer at this stage avoids the need to call add_path_precheck. */ ! foreach(p1, parent_rel->partial_pathlist) { Path *old_path = (Path *) lfirst(p1); PathKeysComparison keyscmp; --- 910,920 ---- * final cost computations. If so, we definitely want to consider it. * * Unlike add_path(), we always compare pathkeys here. This is because we ! * expect partial_pathlist / grouped_pathlist to be very short, and ! * getting a definitive answer at this stage avoids the need to call ! * add_path_precheck. */ ! foreach(p1, pathlist) { Path *old_path = (Path *) lfirst(p1); PathKeysComparison keyscmp; *************** add_partial_path_precheck(RelOptInfo *pa *** 923,929 **** * completion. */ if (!add_path_precheck(parent_rel, total_cost, total_cost, pathkeys, ! NULL)) return false; return true; --- 943,949 ---- * completion. */ if (!add_path_precheck(parent_rel, total_cost, total_cost, pathkeys, ! NULL, false)) return false; return true; *************** create_hashjoin_path(PlannerInfo *root, *** 2108,2120 **** Path *inner_path, List *restrict_clauses, Relids required_outer, ! List *hashclauses) { HashPath *pathnode = makeNode(HashPath); pathnode->jpath.path.pathtype = T_HashJoin; pathnode->jpath.path.parent = joinrel; ! pathnode->jpath.path.pathtarget = joinrel->reltarget; pathnode->jpath.path.param_info = get_joinrel_parampathinfo(root, joinrel, --- 2128,2142 ---- Path *inner_path, List *restrict_clauses, Relids required_outer, ! List *hashclauses, ! bool grouped) { HashPath *pathnode = makeNode(HashPath); pathnode->jpath.path.pathtype = T_HashJoin; pathnode->jpath.path.parent = joinrel; ! pathnode->jpath.path.pathtarget = !grouped ? ! joinrel->reltarget : joinrel->reltarget_grouped; pathnode->jpath.path.param_info = get_joinrel_parampathinfo(root, joinrel, diff --git a/src/backend/optimizer/util/relnode.c b/src/backend/optimizer/util/relnode.c new file mode 100644 index 7a8674d..126120f *** a/src/backend/optimizer/util/relnode.c --- b/src/backend/optimizer/util/relnode.c *************** typedef struct JoinHashEntry *** 33,39 **** } JoinHashEntry; static void build_joinrel_tlist(PlannerInfo *root, RelOptInfo *joinrel, ! RelOptInfo *input_rel); static List *build_joinrel_restrictlist(PlannerInfo *root, RelOptInfo *joinrel, RelOptInfo *outer_rel, --- 33,39 ---- } JoinHashEntry; static void build_joinrel_tlist(PlannerInfo *root, RelOptInfo *joinrel, ! RelOptInfo *input_rel, bool grouped); static List *build_joinrel_restrictlist(PlannerInfo *root, RelOptInfo *joinrel, RelOptInfo *outer_rel, *************** build_simple_rel(PlannerInfo *root, int *** 106,114 **** --- 106,117 ---- rel->consider_param_startup = false; /* might get changed later */ rel->consider_parallel = false; /* might get changed later */ rel->reltarget = create_empty_pathtarget(); + /* Not all relations have this target. */ + rel->reltarget_grouped = NULL; rel->pathlist = NIL; rel->ppilist = NIL; rel->partial_pathlist = NIL; + rel->partial_grouped_pathlist = NIL; rel->cheapest_startup_path = NULL; rel->cheapest_total_path = NULL; rel->cheapest_unique_path = NULL; *************** build_join_rel(PlannerInfo *root, *** 371,379 **** --- 374,385 ---- joinrel->consider_param_startup = false; joinrel->consider_parallel = false; joinrel->reltarget = create_empty_pathtarget(); + /* Not all joins have this target. */ + joinrel->reltarget_grouped = NULL; joinrel->pathlist = NIL; joinrel->ppilist = NIL; joinrel->partial_pathlist = NIL; + joinrel->partial_grouped_pathlist = NIL; joinrel->cheapest_startup_path = NULL; joinrel->cheapest_total_path = NULL; joinrel->cheapest_unique_path = NULL; *************** build_join_rel(PlannerInfo *root, *** 459,468 **** * and inner rels we first try to build it from. But the contents should * be the same regardless. */ ! build_joinrel_tlist(root, joinrel, outer_rel); ! build_joinrel_tlist(root, joinrel, inner_rel); add_placeholders_to_joinrel(root, joinrel, outer_rel, inner_rel); /* * add_placeholders_to_joinrel also took care of adding the ph_lateral * sets of any PlaceHolderVars computed here to direct_lateral_relids, so --- 465,488 ---- * and inner rels we first try to build it from. But the contents should * be the same regardless. */ ! build_joinrel_tlist(root, joinrel, outer_rel, false); ! build_joinrel_tlist(root, joinrel, inner_rel, false); add_placeholders_to_joinrel(root, joinrel, outer_rel, inner_rel); + /* Build reltarget_grouped if appropriate. */ + if (outer_rel->reltarget_grouped && inner_rel->reltarget_grouped && + root->all_baserels_grouped) + { + build_joinrel_tlist(root, joinrel, outer_rel, true); + build_joinrel_tlist(root, joinrel, inner_rel, true); + + /* + * No need to add PHVs - if there were some, it'd mean that the join + * is below nullable side of outer join, in which case no + * pre-aggregation should take place. + */ + } + /* * add_placeholders_to_joinrel also took care of adding the ph_lateral * sets of any PlaceHolderVars computed here to direct_lateral_relids, so *************** min_join_parameterization(PlannerInfo *r *** 607,622 **** */ static void build_joinrel_tlist(PlannerInfo *root, RelOptInfo *joinrel, ! RelOptInfo *input_rel) { Relids relids = joinrel->relids; ListCell *vars; ! foreach(vars, input_rel->reltarget->exprs) { Var *var = (Var *) lfirst(vars); RelOptInfo *baserel; int ndx; /* * Ignore PlaceHolderVars in the input tlists; we'll make our own --- 627,665 ---- */ static void build_joinrel_tlist(PlannerInfo *root, RelOptInfo *joinrel, ! RelOptInfo *input_rel, bool grouped) { Relids relids = joinrel->relids; + PathTarget *reltarget_input, *reltarget_result; ListCell *vars; + int i = -1; ! if (!grouped) ! { ! reltarget_input = input_rel->reltarget; ! reltarget_result = joinrel->reltarget; ! } ! else ! { ! reltarget_input = input_rel->reltarget_grouped; ! /* Shouldn't be called otherwise. */ ! Assert(reltarget_input != NULL); ! ! /* Called first time for this joinrel? */ ! if (joinrel->reltarget_grouped == NULL) ! joinrel->reltarget_grouped = create_empty_pathtarget(); ! ! reltarget_result = joinrel->reltarget_grouped; ! } ! ! foreach(vars, reltarget_input->exprs) { Var *var = (Var *) lfirst(vars); RelOptInfo *baserel; int ndx; + Index sortgroupref = 0; + + i++; /* * Ignore PlaceHolderVars in the input tlists; we'll make our own *************** build_joinrel_tlist(PlannerInfo *root, R *** 642,650 **** if (bms_nonempty_difference(baserel->attr_needed[ndx], relids)) { /* Yup, add it to the output */ ! joinrel->reltarget->exprs = lappend(joinrel->reltarget->exprs, var); /* Vars have cost zero, so no need to adjust reltarget->cost */ ! joinrel->reltarget->width += baserel->attr_widths[ndx]; } } } --- 685,697 ---- if (bms_nonempty_difference(baserel->attr_needed[ndx], relids)) { /* Yup, add it to the output */ ! if (reltarget_input->sortgrouprefs) ! sortgroupref = reltarget_input->sortgrouprefs[i]; ! add_column_to_pathtarget(reltarget_result, (Expr *) var, ! sortgroupref); ! /* Vars have cost zero, so no need to adjust reltarget->cost */ ! reltarget_result->width += baserel->attr_widths[ndx]; } } } diff --git a/src/backend/optimizer/util/tlist.c b/src/backend/optimizer/util/tlist.c new file mode 100644 index 45205a8..af1856c *** a/src/backend/optimizer/util/tlist.c --- b/src/backend/optimizer/util/tlist.c *************** *** 14,22 **** --- 14,28 ---- */ #include "postgres.h" + /* + * TODO Consider moving COUNTFNOID away from pg_aggregate.h so it doesn't + * have to be included. + */ + #include "catalog/pg_aggregate.h" #include "nodes/makefuncs.h" #include "nodes/nodeFuncs.h" #include "optimizer/tlist.h" + #include "optimizer/planner.h" /***************************************************************************** *************** apply_pathtarget_labeling_to_tlist(List *** 759,761 **** --- 765,1012 ---- i++; } } + + /* + * Replace each "grouped var" in the source target with its "intermediate + * expression" if one exists, i.e. apply the effect of joins to the result of + * partial aggregation emitted by base relation. + */ + PathTarget * + create_intermediate_grouping_target(PlannerInfo *root, PathTarget *src) + { + PathTarget *result = create_empty_pathtarget(); + int i = 0; + ListCell *l; + + foreach(l, src->exprs) + { + Expr *expr, *expr_new; + Index sortgroupref = 0; + + if (src->sortgrouprefs) + sortgroupref = src->sortgrouprefs[i]; + + expr_new = expr = (Expr *) lfirst(l); + if (IsA(expr, Var)) + { + Var *var = (Var *) expr; + ListCell *lc; + + foreach(lc, root->grouped_var_list) + { + GroupedVarInfo *gvi = (GroupedVarInfo *) lfirst(lc); + + if (gvi->expr_intermediate && + gvi->var->varno == var->varno && + gvi->var->varattno == var->varattno) + { + /* XXX Need a copy? */ + expr_new = gvi->expr_intermediate; + break; + } + } + } + add_column_to_pathtarget(result, expr_new, sortgroupref); + + i++; + } + + return result; + } + + /* + * Replace each "grouped var" in the source targetlist with the original + * expression. This includes the items already replaced by "intermediate + * expression", see create_intermediate_grouping_target. + * + * TODO Think of more suitable name. Although "grouped var" may substitute for + * grouping expressions in the future, currently Aggref is the only outcome of + * the replacement. undo_grouped_var_substitutions? + */ + List * + restore_grouping_expressions(PlannerInfo *root, List *src) + { + List *result = NIL; + ListCell *l; + + foreach(l, src) + { + TargetEntry *te, *te_new; + Expr *expr_new = NULL; + + te = (TargetEntry *) lfirst(l); + + if (IsA(te->expr, Var)) + { + Var *var = (Var *) te->expr; + + expr_new = find_grouped_var_expr(root, var); + } + else + { + /* Is this the "intermediate expression"? */ + ListCell *lc; + + foreach(lc, root->grouped_var_list) + { + GroupedVarInfo *gvi = (GroupedVarInfo *) lfirst(lc); + + /* + * If expr_intermediate was valid, the var should already have + * been replaced by the "intermediate expression" (which + * should be non-Var). + */ + if (gvi->expr_intermediate != NULL && + equal(te->expr, gvi->expr_intermediate)) + { + /* XXX Need a copy? */ + expr_new = gvi->expr; + break; + } + } + } + if (expr_new != NULL) + { + te_new = flatCopyTargetEntry(te); + te_new->expr = expr_new; + } + else + te_new = te; + result = lappend(result, te_new); + } + + return result; + } + + /* + * Find the expression that we've replaced with grouped var earlier. + */ + Expr * + find_grouped_var_expr(PlannerInfo *root, Var *var) + { + ListCell *lc; + + foreach(lc, root->grouped_var_list) + { + GroupedVarInfo *gvi = (GroupedVarInfo *) lfirst(lc); + + if (gvi->var->varno == var->varno && + gvi->var->varattno == var->varattno) + { + /* XXX Need a copy? */ + return gvi->expr; + } + } + + return NULL; + } + + /* + * Add each aggregate to "grouped target" of a relation in the form of special + * variable, for which GroupedVarInfo will also be added to + * root->grouped_var_list. + * + * It doesn't matter that the relation contains no such variables - they will + * be replaced with the partially-aggregated Aggref before execution starts - + * see restore_grouped_var_expr. + * + * countagg represents count(*) aggregate that each grouped rel must have to + * collect information of per-group row count. This information is used to + * adjust the transient state in the output of the final join. + * + * Variable representing the result of countagg is added to *countagg_vars + * list (besides being added to root->grouped_var_list as well, so that it the + * actual count(*) expression be restored by set_upper_references.) + */ + void + add_aggregates_to_grouped_target(PlannerInfo *root, List *aggregates, + RelOptInfo *rel, Aggref *countagg, + List **countagg_vars, bool mark_partial) + { + ListCell *lc; + bool first = true; + + foreach(lc, aggregates) + { + Aggref *aggref = (Aggref *) lfirst(lc); + AttrNumber varattno; + Var *var; + GroupedVarInfo *gvi; + + rel->max_attr++; + varattno = rel->max_attr; + + var = makeVar(rel->relid, varattno, InvalidOid, 0, InvalidOid, 0); + add_new_column_to_pathtarget(rel->reltarget_grouped, (Expr *) var); + + /* + * Create writable copy so that it can be marked as partial, and + * eventually be associated with the final aggregate - see + * set_upper_references. (XXX Is copy necessary for the count(*) + * aggregate as well?) + */ + aggref = copyObject(aggref); + + if (first) + { + /* count(*) should be the first item of the list. */ + Assert(aggref->aggfnoid == COUNTFNOID && aggref->aggstar); + + /* + * The variable representing the auxiliary count(*) is not subject + * to the final aggregation (in fact the result is used as + * argument of aggtransmultifn, which prepares input value for the + * final aggregationq), so there's never reason to restore the + * count(*) expression. Moreover, restoration of the count(*) + * expression outside Aggref (e.g. in the targetlist of the final + * join) would cause ERROR during plan initialization. + * + * So instead of creating GroupedVarInfo we only add the var to a + * list of vars that GroupedVarInfo.expr_intermediate can + * reference. + */ + if (countagg_vars) + *countagg_vars = lappend(*countagg_vars, var); + + first = false; + } + + /* + * Associate the expression with the corresponding variable, so that + * set_upper_references can do the changes explained above. + */ + gvi = (GroupedVarInfo *) palloc0(sizeof(GroupedVarInfo)); + gvi->var = var; + + /* The variable represents result of the partial aggregation. */ + if (mark_partial) + mark_partial_aggref(aggref, AGGSPLIT_INITIAL_SERIAL); + /* The variable type info should reflect the transient type. */ + var->vartype = exprType((Node *) aggref); + var->vartypmod = exprTypmod((Node *) aggref); + var->varcollid = exprCollation((Node *) aggref); + + gvi->expr = (Expr *) aggref; + gvi->sortgroupref = 0; + root->grouped_var_list = lappend(root->grouped_var_list, gvi); + + /* + * Add the variable to rel->attr_needed to ensure propagation to the + * top-level target list. (Non-grouped path are not aware of the + * variable, and they should already be generated by now.) + */ + rel->attr_needed = (Relids *) + repalloc(rel->attr_needed, (rel->max_attr - rel->min_attr + 1) * + sizeof(Relids)); + rel->attr_needed[varattno - rel->min_attr] = bms_make_singleton(0); + + rel->attr_widths = (int32 *) + repalloc(rel->attr_widths, (rel->max_attr - rel->min_attr + 1) * + sizeof(int32)); + /* + * TODO Determine the width and make sure it's used in the grouped + * target. + */ + rel->attr_widths[varattno - rel->min_attr] = 0; + } + } diff --git a/src/backend/parser/parse_func.c b/src/backend/parser/parse_func.c new file mode 100644 index 1297960..ed521bb *** a/src/backend/parser/parse_func.c --- b/src/backend/parser/parse_func.c *************** ParseFuncOrColumn(ParseState *pstate, Li *** 95,100 **** --- 95,101 ---- FuncDetailCode fdresult; char aggkind = 0; ParseCallbackState pcbstate; + Oid aggtransmultifn = InvalidOid; /* * If there's an aggregate filter, transform it using transformWhereClause *************** ParseFuncOrColumn(ParseState *pstate, Li *** 318,323 **** --- 319,325 ---- classForm = (Form_pg_aggregate) GETSTRUCT(tup); aggkind = classForm->aggkind; catDirectArgs = classForm->aggnumdirectargs; + aggtransmultifn = classForm->aggtransmultifn; ReleaseSysCache(tup); /* Now check various disallowed cases. */ *************** ParseFuncOrColumn(ParseState *pstate, Li *** 662,667 **** --- 664,670 ---- aggref->aggstar = agg_star; aggref->aggvariadic = func_variadic; aggref->aggkind = aggkind; + aggref->aggtransmultifn = aggtransmultifn; /* agglevelsup will be set by transformAggregateCall */ aggref->aggsplit = AGGSPLIT_SIMPLE; /* planner might change this */ aggref->location = location; diff --git a/src/backend/utils/adt/float.c b/src/backend/utils/adt/float.c new file mode 100644 index 86b46de..be7ef22 *** a/src/backend/utils/adt/float.c --- b/src/backend/utils/adt/float.c *************** float4_accum(PG_FUNCTION_ARGS) *** 2630,2635 **** --- 2630,2663 ---- } } + /* + * State multiplication function for sum(float4) aggregate. + */ + Datum + float4_sum_mul(PG_FUNCTION_ARGS) + { + float4 state = PG_GETARG_FLOAT4(0); + int64 factor; + + #ifndef USE_FLOAT8_BYVAL /* controls int8 too */ + { + int64 *factor_p = (int64 *) PG_GETARG_POINTER(1); + + factor = *factor_p; + } + #else + factor = PG_GETARG_INT64(1); + #endif + + /* + * Sum of a single group is added each time the same input set is + * aggregated again. + */ + state *= (float8) factor; + + PG_RETURN_FLOAT4(state); + } + Datum float8_avg(PG_FUNCTION_ARGS) { diff --git a/src/backend/utils/adt/selfuncs.c b/src/backend/utils/adt/selfuncs.c new file mode 100644 index 301dffa..944a23e *** a/src/backend/utils/adt/selfuncs.c --- b/src/backend/utils/adt/selfuncs.c *************** *** 111,116 **** --- 111,117 ---- #include "catalog/pg_statistic.h" #include "catalog/pg_type.h" #include "executor/executor.h" + #include "executor/nodeAgg.h" #include "mb/pg_wchar.h" #include "nodes/makefuncs.h" #include "nodes/nodeFuncs.h" *************** estimate_num_groups(PlannerInfo *root, L *** 3426,3432 **** /* * Sanity check --- don't divide by zero if empty relation. */ ! Assert(rel->reloptkind == RELOPT_BASEREL); if (rel->tuples > 0) { /* --- 3427,3434 ---- /* * Sanity check --- don't divide by zero if empty relation. */ ! Assert(rel->reloptkind == RELOPT_BASEREL || ! rel->reloptkind == RELOPT_OTHER_MEMBER_REL); if (rel->tuples > 0) { /* *************** estimate_hash_bucketsize(PlannerInfo *ro *** 3657,3662 **** --- 3659,3692 ---- return (Selectivity) estfract; } + /* + * estimate_hashagg_tablesize + * estimate the number of bytes that a hash aggregate hashtable will + * require based on the agg_costs, path width and dNumGroups. + */ + Size + estimate_hashagg_tablesize(Path *path, const AggClauseCosts *agg_costs, + double dNumGroups) + { + Size hashentrysize; + + /* Estimate per-hash-entry space at tuple width... */ + hashentrysize = MAXALIGN(path->pathtarget->width) + + MAXALIGN(SizeofMinimalTupleHeader); + + /* plus space for pass-by-ref transition values... */ + hashentrysize += agg_costs->transitionSpace; + /* plus the per-hash-entry overhead */ + hashentrysize += hash_agg_entry_size(agg_costs->numAggs); + + /* + * Note that this disregards the effect of fill-factor and growth policy + * of the hash-table. That's probably ok, given default the default + * fill-factor is relatively high. It'd be hard to meaningfully factor in + * "double-in-size" growth policies here. + */ + return hashentrysize * dNumGroups; + } /*------------------------------------------------------------------------- * diff --git a/src/include/catalog/pg_aggregate.h b/src/include/catalog/pg_aggregate.h new file mode 100644 index 1ffde6c..f0b5498 *** a/src/include/catalog/pg_aggregate.h --- b/src/include/catalog/pg_aggregate.h *************** *** 32,37 **** --- 32,38 ---- * aggkind aggregate kind, see AGGKIND_ categories below * aggnumdirectargs number of arguments that are "direct" arguments * aggtransfn transition function + * aggtransmultifn transition state multiplication function * aggfinalfn final function (0 if none) * aggcombinefn combine function (0 if none) * aggserialfn function to convert transtype to bytea (0 if none) *************** CATALOG(pg_aggregate,2600) BKI_WITHOUT_O *** 58,63 **** --- 59,65 ---- char aggkind; int16 aggnumdirectargs; regproc aggtransfn; + regproc aggtransmultifn; regproc aggfinalfn; regproc aggcombinefn; regproc aggserialfn; *************** typedef FormData_pg_aggregate *Form_pg_a *** 91,117 **** * ---------------- */ ! #define Natts_pg_aggregate 20 #define Anum_pg_aggregate_aggfnoid 1 #define Anum_pg_aggregate_aggkind 2 #define Anum_pg_aggregate_aggnumdirectargs 3 #define Anum_pg_aggregate_aggtransfn 4 ! #define Anum_pg_aggregate_aggfinalfn 5 ! #define Anum_pg_aggregate_aggcombinefn 6 ! #define Anum_pg_aggregate_aggserialfn 7 ! #define Anum_pg_aggregate_aggdeserialfn 8 ! #define Anum_pg_aggregate_aggmtransfn 9 ! #define Anum_pg_aggregate_aggminvtransfn 10 ! #define Anum_pg_aggregate_aggmfinalfn 11 ! #define Anum_pg_aggregate_aggfinalextra 12 ! #define Anum_pg_aggregate_aggmfinalextra 13 ! #define Anum_pg_aggregate_aggsortop 14 ! #define Anum_pg_aggregate_aggtranstype 15 ! #define Anum_pg_aggregate_aggtransspace 16 ! #define Anum_pg_aggregate_aggmtranstype 17 ! #define Anum_pg_aggregate_aggmtransspace 18 ! #define Anum_pg_aggregate_agginitval 19 ! #define Anum_pg_aggregate_aggminitval 20 /* * Symbolic values for aggkind column. We distinguish normal aggregates --- 93,120 ---- * ---------------- */ ! #define Natts_pg_aggregate 21 #define Anum_pg_aggregate_aggfnoid 1 #define Anum_pg_aggregate_aggkind 2 #define Anum_pg_aggregate_aggnumdirectargs 3 #define Anum_pg_aggregate_aggtransfn 4 ! #define Anum_pg_aggregate_aggtransmultifn 5 ! #define Anum_pg_aggregate_aggfinalfn 6 ! #define Anum_pg_aggregate_aggcombinefn 7 ! #define Anum_pg_aggregate_aggserialfn 8 ! #define Anum_pg_aggregate_aggdeserialfn 9 ! #define Anum_pg_aggregate_aggmtransfn 10 ! #define Anum_pg_aggregate_aggminvtransfn 11 ! #define Anum_pg_aggregate_aggmfinalfn 12 ! #define Anum_pg_aggregate_aggfinalextra 13 ! #define Anum_pg_aggregate_aggmfinalextra 14 ! #define Anum_pg_aggregate_aggsortop 15 ! #define Anum_pg_aggregate_aggtranstype 16 ! #define Anum_pg_aggregate_aggtransspace 17 ! #define Anum_pg_aggregate_aggmtranstype 18 ! #define Anum_pg_aggregate_aggmtransspace 19 ! #define Anum_pg_aggregate_agginitval 20 ! #define Anum_pg_aggregate_aggminitval 21 /* * Symbolic values for aggkind column. We distinguish normal aggregates *************** typedef FormData_pg_aggregate *Form_pg_a *** 135,318 **** */ /* avg */ ! DATA(insert ( 2100 n 0 int8_avg_accum numeric_poly_avg int8_avg_combine int8_avg_serialize int8_avg_deserialize int8_avg_accum int8_avg_accum_inv numeric_poly_avg f f 0 2281 48 2281 48 _null_ _null_ )); ! DATA(insert ( 2101 n 0 int4_avg_accum int8_avg int4_avg_combine - - int4_avg_accum int4_avg_accum_inv int8_avg f f 0 1016 0 1016 0 "{0,0}" "{0,0}" )); ! DATA(insert ( 2102 n 0 int2_avg_accum int8_avg int4_avg_combine - - int2_avg_accum int2_avg_accum_inv int8_avg f f 0 1016 0 1016 0 "{0,0}" "{0,0}" )); ! DATA(insert ( 2103 n 0 numeric_avg_accum numeric_avg numeric_avg_combine numeric_avg_serialize numeric_avg_deserialize numeric_avg_accum numeric_accum_inv numeric_avg f f 0 2281 128 2281 128 _null_ _null_ )); ! DATA(insert ( 2104 n 0 float4_accum float8_avg float8_combine - - - - - f f 0 1022 0 0 0 "{0,0,0}" _null_ )); ! DATA(insert ( 2105 n 0 float8_accum float8_avg float8_combine - - - - - f f 0 1022 0 0 0 "{0,0,0}" _null_ )); ! DATA(insert ( 2106 n 0 interval_accum interval_avg interval_combine - - interval_accum interval_accum_inv interval_avg f f 0 1187 0 1187 0 "{0 second,0 second}" "{0 second,0 second}" )); /* sum */ ! DATA(insert ( 2107 n 0 int8_avg_accum numeric_poly_sum int8_avg_combine int8_avg_serialize int8_avg_deserialize int8_avg_accum int8_avg_accum_inv numeric_poly_sum f f 0 2281 48 2281 48 _null_ _null_ )); ! DATA(insert ( 2108 n 0 int4_sum - int8pl - - int4_avg_accum int4_avg_accum_inv int2int4_sum f f 0 20 0 1016 0 _null_ "{0,0}" )); ! DATA(insert ( 2109 n 0 int2_sum - int8pl - - int2_avg_accum int2_avg_accum_inv int2int4_sum f f 0 20 0 1016 0 _null_ "{0,0}" )); ! DATA(insert ( 2110 n 0 float4pl - float4pl - - - - - f f 0 700 0 0 0 _null_ _null_ )); ! DATA(insert ( 2111 n 0 float8pl - float8pl - - - - - f f 0 701 0 0 0 _null_ _null_ )); ! DATA(insert ( 2112 n 0 cash_pl - cash_pl - - cash_pl cash_mi - f f 0 790 0 790 0 _null_ _null_ )); ! DATA(insert ( 2113 n 0 interval_pl - interval_pl - - interval_pl interval_mi - f f 0 1186 0 1186 0 _null_ _null_ )); ! DATA(insert ( 2114 n 0 numeric_avg_accum numeric_sum numeric_avg_combine numeric_avg_serialize numeric_avg_deserialize numeric_avg_accum numeric_accum_inv numeric_sum f f 0 2281 128 2281 128 _null_ _null_ )); /* max */ ! DATA(insert ( 2115 n 0 int8larger - int8larger - - - - - f f 413 20 0 0 0 _null_ _null_ )); ! DATA(insert ( 2116 n 0 int4larger - int4larger - - - - - f f 521 23 0 0 0 _null_ _null_ )); ! DATA(insert ( 2117 n 0 int2larger - int2larger - - - - - f f 520 21 0 0 0 _null_ _null_ )); ! DATA(insert ( 2118 n 0 oidlarger - oidlarger - - - - - f f 610 26 0 0 0 _null_ _null_ )); ! DATA(insert ( 2119 n 0 float4larger - float4larger - - - - - f f 623 700 0 0 0 _null_ _null_ )); ! DATA(insert ( 2120 n 0 float8larger - float8larger - - - - - f f 674 701 0 0 0 _null_ _null_ )); ! DATA(insert ( 2121 n 0 int4larger - int4larger - - - - - f f 563 702 0 0 0 _null_ _null_ )); ! DATA(insert ( 2122 n 0 date_larger - date_larger - - - - - f f 1097 1082 0 0 0 _null_ _null_ )); ! DATA(insert ( 2123 n 0 time_larger - time_larger - - - - - f f 1112 1083 0 0 0 _null_ _null_ )); ! DATA(insert ( 2124 n 0 timetz_larger - timetz_larger - - - - - f f 1554 1266 0 0 0 _null_ _null_ )); ! DATA(insert ( 2125 n 0 cashlarger - cashlarger - - - - - f f 903 790 0 0 0 _null_ _null_ )); ! DATA(insert ( 2126 n 0 timestamp_larger - timestamp_larger - - - - - f f 2064 1114 0 0 0 _null_ _null_ )); ! DATA(insert ( 2127 n 0 timestamptz_larger - timestamptz_larger - - - - - f f 1324 1184 0 0 0 _null_ _null_ )); ! DATA(insert ( 2128 n 0 interval_larger - interval_larger - - - - - f f 1334 1186 0 0 0 _null_ _null_ )); ! DATA(insert ( 2129 n 0 text_larger - text_larger - - - - - f f 666 25 0 0 0 _null_ _null_ )); ! DATA(insert ( 2130 n 0 numeric_larger - numeric_larger - - - - - f f 1756 1700 0 0 0 _null_ _null_ )); ! DATA(insert ( 2050 n 0 array_larger - array_larger - - - - - f f 1073 2277 0 0 0 _null_ _null_ )); ! DATA(insert ( 2244 n 0 bpchar_larger - bpchar_larger - - - - - f f 1060 1042 0 0 0 _null_ _null_ )); ! DATA(insert ( 2797 n 0 tidlarger - tidlarger - - - - - f f 2800 27 0 0 0 _null_ _null_ )); ! DATA(insert ( 3526 n 0 enum_larger - enum_larger - - - - - f f 3519 3500 0 0 0 _null_ _null_ )); ! DATA(insert ( 3564 n 0 network_larger - network_larger - - - - - f f 1205 869 0 0 0 _null_ _null_ )); /* min */ ! DATA(insert ( 2131 n 0 int8smaller - int8smaller - - - - - f f 412 20 0 0 0 _null_ _null_ )); ! DATA(insert ( 2132 n 0 int4smaller - int4smaller - - - - - f f 97 23 0 0 0 _null_ _null_ )); ! DATA(insert ( 2133 n 0 int2smaller - int2smaller - - - - - f f 95 21 0 0 0 _null_ _null_ )); ! DATA(insert ( 2134 n 0 oidsmaller - oidsmaller - - - - - f f 609 26 0 0 0 _null_ _null_ )); ! DATA(insert ( 2135 n 0 float4smaller - float4smaller - - - - - f f 622 700 0 0 0 _null_ _null_ )); ! DATA(insert ( 2136 n 0 float8smaller - float8smaller - - - - - f f 672 701 0 0 0 _null_ _null_ )); ! DATA(insert ( 2137 n 0 int4smaller - int4smaller - - - - - f f 562 702 0 0 0 _null_ _null_ )); ! DATA(insert ( 2138 n 0 date_smaller - date_smaller - - - - - f f 1095 1082 0 0 0 _null_ _null_ )); ! DATA(insert ( 2139 n 0 time_smaller - time_smaller - - - - - f f 1110 1083 0 0 0 _null_ _null_ )); ! DATA(insert ( 2140 n 0 timetz_smaller - timetz_smaller - - - - - f f 1552 1266 0 0 0 _null_ _null_ )); ! DATA(insert ( 2141 n 0 cashsmaller - cashsmaller - - - - - f f 902 790 0 0 0 _null_ _null_ )); ! DATA(insert ( 2142 n 0 timestamp_smaller - timestamp_smaller - - - - - f f 2062 1114 0 0 0 _null_ _null_ )); ! DATA(insert ( 2143 n 0 timestamptz_smaller - timestamptz_smaller - - - - - f f 1322 1184 0 0 0 _null_ _null_ )); ! DATA(insert ( 2144 n 0 interval_smaller - interval_smaller - - - - - f f 1332 1186 0 0 0 _null_ _null_ )); ! DATA(insert ( 2145 n 0 text_smaller - text_smaller - - - - - f f 664 25 0 0 0 _null_ _null_ )); ! DATA(insert ( 2146 n 0 numeric_smaller - numeric_smaller - - - - - f f 1754 1700 0 0 0 _null_ _null_ )); ! DATA(insert ( 2051 n 0 array_smaller - array_smaller - - - - - f f 1072 2277 0 0 0 _null_ _null_ )); ! DATA(insert ( 2245 n 0 bpchar_smaller - bpchar_smaller - - - - - f f 1058 1042 0 0 0 _null_ _null_ )); ! DATA(insert ( 2798 n 0 tidsmaller - tidsmaller - - - - - f f 2799 27 0 0 0 _null_ _null_ )); ! DATA(insert ( 3527 n 0 enum_smaller - enum_smaller - - - - - f f 3518 3500 0 0 0 _null_ _null_ )); ! DATA(insert ( 3565 n 0 network_smaller - network_smaller - - - - - f f 1203 869 0 0 0 _null_ _null_ )); /* count */ ! DATA(insert ( 2147 n 0 int8inc_any - int8pl - - int8inc_any int8dec_any - f f 0 20 0 20 0 "0" "0" )); ! DATA(insert ( 2803 n 0 int8inc - int8pl - - int8inc int8dec - f f 0 20 0 20 0 "0" "0" )); /* var_pop */ ! DATA(insert ( 2718 n 0 int8_accum numeric_var_pop numeric_combine numeric_serialize numeric_deserialize int8_accum int8_accum_inv numeric_var_pop f f 0 2281 128 2281 128 _null_ _null_ )); ! DATA(insert ( 2719 n 0 int4_accum numeric_poly_var_pop numeric_poly_combine numeric_poly_serialize numeric_poly_deserialize int4_accum int4_accum_inv numeric_poly_var_pop f f 0 2281 48 2281 48 _null_ _null_ )); ! DATA(insert ( 2720 n 0 int2_accum numeric_poly_var_pop numeric_poly_combine numeric_poly_serialize numeric_poly_deserialize int2_accum int2_accum_inv numeric_poly_var_pop f f 0 2281 48 2281 48 _null_ _null_ )); ! DATA(insert ( 2721 n 0 float4_accum float8_var_pop float8_combine - - - - - f f 0 1022 0 0 0 "{0,0,0}" _null_ )); ! DATA(insert ( 2722 n 0 float8_accum float8_var_pop float8_combine - - - - - f f 0 1022 0 0 0 "{0,0,0}" _null_ )); ! DATA(insert ( 2723 n 0 numeric_accum numeric_var_pop numeric_combine numeric_serialize numeric_deserialize numeric_accum numeric_accum_inv numeric_var_pop f f 0 2281 128 2281 128 _null_ _null_ )); /* var_samp */ ! DATA(insert ( 2641 n 0 int8_accum numeric_var_samp numeric_combine numeric_serialize numeric_deserialize int8_accum int8_accum_inv numeric_var_samp f f 0 2281 128 2281 128 _null_ _null_ )); ! DATA(insert ( 2642 n 0 int4_accum numeric_poly_var_samp numeric_poly_combine numeric_poly_serialize numeric_poly_deserialize int4_accum int4_accum_inv numeric_poly_var_samp f f 0 2281 48 2281 48 _null_ _null_ )); ! DATA(insert ( 2643 n 0 int2_accum numeric_poly_var_samp numeric_poly_combine numeric_poly_serialize numeric_poly_deserialize int2_accum int2_accum_inv numeric_poly_var_samp f f 0 2281 48 2281 48 _null_ _null_ )); ! DATA(insert ( 2644 n 0 float4_accum float8_var_samp float8_combine - - - - - f f 0 1022 0 0 0 "{0,0,0}" _null_ )); ! DATA(insert ( 2645 n 0 float8_accum float8_var_samp float8_combine - - - - - f f 0 1022 0 0 0 "{0,0,0}" _null_ )); ! DATA(insert ( 2646 n 0 numeric_accum numeric_var_samp numeric_combine numeric_serialize numeric_deserialize numeric_accum numeric_accum_inv numeric_var_samp f f 0 2281 128 2281 128 _null_ _null_ )); /* variance: historical Postgres syntax for var_samp */ ! DATA(insert ( 2148 n 0 int8_accum numeric_var_samp numeric_combine numeric_serialize numeric_deserialize int8_accum int8_accum_inv numeric_var_samp f f 0 2281 128 2281 128 _null_ _null_ )); ! DATA(insert ( 2149 n 0 int4_accum numeric_poly_var_samp numeric_poly_combine numeric_poly_serialize numeric_poly_deserialize int4_accum int4_accum_inv numeric_poly_var_samp f f 0 2281 48 2281 48 _null_ _null_ )); ! DATA(insert ( 2150 n 0 int2_accum numeric_poly_var_samp numeric_poly_combine numeric_poly_serialize numeric_poly_deserialize int2_accum int2_accum_inv numeric_poly_var_samp f f 0 2281 48 2281 48 _null_ _null_ )); ! DATA(insert ( 2151 n 0 float4_accum float8_var_samp float8_combine - - - - - f f 0 1022 0 0 0 "{0,0,0}" _null_ )); ! DATA(insert ( 2152 n 0 float8_accum float8_var_samp float8_combine - - - - - f f 0 1022 0 0 0 "{0,0,0}" _null_ )); ! DATA(insert ( 2153 n 0 numeric_accum numeric_var_samp numeric_combine numeric_serialize numeric_deserialize numeric_accum numeric_accum_inv numeric_var_samp f f 0 2281 128 2281 128 _null_ _null_ )); /* stddev_pop */ ! DATA(insert ( 2724 n 0 int8_accum numeric_stddev_pop numeric_combine numeric_serialize numeric_deserialize int8_accum int8_accum_inv numeric_stddev_pop f f 0 2281 128 2281 128 _null_ _null_ )); ! DATA(insert ( 2725 n 0 int4_accum numeric_poly_stddev_pop numeric_poly_combine numeric_poly_serialize numeric_poly_deserialize int4_accum int4_accum_inv numeric_poly_stddev_pop f f 0 2281 48 2281 48 _null_ _null_ )); ! DATA(insert ( 2726 n 0 int2_accum numeric_poly_stddev_pop numeric_poly_combine numeric_poly_serialize numeric_poly_deserialize int2_accum int2_accum_inv numeric_poly_stddev_pop f f 0 2281 48 2281 48 _null_ _null_ )); ! DATA(insert ( 2727 n 0 float4_accum float8_stddev_pop float8_combine - - - - - f f 0 1022 0 0 0 "{0,0,0}" _null_ )); ! DATA(insert ( 2728 n 0 float8_accum float8_stddev_pop float8_combine - - - - - f f 0 1022 0 0 0 "{0,0,0}" _null_ )); ! DATA(insert ( 2729 n 0 numeric_accum numeric_stddev_pop numeric_combine numeric_serialize numeric_deserialize numeric_accum numeric_accum_inv numeric_stddev_pop f f 0 2281 128 2281 128 _null_ _null_ )); /* stddev_samp */ ! DATA(insert ( 2712 n 0 int8_accum numeric_stddev_samp numeric_combine numeric_serialize numeric_deserialize int8_accum int8_accum_inv numeric_stddev_samp f f 0 2281 128 2281 128 _null_ _null_ )); ! DATA(insert ( 2713 n 0 int4_accum numeric_poly_stddev_samp numeric_poly_combine numeric_poly_serialize numeric_poly_deserialize int4_accum int4_accum_inv numeric_poly_stddev_samp f f 0 2281 48 2281 48 _null_ _null_ )); ! DATA(insert ( 2714 n 0 int2_accum numeric_poly_stddev_samp numeric_poly_combine numeric_poly_serialize numeric_poly_deserialize int2_accum int2_accum_inv numeric_poly_stddev_samp f f 0 2281 48 2281 48 _null_ _null_ )); ! DATA(insert ( 2715 n 0 float4_accum float8_stddev_samp float8_combine - - - - - f f 0 1022 0 0 0 "{0,0,0}" _null_ )); ! DATA(insert ( 2716 n 0 float8_accum float8_stddev_samp float8_combine - - - - - f f 0 1022 0 0 0 "{0,0,0}" _null_ )); ! DATA(insert ( 2717 n 0 numeric_accum numeric_stddev_samp numeric_combine numeric_serialize numeric_deserialize numeric_accum numeric_accum_inv numeric_stddev_samp f f 0 2281 128 2281 128 _null_ _null_ )); /* stddev: historical Postgres syntax for stddev_samp */ ! DATA(insert ( 2154 n 0 int8_accum numeric_stddev_samp numeric_combine numeric_serialize numeric_deserialize int8_accum int8_accum_inv numeric_stddev_samp f f 0 2281 128 2281 128 _null_ _null_ )); ! DATA(insert ( 2155 n 0 int4_accum numeric_poly_stddev_samp numeric_poly_combine numeric_poly_serialize numeric_poly_deserialize int4_accum int4_accum_inv numeric_poly_stddev_samp f f 0 2281 48 2281 48 _null_ _null_ )); ! DATA(insert ( 2156 n 0 int2_accum numeric_poly_stddev_samp numeric_poly_combine numeric_poly_serialize numeric_poly_deserialize int2_accum int2_accum_inv numeric_poly_stddev_samp f f 0 2281 48 2281 48 _null_ _null_ )); ! DATA(insert ( 2157 n 0 float4_accum float8_stddev_samp float8_combine - - - - - f f 0 1022 0 0 0 "{0,0,0}" _null_ )); ! DATA(insert ( 2158 n 0 float8_accum float8_stddev_samp float8_combine - - - - - f f 0 1022 0 0 0 "{0,0,0}" _null_ )); ! DATA(insert ( 2159 n 0 numeric_accum numeric_stddev_samp numeric_combine numeric_serialize numeric_deserialize numeric_accum numeric_accum_inv numeric_stddev_samp f f 0 2281 128 2281 128 _null_ _null_ )); /* SQL2003 binary regression aggregates */ ! DATA(insert ( 2818 n 0 int8inc_float8_float8 - int8pl - - - - - f f 0 20 0 0 0 "0" _null_ )); ! DATA(insert ( 2819 n 0 float8_regr_accum float8_regr_sxx float8_regr_combine - - - - - f f 0 1022 0 0 0 "{0,0,0,0,0,0}" _null_ )); ! DATA(insert ( 2820 n 0 float8_regr_accum float8_regr_syy float8_regr_combine - - - - - f f 0 1022 0 0 0 "{0,0,0,0,0,0}" _null_ )); ! DATA(insert ( 2821 n 0 float8_regr_accum float8_regr_sxy float8_regr_combine - - - - - f f 0 1022 0 0 0 "{0,0,0,0,0,0}" _null_ )); ! DATA(insert ( 2822 n 0 float8_regr_accum float8_regr_avgx float8_regr_combine - - - - - f f 0 1022 0 0 0 "{0,0,0,0,0,0}" _null_ )); ! DATA(insert ( 2823 n 0 float8_regr_accum float8_regr_avgy float8_regr_combine - - - - - f f 0 1022 0 0 0 "{0,0,0,0,0,0}" _null_ )); ! DATA(insert ( 2824 n 0 float8_regr_accum float8_regr_r2 float8_regr_combine - - - - - f f 0 1022 0 0 0 "{0,0,0,0,0,0}" _null_ )); ! DATA(insert ( 2825 n 0 float8_regr_accum float8_regr_slope float8_regr_combine - - - - - f f 0 1022 0 0 0 "{0,0,0,0,0,0}" _null_ )); ! DATA(insert ( 2826 n 0 float8_regr_accum float8_regr_intercept float8_regr_combine - - - - - f f 0 1022 0 0 0 "{0,0,0,0,0,0}" _null_ )); ! DATA(insert ( 2827 n 0 float8_regr_accum float8_covar_pop float8_regr_combine - - - - - f f 0 1022 0 0 0 "{0,0,0,0,0,0}" _null_ )); ! DATA(insert ( 2828 n 0 float8_regr_accum float8_covar_samp float8_regr_combine - - - - - f f 0 1022 0 0 0 "{0,0,0,0,0,0}" _null_ )); ! DATA(insert ( 2829 n 0 float8_regr_accum float8_corr float8_regr_combine - - - - - f f 0 1022 0 0 0 "{0,0,0,0,0,0}" _null_ )); /* boolean-and and boolean-or */ ! DATA(insert ( 2517 n 0 booland_statefunc - booland_statefunc - - bool_accum bool_accum_inv bool_alltrue f f 58 16 0 2281 16 _null_ _null_ )); ! DATA(insert ( 2518 n 0 boolor_statefunc - boolor_statefunc - - bool_accum bool_accum_inv bool_anytrue f f 59 16 0 2281 16 _null_ _null_ )); ! DATA(insert ( 2519 n 0 booland_statefunc - booland_statefunc - - bool_accum bool_accum_inv bool_alltrue f f 58 16 0 2281 16 _null_ _null_ )); /* bitwise integer */ ! DATA(insert ( 2236 n 0 int2and - int2and - - - - - f f 0 21 0 0 0 _null_ _null_ )); ! DATA(insert ( 2237 n 0 int2or - int2or - - - - - f f 0 21 0 0 0 _null_ _null_ )); ! DATA(insert ( 2238 n 0 int4and - int4and - - - - - f f 0 23 0 0 0 _null_ _null_ )); ! DATA(insert ( 2239 n 0 int4or - int4or - - - - - f f 0 23 0 0 0 _null_ _null_ )); ! DATA(insert ( 2240 n 0 int8and - int8and - - - - - f f 0 20 0 0 0 _null_ _null_ )); ! DATA(insert ( 2241 n 0 int8or - int8or - - - - - f f 0 20 0 0 0 _null_ _null_ )); ! DATA(insert ( 2242 n 0 bitand - bitand - - - - - f f 0 1560 0 0 0 _null_ _null_ )); ! DATA(insert ( 2243 n 0 bitor - bitor - - - - - f f 0 1560 0 0 0 _null_ _null_ )); /* xml */ ! DATA(insert ( 2901 n 0 xmlconcat2 - - - - - - - f f 0 142 0 0 0 _null_ _null_ )); /* array */ ! DATA(insert ( 2335 n 0 array_agg_transfn array_agg_finalfn - - - - - - t f 0 2281 0 0 0 _null_ _null_ )); ! DATA(insert ( 4053 n 0 array_agg_array_transfn array_agg_array_finalfn - - - - - - t f 0 2281 0 0 0 _null_ _null_ )); /* text */ ! DATA(insert ( 3538 n 0 string_agg_transfn string_agg_finalfn - - - - - - f f 0 2281 0 0 0 _null_ _null_ )); /* bytea */ ! DATA(insert ( 3545 n 0 bytea_string_agg_transfn bytea_string_agg_finalfn - - - - - - f f 0 2281 0 0 0 _null_ _null_ )); /* json */ ! DATA(insert ( 3175 n 0 json_agg_transfn json_agg_finalfn - - - - - - f f 0 2281 0 0 0 _null_ _null_ )); ! DATA(insert ( 3197 n 0 json_object_agg_transfn json_object_agg_finalfn - - - - - - f f 0 2281 0 0 0 _null_ _null_ )); /* jsonb */ ! DATA(insert ( 3267 n 0 jsonb_agg_transfn jsonb_agg_finalfn - - - - - - f f 0 2281 0 0 0 _null_ _null_ )); ! DATA(insert ( 3270 n 0 jsonb_object_agg_transfn jsonb_object_agg_finalfn - - - - - - f f 0 2281 0 0 0 _null_ _null_ )); /* ordered-set and hypothetical-set aggregates */ ! DATA(insert ( 3972 o 1 ordered_set_transition percentile_disc_final - - - - - - t f 0 2281 0 0 0 _null_ _null_ )); ! DATA(insert ( 3974 o 1 ordered_set_transition percentile_cont_float8_final - - - - - - f f 0 2281 0 0 0 _null_ _null_ )); ! DATA(insert ( 3976 o 1 ordered_set_transition percentile_cont_interval_final - - - - - - f f 0 2281 0 0 0 _null_ _null_ )); ! DATA(insert ( 3978 o 1 ordered_set_transition percentile_disc_multi_final - - - - - - t f 0 2281 0 0 0 _null_ _null_ )); ! DATA(insert ( 3980 o 1 ordered_set_transition percentile_cont_float8_multi_final - - - - - - f f 0 2281 0 0 0 _null_ _null_ )); ! DATA(insert ( 3982 o 1 ordered_set_transition percentile_cont_interval_multi_final - - - - - - f f 0 2281 0 0 0 _null_ _null_ )); ! DATA(insert ( 3984 o 0 ordered_set_transition mode_final - - - - - - t f 0 2281 0 0 0 _null_ _null_ )); ! DATA(insert ( 3986 h 1 ordered_set_transition_multi rank_final - - - - - - t f 0 2281 0 0 0 _null_ _null_ )); ! DATA(insert ( 3988 h 1 ordered_set_transition_multi percent_rank_final - - - - - - t f 0 2281 0 0 0 _null_ _null_ )); ! DATA(insert ( 3990 h 1 ordered_set_transition_multi cume_dist_final - - - - - - t f 0 2281 0 0 0 _null_ _null_ )); ! DATA(insert ( 3992 h 1 ordered_set_transition_multi dense_rank_final - - - - - - t f 0 2281 0 0 0 _null_ _null_ )); /* --- 138,322 ---- */ /* avg */ ! DATA(insert ( 2100 n 0 int8_avg_accum 0 numeric_poly_avg int8_avg_combine int8_avg_serialize int8_avg_deserialize int8_avg_accum int8_avg_accum_inv numeric_poly_avg f f 0 2281 48 2281 48 _null_ _null_ )); ! DATA(insert ( 2101 n 0 int4_avg_accum 0 int8_avg int4_avg_combine - - int4_avg_accum int4_avg_accum_inv int8_avg f f 0 1016 0 1016 0 "{0,0}" "{0,0}" )); ! DATA(insert ( 2102 n 0 int2_avg_accum 0 int8_avg int4_avg_combine - - int2_avg_accum int2_avg_accum_inv int8_avg f f 0 1016 0 1016 0 "{0,0}" "{0,0}" )); ! DATA(insert ( 2103 n 0 numeric_avg_accum 0 numeric_avg numeric_avg_combine numeric_avg_serialize numeric_avg_deserialize numeric_avg_accum numeric_accum_inv numeric_avg f f 0 2281 128 2281 128 _null_ _null_ )); ! DATA(insert ( 2104 n 0 float4_accum 0 float8_avg float8_combine - - - - - f f 0 1022 0 0 0 "{0,0,0}" _null_ )); ! DATA(insert ( 2105 n 0 float8_accum 0 float8_avg float8_combine - - - - - f f 0 1022 0 0 0 "{0,0,0}" _null_ )); ! DATA(insert ( 2106 n 0 interval_accum 0 interval_avg interval_combine - - interval_accum interval_accum_inv interval_avg f f 0 1187 0 1187 0 "{0 second,0 second}" "{0 second,0 second}" )); /* sum */ ! DATA(insert ( 2107 n 0 int8_avg_accum 0 numeric_poly_sum int8_avg_combine int8_avg_serialize int8_avg_deserialize int8_avg_accum int8_avg_accum_inv numeric_poly_sum f f 0 2281 48 2281 48 _null_ _null_ )); ! DATA(insert ( 2108 n 0 int4_sum 0 - int8pl - - int4_avg_accum int4_avg_accum_inv int2int4_sum f f 0 20 0 1016 0 _null_ "{0,0}" )); ! DATA(insert ( 2109 n 0 int2_sum 0 - int8pl - - int2_avg_accum int2_avg_accum_inv int2int4_sum f f 0 20 0 1016 0 _null_ "{0,0}" )); ! DATA(insert ( 2110 n 0 float4pl 4002 - float4pl - - - - - f f 0 700 0 0 0 _null_ _null_ )); ! DATA(insert ( 2111 n 0 float8pl 0 - float8pl - - - - - f f 0 701 0 0 0 _null_ _null_ )); ! DATA(insert ( 2112 n 0 cash_pl 0 - cash_pl - - cash_pl cash_mi - f f 0 790 0 790 0 _null_ _null_ )); ! DATA(insert ( 2113 n 0 interval_pl 0 - interval_pl - - interval_pl interval_mi - f f 0 1186 0 1186 0 _null_ _null_ )); ! DATA(insert ( 2114 n 0 numeric_avg_accum 0 numeric_sum numeric_avg_combine numeric_avg_serialize numeric_avg_deserialize numeric_avg_accum numeric_accum_inv numeric_sum f f 0 2281 128 2281 128 _null_ _null_ )); /* max */ ! DATA(insert ( 2115 n 0 int8larger 0 - int8larger - - - - - f f 413 20 0 0 0 _null_ _null_ )); ! DATA(insert ( 2116 n 0 int4larger 0 - int4larger - - - - - f f 521 23 0 0 0 _null_ _null_ )); ! DATA(insert ( 2117 n 0 int2larger 0 - int2larger - - - - - f f 520 21 0 0 0 _null_ _null_ )); ! DATA(insert ( 2118 n 0 oidlarger 0 - oidlarger - - - - - f f 610 26 0 0 0 _null_ _null_ )); ! DATA(insert ( 2119 n 0 float4larger 0 - float4larger - - - - - f f 623 700 0 0 0 _null_ _null_ )); ! DATA(insert ( 2120 n 0 float8larger 0 - float8larger - - - - - f f 674 701 0 0 0 _null_ _null_ )); ! DATA(insert ( 2121 n 0 int4larger 0 - int4larger - - - - - f f 563 702 0 0 0 _null_ _null_ )); ! DATA(insert ( 2122 n 0 date_larger 0 - date_larger - - - - - f f 1097 1082 0 0 0 _null_ _null_ )); ! DATA(insert ( 2123 n 0 time_larger 0 - time_larger - - - - - f f 1112 1083 0 0 0 _null_ _null_ )); ! DATA(insert ( 2124 n 0 timetz_larger 0 - timetz_larger - - - - - f f 1554 1266 0 0 0 _null_ _null_ )); ! DATA(insert ( 2125 n 0 cashlarger 0 - cashlarger - - - - - f f 903 790 0 0 0 _null_ _null_ )); ! DATA(insert ( 2126 n 0 timestamp_larger 0 - timestamp_larger - - - - - f f 2064 1114 0 0 0 _null_ _null_ )); ! DATA(insert ( 2127 n 0 timestamptz_larger 0 - timestamptz_larger - - - - - f f 1324 1184 0 0 0 _null_ _null_ )); ! DATA(insert ( 2128 n 0 interval_larger 0 - interval_larger - - - - - f f 1334 1186 0 0 0 _null_ _null_ )); ! DATA(insert ( 2129 n 0 text_larger 0 - text_larger - - - - - f f 666 25 0 0 0 _null_ _null_ )); ! DATA(insert ( 2130 n 0 numeric_larger 0 - numeric_larger - - - - - f f 1756 1700 0 0 0 _null_ _null_ )); ! DATA(insert ( 2050 n 0 array_larger 0 - array_larger - - - - - f f 1073 2277 0 0 0 _null_ _null_ )); ! DATA(insert ( 2244 n 0 bpchar_larger 0 - bpchar_larger - - - - - f f 1060 1042 0 0 0 _null_ _null_ )); ! DATA(insert ( 2797 n 0 tidlarger 0 - tidlarger - - - - - f f 2800 27 0 0 0 _null_ _null_ )); ! DATA(insert ( 3526 n 0 enum_larger 0 - enum_larger - - - - - f f 3519 3500 0 0 0 _null_ _null_ )); ! DATA(insert ( 3564 n 0 network_larger 0 - network_larger - - - - - f f 1205 869 0 0 0 _null_ _null_ )); /* min */ ! DATA(insert ( 2131 n 0 int8smaller 0 - int8smaller - - - - - f f 412 20 0 0 0 _null_ _null_ )); ! DATA(insert ( 2132 n 0 int4smaller 0 - int4smaller - - - - - f f 97 23 0 0 0 _null_ _null_ )); ! DATA(insert ( 2133 n 0 int2smaller 0 - int2smaller - - - - - f f 95 21 0 0 0 _null_ _null_ )); ! DATA(insert ( 2134 n 0 oidsmaller 0 - oidsmaller - - - - - f f 609 26 0 0 0 _null_ _null_ )); ! DATA(insert ( 2135 n 0 float4smaller 0 - float4smaller - - - - - f f 622 700 0 0 0 _null_ _null_ )); ! DATA(insert ( 2136 n 0 float8smaller 0 - float8smaller - - - - - f f 672 701 0 0 0 _null_ _null_ )); ! DATA(insert ( 2137 n 0 int4smaller 0 - int4smaller - - - - - f f 562 702 0 0 0 _null_ _null_ )); ! DATA(insert ( 2138 n 0 date_smaller 0 - date_smaller - - - - - f f 1095 1082 0 0 0 _null_ _null_ )); ! DATA(insert ( 2139 n 0 time_smaller 0 - time_smaller - - - - - f f 1110 1083 0 0 0 _null_ _null_ )); ! DATA(insert ( 2140 n 0 timetz_smaller 0 - timetz_smaller - - - - - f f 1552 1266 0 0 0 _null_ _null_ )); ! DATA(insert ( 2141 n 0 cashsmaller 0 - cashsmaller - - - - - f f 902 790 0 0 0 _null_ _null_ )); ! DATA(insert ( 2142 n 0 timestamp_smaller 0 - timestamp_smaller - - - - - f f 2062 1114 0 0 0 _null_ _null_ )); ! DATA(insert ( 2143 n 0 timestamptz_smaller 0 - timestamptz_smaller - - - - - f f 1322 1184 0 0 0 _null_ _null_ )); ! DATA(insert ( 2144 n 0 interval_smaller 0 - interval_smaller - - - - - f f 1332 1186 0 0 0 _null_ _null_ )); ! DATA(insert ( 2145 n 0 text_smaller 0 - text_smaller - - - - - f f 664 25 0 0 0 _null_ _null_ )); ! DATA(insert ( 2146 n 0 numeric_smaller 0 - numeric_smaller - - - - - f f 1754 1700 0 0 0 _null_ _null_ )); ! DATA(insert ( 2051 n 0 array_smaller 0 - array_smaller - - - - - f f 1072 2277 0 0 0 _null_ _null_ )); ! DATA(insert ( 2245 n 0 bpchar_smaller 0 - bpchar_smaller - - - - - f f 1058 1042 0 0 0 _null_ _null_ )); ! DATA(insert ( 2798 n 0 tidsmaller 0 - tidsmaller - - - - - f f 2799 27 0 0 0 _null_ _null_ )); ! DATA(insert ( 3527 n 0 enum_smaller 0 - enum_smaller - - - - - f f 3518 3500 0 0 0 _null_ _null_ )); ! DATA(insert ( 3565 n 0 network_smaller 0 - network_smaller - - - - - f f 1203 869 0 0 0 _null_ _null_ )); /* count */ ! DATA(insert ( 2147 n 0 int8inc_any 0 - int8pl - - int8inc_any int8dec_any - f f 0 20 0 20 0 "0" "0" )); ! DATA(insert ( 2803 n 0 int8inc 0 - int8pl - - int8inc int8dec - f f 0 20 0 20 0 "0" "0" )); ! #define COUNTFNOID 2803 /* var_pop */ ! DATA(insert ( 2718 n 0 int8_accum 0 numeric_var_pop numeric_combine numeric_serialize numeric_deserialize int8_accum int8_accum_inv numeric_var_pop f f 0 2281 128 2281 128 _null_ _null_ )); ! DATA(insert ( 2719 n 0 int4_accum 0 numeric_poly_var_pop numeric_poly_combine numeric_poly_serialize numeric_poly_deserialize int4_accum int4_accum_inv numeric_poly_var_pop f f 0 2281 48 2281 48 _null_ _null_ )); ! DATA(insert ( 2720 n 0 int2_accum 0 numeric_poly_var_pop numeric_poly_combine numeric_poly_serialize numeric_poly_deserialize int2_accum int2_accum_inv numeric_poly_var_pop f f 0 2281 48 2281 48 _null_ _null_ )); ! DATA(insert ( 2721 n 0 float4_accum 0 float8_var_pop float8_combine - - - - - f f 0 1022 0 0 0 "{0,0,0}" _null_ )); ! DATA(insert ( 2722 n 0 float8_accum 0 float8_var_pop float8_combine - - - - - f f 0 1022 0 0 0 "{0,0,0}" _null_ )); ! DATA(insert ( 2723 n 0 numeric_accum 0 numeric_var_pop numeric_combine numeric_serialize numeric_deserialize numeric_accum numeric_accum_inv numeric_var_pop f f 0 2281 128 2281 128 _null_ _null_ )); /* var_samp */ ! DATA(insert ( 2641 n 0 int8_accum 0 numeric_var_samp numeric_combine numeric_serialize numeric_deserialize int8_accum int8_accum_inv numeric_var_samp f f 0 2281 128 2281 128 _null_ _null_ )); ! DATA(insert ( 2642 n 0 int4_accum 0 numeric_poly_var_samp numeric_poly_combine numeric_poly_serialize numeric_poly_deserialize int4_accum int4_accum_inv numeric_poly_var_samp f f 0 2281 48 2281 48 _null_ _null_ )); ! DATA(insert ( 2643 n 0 int2_accum 0 numeric_poly_var_samp numeric_poly_combine numeric_poly_serialize numeric_poly_deserialize int2_accum int2_accum_inv numeric_poly_var_samp f f 0 2281 48 2281 48 _null_ _null_ )); ! DATA(insert ( 2644 n 0 float4_accum 0 float8_var_samp float8_combine - - - - - f f 0 1022 0 0 0 "{0,0,0}" _null_ )); ! DATA(insert ( 2645 n 0 float8_accum 0 float8_var_samp float8_combine - - - - - f f 0 1022 0 0 0 "{0,0,0}" _null_ )); ! DATA(insert ( 2646 n 0 numeric_accum 0 numeric_var_samp numeric_combine numeric_serialize numeric_deserialize numeric_accum numeric_accum_inv numeric_var_samp f f 0 2281 128 2281 128 _null_ _null_ )); /* variance: historical Postgres syntax for var_samp */ ! DATA(insert ( 2148 n 0 int8_accum 0 numeric_var_samp numeric_combine numeric_serialize numeric_deserialize int8_accum int8_accum_inv numeric_var_samp f f 0 2281 128 2281 128 _null_ _null_ )); ! DATA(insert ( 2149 n 0 int4_accum 0 numeric_poly_var_samp numeric_poly_combine numeric_poly_serialize numeric_poly_deserialize int4_accum int4_accum_inv numeric_poly_var_samp f f 0 2281 48 2281 48 _null_ _null_ )); ! DATA(insert ( 2150 n 0 int2_accum 0 numeric_poly_var_samp numeric_poly_combine numeric_poly_serialize numeric_poly_deserialize int2_accum int2_accum_inv numeric_poly_var_samp f f 0 2281 48 2281 48 _null_ _null_ )); ! DATA(insert ( 2151 n 0 float4_accum 0 float8_var_samp float8_combine - - - - - f f 0 1022 0 0 0 "{0,0,0}" _null_ )); ! DATA(insert ( 2152 n 0 float8_accum 0 float8_var_samp float8_combine - - - - - f f 0 1022 0 0 0 "{0,0,0}" _null_ )); ! DATA(insert ( 2153 n 0 numeric_accum 0 numeric_var_samp numeric_combine numeric_serialize numeric_deserialize numeric_accum numeric_accum_inv numeric_var_samp f f 0 2281 128 2281 128 _null_ _null_ )); /* stddev_pop */ ! DATA(insert ( 2724 n 0 int8_accum 0 numeric_stddev_pop numeric_combine numeric_serialize numeric_deserialize int8_accum int8_accum_inv numeric_stddev_pop f f 0 2281 128 2281 128 _null_ _null_ )); ! DATA(insert ( 2725 n 0 int4_accum 0 numeric_poly_stddev_pop numeric_poly_combine numeric_poly_serialize numeric_poly_deserialize int4_accum int4_accum_inv numeric_poly_stddev_pop f f 0 2281 48 2281 48 _null_ _null_ )); ! DATA(insert ( 2726 n 0 int2_accum 0 numeric_poly_stddev_pop numeric_poly_combine numeric_poly_serialize numeric_poly_deserialize int2_accum int2_accum_inv numeric_poly_stddev_pop f f 0 2281 48 2281 48 _null_ _null_ )); ! DATA(insert ( 2727 n 0 float4_accum 0 float8_stddev_pop float8_combine - - - - - f f 0 1022 0 0 0 "{0,0,0}" _null_ )); ! DATA(insert ( 2728 n 0 float8_accum 0 float8_stddev_pop float8_combine - - - - - f f 0 1022 0 0 0 "{0,0,0}" _null_ )); ! DATA(insert ( 2729 n 0 numeric_accum 0 numeric_stddev_pop numeric_combine numeric_serialize numeric_deserialize numeric_accum numeric_accum_inv numeric_stddev_pop f f 0 2281 128 2281 128 _null_ _null_ )); /* stddev_samp */ ! DATA(insert ( 2712 n 0 int8_accum 0 numeric_stddev_samp numeric_combine numeric_serialize numeric_deserialize int8_accum int8_accum_inv numeric_stddev_samp f f 0 2281 128 2281 128 _null_ _null_ )); ! DATA(insert ( 2713 n 0 int4_accum 0 numeric_poly_stddev_samp numeric_poly_combine numeric_poly_serialize numeric_poly_deserialize int4_accum int4_accum_inv numeric_poly_stddev_samp f f 0 2281 48 2281 48 _null_ _null_ )); ! DATA(insert ( 2714 n 0 int2_accum 0 numeric_poly_stddev_samp numeric_poly_combine numeric_poly_serialize numeric_poly_deserialize int2_accum int2_accum_inv numeric_poly_stddev_samp f f 0 2281 48 2281 48 _null_ _null_ )); ! DATA(insert ( 2715 n 0 float4_accum 0 float8_stddev_samp float8_combine - - - - - f f 0 1022 0 0 0 "{0,0,0}" _null_ )); ! DATA(insert ( 2716 n 0 float8_accum 0 float8_stddev_samp float8_combine - - - - - f f 0 1022 0 0 0 "{0,0,0}" _null_ )); ! DATA(insert ( 2717 n 0 numeric_accum 0 numeric_stddev_samp numeric_combine numeric_serialize numeric_deserialize numeric_accum numeric_accum_inv numeric_stddev_samp f f 0 2281 128 2281 128 _null_ _null_ )); /* stddev: historical Postgres syntax for stddev_samp */ ! DATA(insert ( 2154 n 0 int8_accum 0 numeric_stddev_samp numeric_combine numeric_serialize numeric_deserialize int8_accum int8_accum_inv numeric_stddev_samp f f 0 2281 128 2281 128 _null_ _null_ )); ! DATA(insert ( 2155 n 0 int4_accum 0 numeric_poly_stddev_samp numeric_poly_combine numeric_poly_serialize numeric_poly_deserialize int4_accum int4_accum_inv numeric_poly_stddev_samp f f 0 2281 48 2281 48 _null_ _null_ )); ! DATA(insert ( 2156 n 0 int2_accum 0 numeric_poly_stddev_samp numeric_poly_combine numeric_poly_serialize numeric_poly_deserialize int2_accum int2_accum_inv numeric_poly_stddev_samp f f 0 2281 48 2281 48 _null_ _null_ )); ! DATA(insert ( 2157 n 0 float4_accum 0 float8_stddev_samp float8_combine - - - - - f f 0 1022 0 0 0 "{0,0,0}" _null_ )); ! DATA(insert ( 2158 n 0 float8_accum 0 float8_stddev_samp float8_combine - - - - - f f 0 1022 0 0 0 "{0,0,0}" _null_ )); ! DATA(insert ( 2159 n 0 numeric_accum 0 numeric_stddev_samp numeric_combine numeric_serialize numeric_deserialize numeric_accum numeric_accum_inv numeric_stddev_samp f f 0 2281 128 2281 128 _null_ _null_ )); /* SQL2003 binary regression aggregates */ ! DATA(insert ( 2818 n 0 int8inc_float8_float8 0 - int8pl - - - - - f f 0 20 0 0 0 "0" _null_ )); ! DATA(insert ( 2819 n 0 float8_regr_accum 0 float8_regr_sxx float8_regr_combine - - - - - f f 0 1022 0 0 0 "{0,0,0,0,0,0}" _null_ )); ! DATA(insert ( 2820 n 0 float8_regr_accum 0 float8_regr_syy float8_regr_combine - - - - - f f 0 1022 0 0 0 "{0,0,0,0,0,0}" _null_ )); ! DATA(insert ( 2821 n 0 float8_regr_accum 0 float8_regr_sxy float8_regr_combine - - - - - f f 0 1022 0 0 0 "{0,0,0,0,0,0}" _null_ )); ! DATA(insert ( 2822 n 0 float8_regr_accum 0 float8_regr_avgx float8_regr_combine - - - - - f f 0 1022 0 0 0 "{0,0,0,0,0,0}" _null_ )); ! DATA(insert ( 2823 n 0 float8_regr_accum 0 float8_regr_avgy float8_regr_combine - - - - - f f 0 1022 0 0 0 "{0,0,0,0,0,0}" _null_ )); ! DATA(insert ( 2824 n 0 float8_regr_accum 0 float8_regr_r2 float8_regr_combine - - - - - f f 0 1022 0 0 0 "{0,0,0,0,0,0}" _null_ )); ! DATA(insert ( 2825 n 0 float8_regr_accum 0 float8_regr_slope float8_regr_combine - - - - - f f 0 1022 0 0 0 "{0,0,0,0,0,0}" _null_ )); ! DATA(insert ( 2826 n 0 float8_regr_accum 0 float8_regr_intercept float8_regr_combine - - - - - f f 0 1022 0 0 0 "{0,0,0,0,0,0}" _null_ )); ! DATA(insert ( 2827 n 0 float8_regr_accum 0 float8_covar_pop float8_regr_combine - - - - - f f 0 1022 0 0 0 "{0,0,0,0,0,0}" _null_ )); ! DATA(insert ( 2828 n 0 float8_regr_accum 0 float8_covar_samp float8_regr_combine - - - - - f f 0 1022 0 0 0 "{0,0,0,0,0,0}" _null_ )); ! DATA(insert ( 2829 n 0 float8_regr_accum 0 float8_corr float8_regr_combine - - - - - f f 0 1022 0 0 0 "{0,0,0,0,0,0}" _null_ )); /* boolean-and and boolean-or */ ! DATA(insert ( 2517 n 0 booland_statefunc 0 - booland_statefunc - - bool_accum bool_accum_inv bool_alltrue f f 58 16 0 2281 16 _null_ _null_ )); ! DATA(insert ( 2518 n 0 boolor_statefunc 0 - boolor_statefunc - - bool_accum bool_accum_inv bool_anytrue f f 59 16 0 2281 16 _null_ _null_ )); ! DATA(insert ( 2519 n 0 booland_statefunc 0 - booland_statefunc - - bool_accum bool_accum_inv bool_alltrue f f 58 16 0 2281 16 _null_ _null_ )); /* bitwise integer */ ! DATA(insert ( 2236 n 0 int2and 0 - int2and - - - - - f f 0 21 0 0 0 _null_ _null_ )); ! DATA(insert ( 2237 n 0 int2or 0 - int2or - - - - - f f 0 21 0 0 0 _null_ _null_ )); ! DATA(insert ( 2238 n 0 int4and 0 - int4and - - - - - f f 0 23 0 0 0 _null_ _null_ )); ! DATA(insert ( 2239 n 0 int4or 0 - int4or - - - - - f f 0 23 0 0 0 _null_ _null_ )); ! DATA(insert ( 2240 n 0 int8and 0 - int8and - - - - - f f 0 20 0 0 0 _null_ _null_ )); ! DATA(insert ( 2241 n 0 int8or 0 - int8or - - - - - f f 0 20 0 0 0 _null_ _null_ )); ! DATA(insert ( 2242 n 0 bitand 0 - bitand - - - - - f f 0 1560 0 0 0 _null_ _null_ )); ! DATA(insert ( 2243 n 0 bitor 0 - bitor - - - - - f f 0 1560 0 0 0 _null_ _null_ )); /* xml */ ! DATA(insert ( 2901 n 0 xmlconcat2 0 - - - - - - - f f 0 142 0 0 0 _null_ _null_ )); /* array */ ! DATA(insert ( 2335 n 0 array_agg_transfn 0 array_agg_finalfn - - - - - - t f 0 2281 0 0 0 _null_ _null_ )); ! DATA(insert ( 4053 n 0 array_agg_array_transfn 0 array_agg_array_finalfn - - - - - - t f 0 2281 0 0 0 _null_ _null_ )); /* text */ ! DATA(insert ( 3538 n 0 string_agg_transfn 0 string_agg_finalfn - - - - - - f f 0 2281 0 0 0 _null_ _null_ )); /* bytea */ ! DATA(insert ( 3545 n 0 bytea_string_agg_transfn 0 bytea_string_agg_finalfn - - - - - - f f 0 2281 0 0 0 _null_ _null_ )); /* json */ ! DATA(insert ( 3175 n 0 json_agg_transfn 0 json_agg_finalfn - - - - - - f f 0 2281 0 0 0 _null_ _null_ )); ! DATA(insert ( 3197 n 0 json_object_agg_transfn 0 json_object_agg_finalfn - - - - - - f f 0 2281 0 0 0 _null_ _null_ )); /* jsonb */ ! DATA(insert ( 3267 n 0 jsonb_agg_transfn 0 jsonb_agg_finalfn - - - - - - f f 0 2281 0 0 0 _null_ _null_ )); ! DATA(insert ( 3270 n 0 jsonb_object_agg_transfn 0 jsonb_object_agg_finalfn - - - - - - f f 0 2281 0 0 0 _null_ _null_ )); /* ordered-set and hypothetical-set aggregates */ ! DATA(insert ( 3972 o 1 ordered_set_transition 0 percentile_disc_final - - - - - - t f 0 2281 0 0 0 _null_ _null_ )); ! DATA(insert ( 3974 o 1 ordered_set_transition 0 percentile_cont_float8_final - - - - - - f f 0 2281 0 0 0 _null_ _null_ )); ! DATA(insert ( 3976 o 1 ordered_set_transition 0 percentile_cont_interval_final - - - - - - f f 0 2281 0 0 0 _null_ _null_ )); ! DATA(insert ( 3978 o 1 ordered_set_transition 0 percentile_disc_multi_final - - - - - - t f 0 2281 0 0 0 _null_ _null_ )); ! DATA(insert ( 3980 o 1 ordered_set_transition 0 percentile_cont_float8_multi_final - - - - - - f f 0 2281 0 0 0 _null_ _null_ )); ! DATA(insert ( 3982 o 1 ordered_set_transition 0 percentile_cont_interval_multi_final - - - - - - f f 0 2281 0 0 0 _null_ _null_ )); ! DATA(insert ( 3984 o 0 ordered_set_transition 0 mode_final - - - - - - t f 0 2281 0 0 0 _null_ _null_ )); ! DATA(insert ( 3986 h 1 ordered_set_transition_multi 0 rank_final - - - - - - t f 0 2281 0 0 0 _null_ _null_ )); ! DATA(insert ( 3988 h 1 ordered_set_transition_multi 0 percent_rank_final - - - - - - t f 0 2281 0 0 0 _null_ _null_ )); ! DATA(insert ( 3990 h 1 ordered_set_transition_multi 0 cume_dist_final - - - - - - t f 0 2281 0 0 0 _null_ _null_ )); ! DATA(insert ( 3992 h 1 ordered_set_transition_multi 0 dense_rank_final - - - - - - t f 0 2281 0 0 0 _null_ _null_ )); /* diff --git a/src/include/catalog/pg_operator.h b/src/include/catalog/pg_operator.h new file mode 100644 index aeb7927..3095380 *** a/src/include/catalog/pg_operator.h --- b/src/include/catalog/pg_operator.h *************** DATA(insert OID = 685 ( "-" PGNSP PG *** 547,552 **** --- 547,553 ---- DESCR("subtract"); DATA(insert OID = 686 ( "*" PGNSP PGUID b f f 20 20 20 686 0 int8mul - - )); DESCR("multiply"); + #define OPERATOR_INT8MUL 686 DATA(insert OID = 687 ( "/" PGNSP PGUID b f f 20 20 20 0 0 int8div - - )); DESCR("divide"); diff --git a/src/include/catalog/pg_proc.h b/src/include/catalog/pg_proc.h new file mode 100644 index 37e022d..51d1b74 *** a/src/include/catalog/pg_proc.h --- b/src/include/catalog/pg_proc.h *************** DESCR("pg_controldata recovery state inf *** 5345,5350 **** --- 5345,5353 ---- DATA(insert OID = 3444 ( pg_control_init PGNSP PGUID 12 1 0 0 0 f f f f t f v s 0 0 2249 "" "{23,23,23,23,23,23,23,23,23,16,16,16,23}" "{o,o,o,o,o,o,o,o,o,o,o,o,o}" "{max_data_alignment,database_block_size,blocks_per_segment,wal_block_size,bytes_per_wal_segment,max_identifier_length,max_index_columns,max_toast_chunk_size,large_object_chunk_size,bigint_timestamps,float4_pass_by_value,float8_pass_by_value,data_page_checksum_version}" _null_ _null_ pg_control_init _null_ _null_ _null_ )); DESCR("pg_controldata init state information as a function"); + DATA(insert OID = 4002 ( float4_sum_mul PGNSP PGUID 12 1 0 0 0 f f f f t f i s 2 0 1022 "1022 20" _null_ _null_ _null_ _null_ _null_ float4_sum_mul _null_ _null_ _null_ )); + DESCR("aggregate state multiplication function"); + /* * Symbolic values for provolatile column: these indicate whether the result * of a function is dependent *only* on the values of its explicit arguments, diff --git a/src/include/nodes/primnodes.h b/src/include/nodes/primnodes.h new file mode 100644 index f72ec24..dd76d9b *** a/src/include/nodes/primnodes.h --- b/src/include/nodes/primnodes.h *************** typedef struct Aggref *** 284,289 **** --- 284,290 ---- bool aggvariadic; /* true if variadic arguments have been * combined into an array last argument */ char aggkind; /* aggregate kind (see pg_aggregate.h) */ + Oid aggtransmultifn;/* pg_aggregate(aggtransmultifn) */ Index agglevelsup; /* > 0 if agg belongs to outer query */ AggSplit aggsplit; /* expected agg-splitting mode of parent Agg */ int location; /* token location, or -1 if unknown */ diff --git a/src/include/nodes/relation.h b/src/include/nodes/relation.h new file mode 100644 index e1d31c7..1e8ef3b *** a/src/include/nodes/relation.h --- b/src/include/nodes/relation.h *************** typedef struct PlannerInfo *** 252,257 **** --- 252,262 ---- List *placeholder_list; /* list of PlaceHolderInfos */ + /* TODO Consider hashing. */ + List *grouped_var_list; /* List of GroupedVarInfos. */ + + bool all_baserels_grouped; /* Should grouped rels be joined? */ + List *fkey_list; /* list of ForeignKeyOptInfos */ List *query_pathkeys; /* desired pathkeys for query_planner() */ *************** typedef struct RelOptInfo *** 495,504 **** --- 500,516 ---- /* default result targetlist for Paths scanning this relation */ struct PathTarget *reltarget; /* list of Vars/Exprs, cost, width */ + /* result targetlist if the base relation is grouped */ + struct PathTarget *reltarget_grouped; + /* materialization information */ List *pathlist; /* Path structures */ + List *grouped_pathlist; /* paths with partial aggregation already + * done. */ List *ppilist; /* ParamPathInfos used in pathlist */ List *partial_pathlist; /* partial Paths */ + List *partial_grouped_pathlist; /* partial Paths with partial + * aggregation already done. */ struct Path *cheapest_startup_path; struct Path *cheapest_total_path; struct Path *cheapest_unique_path; *************** typedef struct PlaceHolderInfo *** 1905,1910 **** --- 1917,1951 ---- } PlaceHolderInfo; /* + * Variable of a "grouped relation" represents an aggregate or grouping + * expression that it evaluates. Input values of such expressions are not + * available above this relation, so the values of such expressions are passed + * as variables. Each variable-to-expression association is stored as an item + * of root->grouped_var_list and used by set_upper_references. + */ + typedef struct GroupedVarInfo + { + /* The variable added to base relation instead of aggregate. */ + Var *var; + + /* + * The expression whose value this "grouped var" represents in the + * target list of the (partially) grouped relation. + */ + Expr *expr; + + /* + * If aggtransmultifn function (see Aggref) must be applied before the + * final aggregation, expr_intermediate contains the function call. It'll + * replace the variable in targetlist of the Result node that prepares + * input for the final aggregation. + */ + Expr *expr_intermediate; + + Index sortgroupref; + } GroupedVarInfo; + + /* * This struct describes one potentially index-optimizable MIN/MAX aggregate * function. MinMaxAggPath contains a list of these, and if we accept that * path, the list is stored into root->minmax_aggs for use during setrefs.c. diff --git a/src/include/optimizer/pathnode.h b/src/include/optimizer/pathnode.h new file mode 100644 index d16f879..54b84c7 *** a/src/include/optimizer/pathnode.h --- b/src/include/optimizer/pathnode.h *************** extern int compare_path_costs(Path *path *** 25,37 **** extern int compare_fractional_path_costs(Path *path1, Path *path2, double fraction); extern void set_cheapest(RelOptInfo *parent_rel); ! extern void add_path(RelOptInfo *parent_rel, Path *new_path); extern bool add_path_precheck(RelOptInfo *parent_rel, Cost startup_cost, Cost total_cost, ! List *pathkeys, Relids required_outer); ! extern void add_partial_path(RelOptInfo *parent_rel, Path *new_path); extern bool add_partial_path_precheck(RelOptInfo *parent_rel, ! Cost total_cost, List *pathkeys); extern Path *create_seqscan_path(PlannerInfo *root, RelOptInfo *rel, Relids required_outer, int parallel_workers); --- 25,39 ---- extern int compare_fractional_path_costs(Path *path1, Path *path2, double fraction); extern void set_cheapest(RelOptInfo *parent_rel); ! extern void add_path(RelOptInfo *parent_rel, Path *new_path, bool grouped); extern bool add_path_precheck(RelOptInfo *parent_rel, Cost startup_cost, Cost total_cost, ! List *pathkeys, Relids required_outer, bool grouped); ! extern void add_partial_path(RelOptInfo *parent_rel, Path *new_path, ! bool grouped); extern bool add_partial_path_precheck(RelOptInfo *parent_rel, ! Cost total_cost, List *pathkeys, ! bool grouped); extern Path *create_seqscan_path(PlannerInfo *root, RelOptInfo *rel, Relids required_outer, int parallel_workers); *************** extern HashPath *create_hashjoin_path(Pl *** 134,140 **** Path *inner_path, List *restrict_clauses, Relids required_outer, ! List *hashclauses); extern ProjectionPath *create_projection_path(PlannerInfo *root, RelOptInfo *rel, --- 136,143 ---- Path *inner_path, List *restrict_clauses, Relids required_outer, ! List *hashclauses, ! bool grouped); extern ProjectionPath *create_projection_path(PlannerInfo *root, RelOptInfo *rel, diff --git a/src/include/optimizer/paths.h b/src/include/optimizer/paths.h new file mode 100644 index 480f25f..0d29bec *** a/src/include/optimizer/paths.h --- b/src/include/optimizer/paths.h *************** extern void set_dummy_rel_pathlist(RelOp *** 52,58 **** extern RelOptInfo *standard_join_search(PlannerInfo *root, int levels_needed, List *initial_rels); ! extern void generate_gather_paths(PlannerInfo *root, RelOptInfo *rel); #ifdef OPTIMIZER_DEBUG extern void debug_print_rel(PlannerInfo *root, RelOptInfo *rel); --- 52,59 ---- extern RelOptInfo *standard_join_search(PlannerInfo *root, int levels_needed, List *initial_rels); ! extern void generate_gather_paths(PlannerInfo *root, RelOptInfo *rel, ! bool grouped); #ifdef OPTIMIZER_DEBUG extern void debug_print_rel(PlannerInfo *root, RelOptInfo *rel); diff --git a/src/include/optimizer/planmain.h b/src/include/optimizer/planmain.h new file mode 100644 index 8468b0c..dd2529b *** a/src/include/optimizer/planmain.h --- b/src/include/optimizer/planmain.h *************** extern void add_base_rels_to_query(Plann *** 75,80 **** --- 75,81 ---- extern void build_base_rel_tlists(PlannerInfo *root, List *final_tlist); extern void add_vars_to_targetlist(PlannerInfo *root, List *vars, Relids where_needed, bool create_new_ph); + extern void build_base_rel_tlists_grouped(PlannerInfo *root); extern void find_lateral_references(PlannerInfo *root); extern void create_lateral_join_info(PlannerInfo *root); extern List *deconstruct_jointree(PlannerInfo *root); diff --git a/src/include/optimizer/tlist.h b/src/include/optimizer/tlist.h new file mode 100644 index f80b31a..9d2c097 *** a/src/include/optimizer/tlist.h --- b/src/include/optimizer/tlist.h *************** extern void add_column_to_pathtarget(Pat *** 61,67 **** extern void add_new_column_to_pathtarget(PathTarget *target, Expr *expr); extern void add_new_columns_to_pathtarget(PathTarget *target, List *exprs); extern void apply_pathtarget_labeling_to_tlist(List *tlist, PathTarget *target); ! /* Convenience macro to get a PathTarget with valid cost/width fields */ #define create_pathtarget(root, tlist) \ set_pathtarget_cost_width(root, make_pathtarget_from_tlist(tlist)) --- 61,76 ---- extern void add_new_column_to_pathtarget(PathTarget *target, Expr *expr); extern void add_new_columns_to_pathtarget(PathTarget *target, List *exprs); extern void apply_pathtarget_labeling_to_tlist(List *tlist, PathTarget *target); ! extern PathTarget *create_intermediate_grouping_target(PlannerInfo *root, ! PathTarget *src); ! extern List *restore_grouping_expressions(PlannerInfo *root, List *src); ! extern Expr *find_grouped_var_expr(PlannerInfo *root, Var *var); ! extern void add_aggregates_to_grouped_target(PlannerInfo *root, ! List *aggregates, ! RelOptInfo *rel, ! Aggref *countagg, ! List **countagg_vars, ! bool mark_partial); /* Convenience macro to get a PathTarget with valid cost/width fields */ #define create_pathtarget(root, tlist) \ set_pathtarget_cost_width(root, make_pathtarget_from_tlist(tlist)) diff --git a/src/include/utils/builtins.h b/src/include/utils/builtins.h new file mode 100644 index e1bb344..628b142 *** a/src/include/utils/builtins.h --- b/src/include/utils/builtins.h *************** extern Datum float84le(PG_FUNCTION_ARGS) *** 475,480 **** --- 475,481 ---- extern Datum float84gt(PG_FUNCTION_ARGS); extern Datum float84ge(PG_FUNCTION_ARGS); extern Datum width_bucket_float8(PG_FUNCTION_ARGS); + extern Datum float4_sum_mul(PG_FUNCTION_ARGS); /* dbsize.c */ extern Datum pg_tablespace_size_oid(PG_FUNCTION_ARGS); diff --git a/src/include/utils/selfuncs.h b/src/include/utils/selfuncs.h new file mode 100644 index b43dae7..39f5dee *** a/src/include/utils/selfuncs.h --- b/src/include/utils/selfuncs.h *************** extern double estimate_num_groups(Planne *** 232,237 **** --- 232,240 ---- extern Selectivity estimate_hash_bucketsize(PlannerInfo *root, Node *hashkey, double nbuckets); + extern Size estimate_hashagg_tablesize(Path *path, + const AggClauseCosts *agg_costs, + double dNumGroups); extern List *deconstruct_indexquals(IndexPath *path); extern void genericcostestimate(PlannerInfo *root, IndexPath *path,