Skip to content

Navigation Menu

Sign in
Appearance settings

Search code, repositories, users, issues, pull requests...

Provide feedback

We read every piece of feedback, and take your input very seriously.

Saved searches

Use saved searches to filter your results more quickly
Appearance settings

Commit f199303

Browse filesBrowse files
tglsfdctglsfdc
committed
Avoid making a separate pass over the query to check for partializability.
It's rather silly to make a separate pass over the tlist + HAVING qual, and a separate set of visits to the syscache, when get_agg_clause_costs already has all the required information in hand. This nets out as less code as well as fewer cycles.
1 parent 19e972d commit f199303
Copy full SHA for f199303

File tree

Expand file treeCollapse file tree

4 files changed

+54
-118
lines changed
Filter options
Expand file treeCollapse file tree

4 files changed

+54
-118
lines changed

‎src/backend/optimizer/plan/planner.c

Copy file name to clipboardExpand all lines: src/backend/optimizer/plan/planner.c
+16-13Lines changed: 16 additions & 13 deletions
Original file line numberDiff line numberDiff line change
@@ -110,8 +110,10 @@ static double get_number_of_groups(PlannerInfo *root,
110110
List *rollup_groupclauses);
111111
static void set_grouped_rel_consider_parallel(PlannerInfo *root,
112112
RelOptInfo *grouped_rel,
113-
PathTarget *target);
114-
static Size estimate_hashagg_tablesize(Path *path, AggClauseCosts *agg_costs,
113+
PathTarget *target,
114+
const AggClauseCosts *agg_costs);
115+
static Size estimate_hashagg_tablesize(Path *path,
116+
const AggClauseCosts *agg_costs,
115117
double dNumGroups);
116118
static RelOptInfo *create_grouping_paths(PlannerInfo *root,
117119
RelOptInfo *input_rel,
@@ -3207,7 +3209,8 @@ get_number_of_groups(PlannerInfo *root,
32073209
*/
32083210
static void
32093211
set_grouped_rel_consider_parallel(PlannerInfo *root, RelOptInfo *grouped_rel,
3210-
PathTarget *target)
3212+
PathTarget *target,
3213+
const AggClauseCosts *agg_costs)
32113214
{
32123215
Query *parse = root->parse;
32133216

@@ -3240,15 +3243,14 @@ set_grouped_rel_consider_parallel(PlannerInfo *root, RelOptInfo *grouped_rel,
32403243
return;
32413244

32423245
/*
3243-
* All that's left to check now is to make sure all aggregate functions
3244-
* support partial mode. If there's no aggregates then we can skip
3245-
* checking that.
3246+
* If we have any non-partial-capable aggregates, or if any of them can't
3247+
* be serialized, we can't go parallel.
32463248
*/
3247-
if (!parse->hasAggs)
3248-
grouped_rel->consider_parallel = true;
3249-
else if (aggregates_allow_partial((Node *) target->exprs) == PAT_ANY &&
3250-
aggregates_allow_partial(root->parse->havingQual) == PAT_ANY)
3251-
grouped_rel->consider_parallel = true;
3249+
if (agg_costs->hasNonPartial || agg_costs->hasNonSerial)
3250+
return;
3251+
3252+
/* OK, consider parallelization */
3253+
grouped_rel->consider_parallel = true;
32523254
}
32533255

32543256
/*
@@ -3257,7 +3259,7 @@ set_grouped_rel_consider_parallel(PlannerInfo *root, RelOptInfo *grouped_rel,
32573259
* require based on the agg_costs, path width and dNumGroups.
32583260
*/
32593261
static Size
3260-
estimate_hashagg_tablesize(Path *path, AggClauseCosts *agg_costs,
3262+
estimate_hashagg_tablesize(Path *path, const AggClauseCosts *agg_costs,
32613263
double dNumGroups)
32623264
{
32633265
Size hashentrysize;
@@ -3411,7 +3413,8 @@ create_grouping_paths(PlannerInfo *root,
34113413
* going to be safe to do so.
34123414
*/
34133415
if (input_rel->partial_pathlist != NIL)
3414-
set_grouped_rel_consider_parallel(root, grouped_rel, target);
3416+
set_grouped_rel_consider_parallel(root, grouped_rel,
3417+
target, &agg_costs);
34153418

34163419
/*
34173420
* Determine whether it's possible to perform sort-based implementations

‎src/backend/optimizer/util/clauses.c

Copy file name to clipboardExpand all lines: src/backend/optimizer/util/clauses.c
+34-84Lines changed: 34 additions & 84 deletions
Original file line numberDiff line numberDiff line change
@@ -52,10 +52,6 @@
5252
#include "utils/syscache.h"
5353
#include "utils/typcache.h"
5454

55-
typedef struct
56-
{
57-
PartialAggType allowedtype;
58-
} partial_agg_context;
5955

6056
typedef struct
6157
{
@@ -98,8 +94,6 @@ typedef struct
9894
bool allow_restricted;
9995
} has_parallel_hazard_arg;
10096

101-
static bool aggregates_allow_partial_walker(Node *node,
102-
partial_agg_context *context);
10397
static bool contain_agg_clause_walker(Node *node, void *context);
10498
static bool get_agg_clause_costs_walker(Node *node,
10599
get_agg_clause_costs_context *context);
@@ -403,81 +397,6 @@ make_ands_implicit(Expr *clause)
403397
* Aggregate-function clause manipulation
404398
*****************************************************************************/
405399

406-
/*
407-
* aggregates_allow_partial
408-
* Recursively search for Aggref clauses and determine the maximum
409-
* level of partial aggregation which can be supported.
410-
*/
411-
PartialAggType
412-
aggregates_allow_partial(Node *clause)
413-
{
414-
partial_agg_context context;
415-
416-
/* initially any type is okay, until we find Aggrefs which say otherwise */
417-
context.allowedtype = PAT_ANY;
418-
419-
if (!aggregates_allow_partial_walker(clause, &context))
420-
return context.allowedtype;
421-
return context.allowedtype;
422-
}
423-
424-
static bool
425-
aggregates_allow_partial_walker(Node *node, partial_agg_context *context)
426-
{
427-
if (node == NULL)
428-
return false;
429-
if (IsA(node, Aggref))
430-
{
431-
Aggref *aggref = (Aggref *) node;
432-
HeapTuple aggTuple;
433-
Form_pg_aggregate aggform;
434-
435-
Assert(aggref->agglevelsup == 0);
436-
437-
/*
438-
* We can't perform partial aggregation with Aggrefs containing a
439-
* DISTINCT or ORDER BY clause.
440-
*/
441-
if (aggref->aggdistinct || aggref->aggorder)
442-
{
443-
context->allowedtype = PAT_DISABLED;
444-
return true; /* abort search */
445-
}
446-
aggTuple = SearchSysCache1(AGGFNOID,
447-
ObjectIdGetDatum(aggref->aggfnoid));
448-
if (!HeapTupleIsValid(aggTuple))
449-
elog(ERROR, "cache lookup failed for aggregate %u",
450-
aggref->aggfnoid);
451-
aggform = (Form_pg_aggregate) GETSTRUCT(aggTuple);
452-
453-
/*
454-
* If there is no combine function, then partial aggregation is not
455-
* possible.
456-
*/
457-
if (!OidIsValid(aggform->aggcombinefn))
458-
{
459-
ReleaseSysCache(aggTuple);
460-
context->allowedtype = PAT_DISABLED;
461-
return true; /* abort search */
462-
}
463-
464-
/*
465-
* If we find any aggs with an internal transtype then we must check
466-
* whether these have serialization/deserialization functions;
467-
* otherwise, we set the maximum allowed type to PAT_INTERNAL_ONLY.
468-
*/
469-
if (aggform->aggtranstype == INTERNALOID &&
470-
(!OidIsValid(aggform->aggserialfn) ||
471-
!OidIsValid(aggform->aggdeserialfn)))
472-
context->allowedtype = PAT_INTERNAL_ONLY;
473-
474-
ReleaseSysCache(aggTuple);
475-
return false; /* continue searching */
476-
}
477-
return expression_tree_walker(node, aggregates_allow_partial_walker,
478-
(void *) context);
479-
}
480-
481400
/*
482401
* contain_agg_clause
483402
* Recursively search for Aggref/GroupingFunc nodes within a clause.
@@ -529,8 +448,9 @@ contain_agg_clause_walker(Node *node, void *context)
529448
*
530449
* We count the nodes, estimate their execution costs, and estimate the total
531450
* space needed for their transition state values if all are evaluated in
532-
* parallel (as would be done in a HashAgg plan). See AggClauseCosts for
533-
* the exact set of statistics collected.
451+
* parallel (as would be done in a HashAgg plan). Also, we check whether
452+
* partial aggregation is feasible. See AggClauseCosts for the exact set
453+
* of statistics collected.
534454
*
535455
* In addition, we mark Aggref nodes with the correct aggtranstype, so
536456
* that that doesn't need to be done repeatedly. (That makes this function's
@@ -616,10 +536,40 @@ get_agg_clause_costs_walker(Node *node, get_agg_clause_costs_context *context)
616536
aggref->aggtranstype = aggtranstype;
617537
}
618538

619-
/* count it; note ordered-set aggs always have nonempty aggorder */
539+
/*
540+
* Count it, and check for cases requiring ordered input. Note that
541+
* ordered-set aggs always have nonempty aggorder. Any ordered-input
542+
* case also defeats partial aggregation.
543+
*/
620544
costs->numAggs++;
621545
if (aggref->aggorder != NIL || aggref->aggdistinct != NIL)
546+
{
622547
costs->numOrderedAggs++;
548+
costs->hasNonPartial = true;
549+
}
550+
551+
/*
552+
* Check whether partial aggregation is feasible, unless we already
553+
* found out that we can't do it.
554+
*/
555+
if (!costs->hasNonPartial)
556+
{
557+
/*
558+
* If there is no combine function, then partial aggregation is
559+
* not possible.
560+
*/
561+
if (!OidIsValid(aggcombinefn))
562+
costs->hasNonPartial = true;
563+
564+
/*
565+
* If we have any aggs with transtype INTERNAL then we must check
566+
* whether they have serialization/deserialization functions; if
567+
* not, we can't serialize partial-aggregation results.
568+
*/
569+
else if (aggtranstype == INTERNALOID &&
570+
(!OidIsValid(aggserialfn) || !OidIsValid(aggdeserialfn)))
571+
costs->hasNonSerial = true;
572+
}
623573

624574
/*
625575
* Add the appropriate component function execution costs to

‎src/include/nodes/relation.h

Copy file name to clipboardExpand all lines: src/include/nodes/relation.h
+4-1Lines changed: 4 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -50,12 +50,15 @@ typedef struct QualCost
5050
* Costing aggregate function execution requires these statistics about
5151
* the aggregates to be executed by a given Agg node. Note that the costs
5252
* include the execution costs of the aggregates' argument expressions as
53-
* well as the aggregate functions themselves.
53+
* well as the aggregate functions themselves. Also, the fields must be
54+
* defined so that initializing the struct to zeroes with memset is correct.
5455
*/
5556
typedef struct AggClauseCosts
5657
{
5758
int numAggs; /* total number of aggregate functions */
5859
int numOrderedAggs; /* number w/ DISTINCT/ORDER BY/WITHIN GROUP */
60+
bool hasNonPartial; /* does any agg not support partial mode? */
61+
bool hasNonSerial; /* is any partial agg non-serializable? */
5962
QualCost transCost; /* total per-input-row execution costs */
6063
Cost finalCost; /* total per-aggregated-row costs */
6164
Size transitionSpace; /* space for pass-by-ref transition data */

‎src/include/optimizer/clauses.h

Copy file name to clipboardExpand all lines: src/include/optimizer/clauses.h
-20Lines changed: 0 additions & 20 deletions
Original file line numberDiff line numberDiff line change
@@ -27,25 +27,6 @@ typedef struct
2727
List **windowFuncs; /* lists of WindowFuncs for each winref */
2828
} WindowFuncLists;
2929

30-
/*
31-
* PartialAggType
32-
* PartialAggType stores whether partial aggregation is allowed and
33-
* which context it is allowed in. We require three states here as there are
34-
* two different contexts in which partial aggregation is safe. For aggregates
35-
* which have an 'stype' of INTERNAL, it is okay to pass a pointer to the
36-
* aggregate state within a single process, since the datum is just a
37-
* pointer. In cases where the aggregate state must be passed between
38-
* different processes, for example during parallel aggregation, passing
39-
* pointers directly is not going to work.
40-
*/
41-
typedef enum
42-
{
43-
PAT_ANY = 0, /* Any type of partial aggregation is okay. */
44-
PAT_INTERNAL_ONLY, /* Some aggregates support only internal mode. */
45-
PAT_DISABLED /* Some aggregates don't support partial mode
46-
* at all */
47-
} PartialAggType;
48-
4930
extern Expr *make_opclause(Oid opno, Oid opresulttype, bool opretset,
5031
Expr *leftop, Expr *rightop,
5132
Oid opcollid, Oid inputcollid);
@@ -65,7 +46,6 @@ extern Node *make_and_qual(Node *qual1, Node *qual2);
6546
extern Expr *make_ands_explicit(List *andclauses);
6647
extern List *make_ands_implicit(Expr *clause);
6748

68-
extern PartialAggType aggregates_allow_partial(Node *clause);
6949
extern bool contain_agg_clause(Node *clause);
7050
extern void get_agg_clause_costs(PlannerInfo *root, Node *clause,
7151
AggSplit aggsplit, AggClauseCosts *costs);

0 commit comments

Comments
0 (0)
Morty Proxy This is a proxified and sanitized view of the page, visit original site.