nodeAgg.h File Reference

#include "access/parallel.h"
#include "nodes/execnodes.h"

Include dependency graph for nodeAgg.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Data Structures
struct	AggStatePerTransData
struct	AggStatePerAggData
struct	AggStatePerGroupData
struct	AggStatePerPhaseData
struct	AggStatePerHashData

Macros
#define	FIELDNO_AGGSTATEPERGROUPDATA_TRANSVALUE   0
#define	FIELDNO_AGGSTATEPERGROUPDATA_TRANSVALUEISNULL   1
#define	FIELDNO_AGGSTATEPERGROUPDATA_NOTRANSVALUE   2

Typedefs
typedef struct AggStatePerTransData	AggStatePerTransData
typedef struct AggStatePerAggData	AggStatePerAggData
typedef struct AggStatePerGroupData	AggStatePerGroupData
typedef struct AggStatePerPhaseData	AggStatePerPhaseData
typedef struct AggStatePerHashData	AggStatePerHashData

Functions
AggState *	ExecInitAgg (Agg *node, EState *estate, int eflags)
void	ExecEndAgg (AggState *node)
void	ExecReScanAgg (AggState *node)
Size	hash_agg_entry_size (int numTrans, Size tupleWidth, Size transitionSpace)
void	hash_agg_set_limits (double hashentrysize, double input_groups, int used_bits, Size *mem_limit, uint64 *ngroups_limit, int *num_partitions)
void	ExecAggEstimate (AggState *node, ParallelContext *pcxt)
void	ExecAggInitializeDSM (AggState *node, ParallelContext *pcxt)
void	ExecAggInitializeWorker (AggState *node, ParallelWorkerContext *pwcxt)
void	ExecAggRetrieveInstrumentation (AggState *node)

Macro Definition Documentation

FIELDNO_AGGSTATEPERGROUPDATA_NOTRANSVALUE

#define FIELDNO_AGGSTATEPERGROUPDATA_NOTRANSVALUE   2

Definition at line 257 of file nodeAgg.h.

FIELDNO_AGGSTATEPERGROUPDATA_TRANSVALUE

#define FIELDNO_AGGSTATEPERGROUPDATA_TRANSVALUE   0

Definition at line 252 of file nodeAgg.h.

FIELDNO_AGGSTATEPERGROUPDATA_TRANSVALUEISNULL

#define FIELDNO_AGGSTATEPERGROUPDATA_TRANSVALUEISNULL   1

Definition at line 254 of file nodeAgg.h.

Typedef Documentation

AggStatePerAggData

typedef struct AggStatePerAggData AggStatePerAggData

AggStatePerGroupData

typedef struct AggStatePerGroupData AggStatePerGroupData

AggStatePerHashData

typedef struct AggStatePerHashData AggStatePerHashData

AggStatePerPhaseData

typedef struct AggStatePerPhaseData AggStatePerPhaseData

AggStatePerTransData

typedef struct AggStatePerTransData AggStatePerTransData

Function Documentation

ExecAggEstimate()

void ExecAggEstimate ( AggState *  node, ParallelContext *  pcxt  )

extern

Definition at line 4779 of file nodeAgg.c.

{
    Size        size;
 
    /* don't need this if not instrumenting or no workers */
    if (!node->ss.ps.instrument || pcxt->nworkers == 0)
        return;
 
    size = mul_size(pcxt->nworkers, sizeof(AggregateInstrumentation));
    size = add_size(size, offsetof(SharedAggInfo, sinstrument));
    shm_toc_estimate_chunk(&pcxt->estimator, size);
    shm_toc_estimate_keys(&pcxt->estimator, 1);
}

References add_size(), ParallelContext::estimator, fb(), PlanState::instrument, mul_size(), ParallelContext::nworkers, ScanState::ps, shm_toc_estimate_chunk, shm_toc_estimate_keys, and AggState::ss.

Referenced by ExecParallelEstimate().

ExecAggInitializeDSM()

void ExecAggInitializeDSM ( AggState *  node, ParallelContext *  pcxt  )

extern

Definition at line 4800 of file nodeAgg.c.

{
    Size        size;
 
    /* don't need this if not instrumenting or no workers */
    if (!node->ss.ps.instrument || pcxt->nworkers == 0)
        return;
 
    size = offsetof(SharedAggInfo, sinstrument)
        + pcxt->nworkers * sizeof(AggregateInstrumentation);
    node->shared_info = shm_toc_allocate(pcxt->toc, size);
    /* ensure any unfilled slots will contain zeroes */
    memset(node->shared_info, 0, size);
    node->shared_info->num_workers = pcxt->nworkers;
    shm_toc_insert(pcxt->toc, node->ss.ps.plan->plan_node_id,
                   node->shared_info);
}

References fb(), PlanState::instrument, SharedAggInfo::num_workers, ParallelContext::nworkers, PlanState::plan, Plan::plan_node_id, ScanState::ps, AggState::shared_info, shm_toc_allocate(), shm_toc_insert(), AggState::ss, and ParallelContext::toc.

Referenced by ExecParallelInitializeDSM().

ExecAggInitializeWorker()

void ExecAggInitializeWorker ( AggState *  node, ParallelWorkerContext *  pwcxt  )

extern

Definition at line 4825 of file nodeAgg.c.

{
    node->shared_info =
        shm_toc_lookup(pwcxt->toc, node->ss.ps.plan->plan_node_id, true);
}

References fb(), PlanState::plan, Plan::plan_node_id, ScanState::ps, AggState::shared_info, shm_toc_lookup(), and AggState::ss.

Referenced by ExecParallelInitializeWorker().

ExecAggRetrieveInstrumentation()

void ExecAggRetrieveInstrumentation ( AggState *  node )

extern

Definition at line 4838 of file nodeAgg.c.

{
    Size        size;
    SharedAggInfo *si;
 
    if (node->shared_info == NULL)
        return;
 
    size = offsetof(SharedAggInfo, sinstrument)
        + node->shared_info->num_workers * sizeof(AggregateInstrumentation);
    si = palloc(size);
    memcpy(si, node->shared_info, size);
    node->shared_info = si;
}

References fb(), SharedAggInfo::num_workers, palloc(), and AggState::shared_info.

Referenced by ExecParallelRetrieveInstrumentation().

ExecEndAgg()

void ExecEndAgg ( AggState *  node )

extern

Definition at line 4394 of file nodeAgg.c.

{
    PlanState  *outerPlan;
    int         transno;
    int         numGroupingSets = Max(node->maxsets, 1);
    int         setno;
 
    /*
     * When ending a parallel worker, copy the statistics gathered by the
     * worker back into shared memory so that it can be picked up by the main
     * process to report in EXPLAIN ANALYZE.
     */
    if (node->shared_info && IsParallelWorker())
    {
        AggregateInstrumentation *si;
 
        Assert(ParallelWorkerNumber <= node->shared_info->num_workers);
        si = &node->shared_info->sinstrument[ParallelWorkerNumber];
        si->hash_batches_used = node->hash_batches_used;
        si->hash_disk_used = node->hash_disk_used;
        si->hash_mem_peak = node->hash_mem_peak;
    }
 
    /* Make sure we have closed any open tuplesorts */
 
    if (node->sort_in)
        tuplesort_end(node->sort_in);
    if (node->sort_out)
        tuplesort_end(node->sort_out);
 
    hashagg_reset_spill_state(node);
 
    /* Release hash tables too */
    if (node->hash_metacxt != NULL)
    {
        MemoryContextDelete(node->hash_metacxt);
        node->hash_metacxt = NULL;
    }
    if (node->hash_tuplescxt != NULL)
    {
        MemoryContextDelete(node->hash_tuplescxt);
        node->hash_tuplescxt = NULL;
    }
 
    for (transno = 0; transno < node->numtrans; transno++)
    {
        AggStatePerTrans pertrans = &node->pertrans[transno];
 
        for (setno = 0; setno < numGroupingSets; setno++)
        {
            if (pertrans->sortstates[setno])
                tuplesort_end(pertrans->sortstates[setno]);
        }
    }
 
    /* And ensure any agg shutdown callbacks have been called */
    for (setno = 0; setno < numGroupingSets; setno++)
        ReScanExprContext(node->aggcontexts[setno]);
    if (node->hashcontext)
        ReScanExprContext(node->hashcontext);
 
    outerPlan = outerPlanState(node);
    ExecEndNode(outerPlan);
}

References AggState::aggcontexts, Assert, ExecEndNode(), fb(), AggregateInstrumentation::hash_batches_used, AggState::hash_batches_used, AggState::hash_disk_used, AggState::hash_mem_peak, AggState::hash_metacxt, AggState::hash_tuplescxt, hashagg_reset_spill_state(), AggState::hashcontext, IsParallelWorker, Max, AggState::maxsets, MemoryContextDelete(), AggState::numtrans, outerPlan, outerPlanState, ParallelWorkerNumber, AggState::pertrans, ReScanExprContext(), AggState::shared_info, SharedAggInfo::sinstrument, AggState::sort_in, AggState::sort_out, AggStatePerTransData::sortstates, and tuplesort_end().

Referenced by ExecEndNode().

ExecInitAgg()

AggState * ExecInitAgg ( Agg *  node, EState *  estate, int  eflags  )

extern

Definition at line 3279 of file nodeAgg.c.

{
    AggState   *aggstate;
    AggStatePerAgg peraggs;
    AggStatePerTrans pertransstates;
    AggStatePerGroup *pergroups;
    Plan       *outerPlan;
    ExprContext *econtext;
    TupleDesc   scanDesc;
    int         max_aggno;
    int         max_transno;
    int         numaggrefs;
    int         numaggs;
    int         numtrans;
    int         phase;
    int         phaseidx;
    ListCell   *l;
    Bitmapset  *all_grouped_cols = NULL;
    int         numGroupingSets = 1;
    int         numPhases;
    int         numHashes;
    int         i = 0;
    int         j = 0;
    bool        use_hashing = (node->aggstrategy == AGG_HASHED ||
                               node->aggstrategy == AGG_MIXED);
 
    /* check for unsupported flags */
    Assert(!(eflags & (EXEC_FLAG_BACKWARD | EXEC_FLAG_MARK)));
 
    /*
     * create state structure
     */
    aggstate = makeNode(AggState);
    aggstate->ss.ps.plan = (Plan *) node;
    aggstate->ss.ps.state = estate;
    aggstate->ss.ps.ExecProcNode = ExecAgg;
 
    aggstate->aggs = NIL;
    aggstate->numaggs = 0;
    aggstate->numtrans = 0;
    aggstate->aggstrategy = node->aggstrategy;
    aggstate->aggsplit = node->aggsplit;
    aggstate->maxsets = 0;
    aggstate->projected_set = -1;
    aggstate->current_set = 0;
    aggstate->peragg = NULL;
    aggstate->pertrans = NULL;
    aggstate->curperagg = NULL;
    aggstate->curpertrans = NULL;
    aggstate->input_done = false;
    aggstate->agg_done = false;
    aggstate->pergroups = NULL;
    aggstate->grp_firstTuple = NULL;
    aggstate->sort_in = NULL;
    aggstate->sort_out = NULL;
 
    /*
     * phases[0] always exists, but is dummy in sorted/plain mode
     */
    numPhases = (use_hashing ? 1 : 2);
    numHashes = (use_hashing ? 1 : 0);
 
    /*
     * Calculate the maximum number of grouping sets in any phase; this
     * determines the size of some allocations.  Also calculate the number of
     * phases, since all hashed/mixed nodes contribute to only a single phase.
     */
    if (node->groupingSets)
    {
        numGroupingSets = list_length(node->groupingSets);
 
        foreach(l, node->chain)
        {
            Agg        *agg = lfirst(l);
 
            numGroupingSets = Max(numGroupingSets,
                                  list_length(agg->groupingSets));
 
            /*
             * additional AGG_HASHED aggs become part of phase 0, but all
             * others add an extra phase.
             */
            if (agg->aggstrategy != AGG_HASHED)
                ++numPhases;
            else
                ++numHashes;
        }
    }
 
    aggstate->maxsets = numGroupingSets;
    aggstate->numphases = numPhases;
 
    aggstate->aggcontexts = palloc0_array(ExprContext *, numGroupingSets);
 
    /*
     * Create expression contexts.  We need three or more, one for
     * per-input-tuple processing, one for per-output-tuple processing, one
     * for all the hashtables, and one for each grouping set.  The per-tuple
     * memory context of the per-grouping-set ExprContexts (aggcontexts)
     * replaces the standalone memory context formerly used to hold transition
     * values.  We cheat a little by using ExecAssignExprContext() to build
     * all of them.
     *
     * NOTE: the details of what is stored in aggcontexts and what is stored
     * in the regular per-query memory context are driven by a simple
     * decision: we want to reset the aggcontext at group boundaries (if not
     * hashing) and in ExecReScanAgg to recover no-longer-wanted space.
     */
    ExecAssignExprContext(estate, &aggstate->ss.ps);
    aggstate->tmpcontext = aggstate->ss.ps.ps_ExprContext;
 
    for (i = 0; i < numGroupingSets; ++i)
    {
        ExecAssignExprContext(estate, &aggstate->ss.ps);
        aggstate->aggcontexts[i] = aggstate->ss.ps.ps_ExprContext;
    }
 
    if (use_hashing)
        hash_create_memory(aggstate);
 
    ExecAssignExprContext(estate, &aggstate->ss.ps);
 
    /*
     * Initialize child nodes.
     *
     * If we are doing a hashed aggregation then the child plan does not need
     * to handle REWIND efficiently; see ExecReScanAgg.
     */
    if (node->aggstrategy == AGG_HASHED)
        eflags &= ~EXEC_FLAG_REWIND;
    outerPlan = outerPlan(node);
    outerPlanState(aggstate) = ExecInitNode(outerPlan, estate, eflags);
 
    /*
     * initialize source tuple type.
     */
    aggstate->ss.ps.outerops =
        ExecGetResultSlotOps(outerPlanState(&aggstate->ss),
                             &aggstate->ss.ps.outeropsfixed);
    aggstate->ss.ps.outeropsset = true;
 
    ExecCreateScanSlotFromOuterPlan(estate, &aggstate->ss,
                                    aggstate->ss.ps.outerops);
    scanDesc = aggstate->ss.ss_ScanTupleSlot->tts_tupleDescriptor;
 
    /*
     * If there are more than two phases (including a potential dummy phase
     * 0), input will be resorted using tuplesort. Need a slot for that.
     */
    if (numPhases > 2)
    {
        aggstate->sort_slot = ExecInitExtraTupleSlot(estate, scanDesc,
                                                     &TTSOpsMinimalTuple);
 
        /*
         * The output of the tuplesort, and the output from the outer child
         * might not use the same type of slot. In most cases the child will
         * be a Sort, and thus return a TTSOpsMinimalTuple type slot - but the
         * input can also be presorted due an index, in which case it could be
         * a different type of slot.
         *
         * XXX: For efficiency it would be good to instead/additionally
         * generate expressions with corresponding settings of outerops* for
         * the individual phases - deforming is often a bottleneck for
         * aggregations with lots of rows per group. If there's multiple
         * sorts, we know that all but the first use TTSOpsMinimalTuple (via
         * the nodeAgg.c internal tuplesort).
         */
        if (aggstate->ss.ps.outeropsfixed &&
            aggstate->ss.ps.outerops != &TTSOpsMinimalTuple)
            aggstate->ss.ps.outeropsfixed = false;
    }
 
    /*
     * Initialize result type, slot and projection.
     */
    ExecInitResultTupleSlotTL(&aggstate->ss.ps, &TTSOpsVirtual);
    ExecAssignProjectionInfo(&aggstate->ss.ps, NULL);
 
    /*
     * initialize child expressions
     *
     * We expect the parser to have checked that no aggs contain other agg
     * calls in their arguments (and just to be sure, we verify it again while
     * initializing the plan node).  This would make no sense under SQL
     * semantics, and it's forbidden by the spec.  Because it is true, we
     * don't need to worry about evaluating the aggs in any particular order.
     *
     * Note: execExpr.c finds Aggrefs for us, and adds them to aggstate->aggs.
     * Aggrefs in the qual are found here; Aggrefs in the targetlist are found
     * during ExecAssignProjectionInfo, above.
     */
    aggstate->ss.ps.qual =
        ExecInitQual(node->plan.qual, (PlanState *) aggstate);
 
    /*
     * We should now have found all Aggrefs in the targetlist and quals.
     */
    numaggrefs = list_length(aggstate->aggs);
    max_aggno = -1;
    max_transno = -1;
    foreach(l, aggstate->aggs)
    {
        Aggref     *aggref = (Aggref *) lfirst(l);
 
        max_aggno = Max(max_aggno, aggref->aggno);
        max_transno = Max(max_transno, aggref->aggtransno);
    }
    aggstate->numaggs = numaggs = max_aggno + 1;
    aggstate->numtrans = numtrans = max_transno + 1;
 
    /*
     * For each phase, prepare grouping set data and fmgr lookup data for
     * compare functions.  Accumulate all_grouped_cols in passing.
     */
    aggstate->phases = palloc0_array(AggStatePerPhaseData, numPhases);
 
    aggstate->num_hashes = numHashes;
    if (numHashes)
    {
        aggstate->perhash = palloc0_array(AggStatePerHashData, numHashes);
        aggstate->phases[0].numsets = 0;
        aggstate->phases[0].gset_lengths = palloc_array(int, numHashes);
        aggstate->phases[0].grouped_cols = palloc_array(Bitmapset *, numHashes);
    }
 
    phase = 0;
    for (phaseidx = 0; phaseidx <= list_length(node->chain); ++phaseidx)
    {
        Agg        *aggnode;
        Sort       *sortnode;
 
        if (phaseidx > 0)
        {
            aggnode = list_nth_node(Agg, node->chain, phaseidx - 1);
            sortnode = castNode(Sort, outerPlan(aggnode));
        }
        else
        {
            aggnode = node;
            sortnode = NULL;
        }
 
        Assert(phase <= 1 || sortnode);
 
        if (aggnode->aggstrategy == AGG_HASHED
            || aggnode->aggstrategy == AGG_MIXED)
        {
            AggStatePerPhase phasedata = &aggstate->phases[0];
            AggStatePerHash perhash;
            Bitmapset  *cols = NULL;
 
            Assert(phase == 0);
            i = phasedata->numsets++;
            perhash = &aggstate->perhash[i];
 
            /* phase 0 always points to the "real" Agg in the hash case */
            phasedata->aggnode = node;
            phasedata->aggstrategy = node->aggstrategy;
 
            /* but the actual Agg node representing this hash is saved here */
            perhash->aggnode = aggnode;
 
            phasedata->gset_lengths[i] = perhash->numCols = aggnode->numCols;
 
            for (j = 0; j < aggnode->numCols; ++j)
                cols = bms_add_member(cols, aggnode->grpColIdx[j]);
 
            phasedata->grouped_cols[i] = cols;
 
            all_grouped_cols = bms_add_members(all_grouped_cols, cols);
            continue;
        }
        else
        {
            AggStatePerPhase phasedata = &aggstate->phases[++phase];
            int         num_sets;
 
            phasedata->numsets = num_sets = list_length(aggnode->groupingSets);
 
            if (num_sets)
            {
                phasedata->gset_lengths = palloc(num_sets * sizeof(int));
                phasedata->grouped_cols = palloc(num_sets * sizeof(Bitmapset *));
 
                i = 0;
                foreach(l, aggnode->groupingSets)
                {
                    int         current_length = list_length(lfirst(l));
                    Bitmapset  *cols = NULL;
 
                    /* planner forces this to be correct */
                    for (j = 0; j < current_length; ++j)
                        cols = bms_add_member(cols, aggnode->grpColIdx[j]);
 
                    phasedata->grouped_cols[i] = cols;
                    phasedata->gset_lengths[i] = current_length;
 
                    ++i;
                }
 
                all_grouped_cols = bms_add_members(all_grouped_cols,
                                                   phasedata->grouped_cols[0]);
            }
            else
            {
                Assert(phaseidx == 0);
 
                phasedata->gset_lengths = NULL;
                phasedata->grouped_cols = NULL;
            }
 
            /*
             * If we are grouping, precompute fmgr lookup data for inner loop.
             */
            if (aggnode->aggstrategy == AGG_SORTED)
            {
                /*
                 * Build a separate function for each subset of columns that
                 * need to be compared.
                 */
                phasedata->eqfunctions = palloc0_array(ExprState *, aggnode->numCols);
 
                /* for each grouping set */
                for (int k = 0; k < phasedata->numsets; k++)
                {
                    int         length = phasedata->gset_lengths[k];
 
                    /* nothing to do for empty grouping set */
                    if (length == 0)
                        continue;
 
                    /* if we already had one of this length, it'll do */
                    if (phasedata->eqfunctions[length - 1] != NULL)
                        continue;
 
                    phasedata->eqfunctions[length - 1] =
                        execTuplesMatchPrepare(scanDesc,
                                               length,
                                               aggnode->grpColIdx,
                                               aggnode->grpOperators,
                                               aggnode->grpCollations,
                                               (PlanState *) aggstate);
                }
 
                /* and for all grouped columns, unless already computed */
                if (aggnode->numCols > 0 &&
                    phasedata->eqfunctions[aggnode->numCols - 1] == NULL)
                {
                    phasedata->eqfunctions[aggnode->numCols - 1] =
                        execTuplesMatchPrepare(scanDesc,
                                               aggnode->numCols,
                                               aggnode->grpColIdx,
                                               aggnode->grpOperators,
                                               aggnode->grpCollations,
                                               (PlanState *) aggstate);
                }
            }
 
            phasedata->aggnode = aggnode;
            phasedata->aggstrategy = aggnode->aggstrategy;
            phasedata->sortnode = sortnode;
        }
    }
 
    /*
     * Convert all_grouped_cols to a descending-order list.
     */
    i = -1;
    while ((i = bms_next_member(all_grouped_cols, i)) >= 0)
        aggstate->all_grouped_cols = lcons_int(i, aggstate->all_grouped_cols);
 
    /*
     * Set up aggregate-result storage in the output expr context, and also
     * allocate my private per-agg working storage
     */
    econtext = aggstate->ss.ps.ps_ExprContext;
    econtext->ecxt_aggvalues = palloc0_array(Datum, numaggs);
    econtext->ecxt_aggnulls = palloc0_array(bool, numaggs);
 
    peraggs = palloc0_array(AggStatePerAggData, numaggs);
    pertransstates = palloc0_array(AggStatePerTransData, numtrans);
 
    aggstate->peragg = peraggs;
    aggstate->pertrans = pertransstates;
 
 
    aggstate->all_pergroups = palloc0_array(AggStatePerGroup, numGroupingSets + numHashes);
    pergroups = aggstate->all_pergroups;
 
    if (node->aggstrategy != AGG_HASHED)
    {
        for (i = 0; i < numGroupingSets; i++)
        {
            pergroups[i] = palloc0_array(AggStatePerGroupData, numaggs);
        }
 
        aggstate->pergroups = pergroups;
        pergroups += numGroupingSets;
    }
 
    /*
     * Hashing can only appear in the initial phase.
     */
    if (use_hashing)
    {
        Plan       *outerplan = outerPlan(node);
        double      totalGroups = 0;
 
        aggstate->hash_spill_rslot = ExecInitExtraTupleSlot(estate, scanDesc,
                                                            &TTSOpsMinimalTuple);
        aggstate->hash_spill_wslot = ExecInitExtraTupleSlot(estate, scanDesc,
                                                            &TTSOpsVirtual);
 
        /* this is an array of pointers, not structures */
        aggstate->hash_pergroup = pergroups;
 
        aggstate->hashentrysize = hash_agg_entry_size(aggstate->numtrans,
                                                      outerplan->plan_width,
                                                      node->transitionSpace);
 
        /*
         * Consider all of the grouping sets together when setting the limits
         * and estimating the number of partitions. This can be inaccurate
         * when there is more than one grouping set, but should still be
         * reasonable.
         */
        for (int k = 0; k < aggstate->num_hashes; k++)
            totalGroups += aggstate->perhash[k].aggnode->numGroups;
 
        hash_agg_set_limits(aggstate->hashentrysize, totalGroups, 0,
                            &aggstate->hash_mem_limit,
                            &aggstate->hash_ngroups_limit,
                            &aggstate->hash_planned_partitions);
        find_hash_columns(aggstate);
 
        /* Skip massive memory allocation if we are just doing EXPLAIN */
        if (!(eflags & EXEC_FLAG_EXPLAIN_ONLY))
            build_hash_tables(aggstate);
 
        aggstate->table_filled = false;
 
        /* Initialize this to 1, meaning nothing spilled, yet */
        aggstate->hash_batches_used = 1;
    }
 
    /*
     * Initialize current phase-dependent values to initial phase. The initial
     * phase is 1 (first sort pass) for all strategies that use sorting (if
     * hashing is being done too, then phase 0 is processed last); but if only
     * hashing is being done, then phase 0 is all there is.
     */
    if (node->aggstrategy == AGG_HASHED)
    {
        aggstate->current_phase = 0;
        initialize_phase(aggstate, 0);
        select_current_set(aggstate, 0, true);
    }
    else
    {
        aggstate->current_phase = 1;
        initialize_phase(aggstate, 1);
        select_current_set(aggstate, 0, false);
    }
 
    /*
     * Perform lookups of aggregate function info, and initialize the
     * unchanging fields of the per-agg and per-trans data.
     */
    foreach(l, aggstate->aggs)
    {
        Aggref     *aggref = lfirst(l);
        AggStatePerAgg peragg;
        AggStatePerTrans pertrans;
        Oid         aggTransFnInputTypes[FUNC_MAX_ARGS];
        int         numAggTransFnArgs;
        int         numDirectArgs;
        HeapTuple   aggTuple;
        Form_pg_aggregate aggform;
        AclResult   aclresult;
        Oid         finalfn_oid;
        Oid         serialfn_oid,
                    deserialfn_oid;
        Oid         aggOwner;
        Expr       *finalfnexpr;
        Oid         aggtranstype;
 
        /* Planner should have assigned aggregate to correct level */
        Assert(aggref->agglevelsup == 0);
        /* ... and the split mode should match */
        Assert(aggref->aggsplit == aggstate->aggsplit);
 
        peragg = &peraggs[aggref->aggno];
 
        /* Check if we initialized the state for this aggregate already. */
        if (peragg->aggref != NULL)
            continue;
 
        peragg->aggref = aggref;
        peragg->transno = aggref->aggtransno;
 
        /* Fetch the pg_aggregate row */
        aggTuple = SearchSysCache1(AGGFNOID,
                                   ObjectIdGetDatum(aggref->aggfnoid));
        if (!HeapTupleIsValid(aggTuple))
            elog(ERROR, "cache lookup failed for aggregate %u",
                 aggref->aggfnoid);
        aggform = (Form_pg_aggregate) GETSTRUCT(aggTuple);
 
        /* Check permission to call aggregate function */
        aclresult = object_aclcheck(ProcedureRelationId, aggref->aggfnoid, GetUserId(),
                                    ACL_EXECUTE);
        if (aclresult != ACLCHECK_OK)
            aclcheck_error(aclresult, OBJECT_AGGREGATE,
                           get_func_name(aggref->aggfnoid));
        InvokeFunctionExecuteHook(aggref->aggfnoid);
 
        /* planner recorded transition state type in the Aggref itself */
        aggtranstype = aggref->aggtranstype;
        Assert(OidIsValid(aggtranstype));
 
        /* Final function only required if we're finalizing the aggregates */
        if (DO_AGGSPLIT_SKIPFINAL(aggstate->aggsplit))
            peragg->finalfn_oid = finalfn_oid = InvalidOid;
        else
            peragg->finalfn_oid = finalfn_oid = aggform->aggfinalfn;
 
        serialfn_oid = InvalidOid;
        deserialfn_oid = InvalidOid;
 
        /*
         * Check if serialization/deserialization is required.  We only do it
         * for aggregates that have transtype INTERNAL.
         */
        if (aggtranstype == INTERNALOID)
        {
            /*
             * The planner should only have generated a serialize agg node if
             * every aggregate with an INTERNAL state has a serialization
             * function.  Verify that.
             */
            if (DO_AGGSPLIT_SERIALIZE(aggstate->aggsplit))
            {
                /* serialization only valid when not running finalfn */
                Assert(DO_AGGSPLIT_SKIPFINAL(aggstate->aggsplit));
 
                if (!OidIsValid(aggform->aggserialfn))
                    elog(ERROR, "serialfunc not provided for serialization aggregation");
                serialfn_oid = aggform->aggserialfn;
            }
 
            /* Likewise for deserialization functions */
            if (DO_AGGSPLIT_DESERIALIZE(aggstate->aggsplit))
            {
                /* deserialization only valid when combining states */
                Assert(DO_AGGSPLIT_COMBINE(aggstate->aggsplit));
 
                if (!OidIsValid(aggform->aggdeserialfn))
                    elog(ERROR, "deserialfunc not provided for deserialization aggregation");
                deserialfn_oid = aggform->aggdeserialfn;
            }
        }
 
        /* Check that aggregate owner has permission to call component fns */
        {
            HeapTuple   procTuple;
 
            procTuple = SearchSysCache1(PROCOID,
                                        ObjectIdGetDatum(aggref->aggfnoid));
            if (!HeapTupleIsValid(procTuple))
                elog(ERROR, "cache lookup failed for function %u",
                     aggref->aggfnoid);
            aggOwner = ((Form_pg_proc) GETSTRUCT(procTuple))->proowner;
            ReleaseSysCache(procTuple);
 
            if (OidIsValid(finalfn_oid))
            {
                aclresult = object_aclcheck(ProcedureRelationId, finalfn_oid, aggOwner,
                                            ACL_EXECUTE);
                if (aclresult != ACLCHECK_OK)
                    aclcheck_error(aclresult, OBJECT_FUNCTION,
                                   get_func_name(finalfn_oid));
                InvokeFunctionExecuteHook(finalfn_oid);
            }
            if (OidIsValid(serialfn_oid))
            {
                aclresult = object_aclcheck(ProcedureRelationId, serialfn_oid, aggOwner,
                                            ACL_EXECUTE);
                if (aclresult != ACLCHECK_OK)
                    aclcheck_error(aclresult, OBJECT_FUNCTION,
                                   get_func_name(serialfn_oid));
                InvokeFunctionExecuteHook(serialfn_oid);
            }
            if (OidIsValid(deserialfn_oid))
            {
                aclresult = object_aclcheck(ProcedureRelationId, deserialfn_oid, aggOwner,
                                            ACL_EXECUTE);
                if (aclresult != ACLCHECK_OK)
                    aclcheck_error(aclresult, OBJECT_FUNCTION,
                                   get_func_name(deserialfn_oid));
                InvokeFunctionExecuteHook(deserialfn_oid);
            }
        }
 
        /*
         * Get actual datatypes of the (nominal) aggregate inputs.  These
         * could be different from the agg's declared input types, when the
         * agg accepts ANY or a polymorphic type.
         */
        numAggTransFnArgs = get_aggregate_argtypes(aggref,
                                                   aggTransFnInputTypes);
 
        /* Count the "direct" arguments, if any */
        numDirectArgs = list_length(aggref->aggdirectargs);
 
        /* Detect how many arguments to pass to the finalfn */
        if (aggform->aggfinalextra)
            peragg->numFinalArgs = numAggTransFnArgs + 1;
        else
            peragg->numFinalArgs = numDirectArgs + 1;
 
        /* Initialize any direct-argument expressions */
        peragg->aggdirectargs = ExecInitExprList(aggref->aggdirectargs,
                                                 (PlanState *) aggstate);
 
        /*
         * build expression trees using actual argument & result types for the
         * finalfn, if it exists and is required.
         */
        if (OidIsValid(finalfn_oid))
        {
            build_aggregate_finalfn_expr(aggTransFnInputTypes,
                                         peragg->numFinalArgs,
                                         aggtranstype,
                                         aggref->aggtype,
                                         aggref->inputcollid,
                                         finalfn_oid,
                                         &finalfnexpr);
            fmgr_info(finalfn_oid, &peragg->finalfn);
            fmgr_info_set_expr((Node *) finalfnexpr, &peragg->finalfn);
        }
 
        /* get info about the output value's datatype */
        get_typlenbyval(aggref->aggtype,
                        &peragg->resulttypeLen,
                        &peragg->resulttypeByVal);
 
        /*
         * Build working state for invoking the transition function, if we
         * haven't done it already.
         */
        pertrans = &pertransstates[aggref->aggtransno];
        if (pertrans->aggref == NULL)
        {
            Datum       textInitVal;
            Datum       initValue;
            bool        initValueIsNull;
            Oid         transfn_oid;
 
            /*
             * If this aggregation is performing state combines, then instead
             * of using the transition function, we'll use the combine
             * function.
             */
            if (DO_AGGSPLIT_COMBINE(aggstate->aggsplit))
            {
                transfn_oid = aggform->aggcombinefn;
 
                /* If not set then the planner messed up */
                if (!OidIsValid(transfn_oid))
                    elog(ERROR, "combinefn not set for aggregate function");
            }
            else
                transfn_oid = aggform->aggtransfn;
 
            aclresult = object_aclcheck(ProcedureRelationId, transfn_oid, aggOwner, ACL_EXECUTE);
            if (aclresult != ACLCHECK_OK)
                aclcheck_error(aclresult, OBJECT_FUNCTION,
                               get_func_name(transfn_oid));
            InvokeFunctionExecuteHook(transfn_oid);
 
            /*
             * initval is potentially null, so don't try to access it as a
             * struct field. Must do it the hard way with SysCacheGetAttr.
             */
            textInitVal = SysCacheGetAttr(AGGFNOID, aggTuple,
                                          Anum_pg_aggregate_agginitval,
                                          &initValueIsNull);
            if (initValueIsNull)
                initValue = (Datum) 0;
            else
                initValue = GetAggInitVal(textInitVal, aggtranstype);
 
            if (DO_AGGSPLIT_COMBINE(aggstate->aggsplit))
            {
                Oid         combineFnInputTypes[] = {aggtranstype,
                aggtranstype};
 
                /*
                 * When combining there's only one input, the to-be-combined
                 * transition value.  The transition value is not counted
                 * here.
                 */
                pertrans->numTransInputs = 1;
 
                /* aggcombinefn always has two arguments of aggtranstype */
                build_pertrans_for_aggref(pertrans, aggstate, estate,
                                          aggref, transfn_oid, aggtranstype,
                                          serialfn_oid, deserialfn_oid,
                                          initValue, initValueIsNull,
                                          combineFnInputTypes, 2);
 
                /*
                 * Ensure that a combine function to combine INTERNAL states
                 * is not strict. This should have been checked during CREATE
                 * AGGREGATE, but the strict property could have been changed
                 * since then.
                 */
                if (pertrans->transfn.fn_strict && aggtranstype == INTERNALOID)
                    ereport(ERROR,
                            (errcode(ERRCODE_INVALID_FUNCTION_DEFINITION),
                             errmsg("combine function with transition type %s must not be declared STRICT",
                                    format_type_be(aggtranstype))));
            }
            else
            {
                /* Detect how many arguments to pass to the transfn */
                if (AGGKIND_IS_ORDERED_SET(aggref->aggkind))
                    pertrans->numTransInputs = list_length(aggref->args);
                else
                    pertrans->numTransInputs = numAggTransFnArgs;
 
                build_pertrans_for_aggref(pertrans, aggstate, estate,
                                          aggref, transfn_oid, aggtranstype,
                                          serialfn_oid, deserialfn_oid,
                                          initValue, initValueIsNull,
                                          aggTransFnInputTypes,
                                          numAggTransFnArgs);
 
                /*
                 * If the transfn is strict and the initval is NULL, make sure
                 * input type and transtype are the same (or at least
                 * binary-compatible), so that it's OK to use the first
                 * aggregated input value as the initial transValue.  This
                 * should have been checked at agg definition time, but we
                 * must check again in case the transfn's strictness property
                 * has been changed.
                 */
                if (pertrans->transfn.fn_strict && pertrans->initValueIsNull)
                {
                    if (numAggTransFnArgs <= numDirectArgs ||
                        !IsBinaryCoercible(aggTransFnInputTypes[numDirectArgs],
                                           aggtranstype))
                        ereport(ERROR,
                                (errcode(ERRCODE_INVALID_FUNCTION_DEFINITION),
                                 errmsg("aggregate %u needs to have compatible input type and transition type",
                                        aggref->aggfnoid)));
                }
            }
        }
        else
            pertrans->aggshared = true;
        ReleaseSysCache(aggTuple);
    }
 
    /*
     * Last, check whether any more aggregates got added onto the node while
     * we processed the expressions for the aggregate arguments (including not
     * only the regular arguments and FILTER expressions handled immediately
     * above, but any direct arguments we might've handled earlier).  If so,
     * we have nested aggregate functions, which is semantically nonsensical,
     * so complain.  (This should have been caught by the parser, so we don't
     * need to work hard on a helpful error message; but we defend against it
     * here anyway, just to be sure.)
     */
    if (numaggrefs != list_length(aggstate->aggs))
        ereport(ERROR,
                (errcode(ERRCODE_GROUPING_ERROR),
                 errmsg("aggregate function calls cannot be nested")));
 
    /*
     * Build expressions doing all the transition work at once. We build a
     * different one for each phase, as the number of transition function
     * invocation can differ between phases. Note this'll work both for
     * transition and combination functions (although there'll only be one
     * phase in the latter case).
     */
    for (phaseidx = 0; phaseidx < aggstate->numphases; phaseidx++)
    {
        AggStatePerPhase phase = &aggstate->phases[phaseidx];
        bool        dohash = false;
        bool        dosort = false;
 
        /* phase 0 doesn't necessarily exist */
        if (!phase->aggnode)
            continue;
 
        if (aggstate->aggstrategy == AGG_MIXED && phaseidx == 1)
        {
            /*
             * Phase one, and only phase one, in a mixed agg performs both
             * sorting and aggregation.
             */
            dohash = true;
            dosort = true;
        }
        else if (aggstate->aggstrategy == AGG_MIXED && phaseidx == 0)
        {
            /*
             * No need to compute a transition function for an AGG_MIXED phase
             * 0 - the contents of the hashtables will have been computed
             * during phase 1.
             */
            continue;
        }
        else if (phase->aggstrategy == AGG_PLAIN ||
                 phase->aggstrategy == AGG_SORTED)
        {
            dohash = false;
            dosort = true;
        }
        else if (phase->aggstrategy == AGG_HASHED)
        {
            dohash = true;
            dosort = false;
        }
        else
            Assert(false);
 
        phase->evaltrans = ExecBuildAggTrans(aggstate, phase, dosort, dohash,
                                             false);
 
        /* cache compiled expression for outer slot without NULL check */
        phase->evaltrans_cache[0][0] = phase->evaltrans;
    }
 
    return aggstate;
}

References ACL_EXECUTE, aclcheck_error(), ACLCHECK_OK, AGG_HASHED, AGG_MIXED, AGG_PLAIN, AGG_SORTED, AggStatePerAggData::aggdirectargs, Aggref::aggdirectargs, Aggref::aggfnoid, AggStatePerPhaseData::aggnode, AggStatePerHashData::aggnode, AggStatePerTransData::aggref, AggStatePerAggData::aggref, AggStatePerTransData::aggshared, Agg::aggsplit, AggStatePerPhaseData::aggstrategy, Agg::aggstrategy, Aggref::args, Assert, bms_add_member(), bms_add_members(), bms_next_member(), build_aggregate_finalfn_expr(), build_hash_tables(), build_pertrans_for_aggref(), castNode, Agg::chain, DO_AGGSPLIT_COMBINE, DO_AGGSPLIT_DESERIALIZE, DO_AGGSPLIT_SERIALIZE, DO_AGGSPLIT_SKIPFINAL, ExprContext::ecxt_aggnulls, ExprContext::ecxt_aggvalues, elog, ereport, errcode(), errmsg(), ERROR, AggStatePerPhaseData::evaltrans, AggStatePerPhaseData::evaltrans_cache, EXEC_FLAG_BACKWARD, EXEC_FLAG_EXPLAIN_ONLY, EXEC_FLAG_MARK, ExecAgg(), ExecAssignExprContext(), ExecAssignProjectionInfo(), ExecBuildAggTrans(), ExecCreateScanSlotFromOuterPlan(), ExecGetResultSlotOps(), ExecInitExprList(), ExecInitExtraTupleSlot(), ExecInitNode(), ExecInitQual(), ExecInitResultTupleSlotTL(), execTuplesMatchPrepare(), fb(), AggStatePerAggData::finalfn, AggStatePerAggData::finalfn_oid, find_hash_columns(), fmgr_info(), fmgr_info_set_expr, FmgrInfo::fn_strict, format_type_be(), FUNC_MAX_ARGS, get_aggregate_argtypes(), get_func_name(), get_typlenbyval(), GetAggInitVal(), GETSTRUCT(), GetUserId(), Agg::groupingSets, hash_agg_entry_size(), hash_agg_set_limits(), hash_create_memory(), HeapTupleIsValid, i, initialize_phase(), initValue(), AggStatePerTransData::initValueIsNull, InvalidOid, InvokeFunctionExecuteHook, IsBinaryCoercible(), j, lcons_int(), lfirst, list_length(), list_nth_node, makeNode, Max, NIL, AggStatePerHashData::numCols, Agg::numCols, AggStatePerAggData::numFinalArgs, AggStatePerPhaseData::numsets, AggStatePerTransData::numTransInputs, object_aclcheck(), OBJECT_AGGREGATE, OBJECT_FUNCTION, ObjectIdGetDatum(), OidIsValid, outerPlan, outerPlanState, palloc(), palloc0_array, palloc_array, Agg::plan, Plan::qual, ReleaseSysCache(), AggStatePerAggData::resulttypeByVal, AggStatePerAggData::resulttypeLen, SearchSysCache1(), select_current_set(), SysCacheGetAttr(), AggStatePerTransData::transfn, Agg::transitionSpace, AggStatePerAggData::transno, TTSOpsMinimalTuple, and TTSOpsVirtual.

Referenced by ExecInitNode().

ExecReScanAgg()

void ExecReScanAgg ( AggState *  node )

extern

Definition at line 4460 of file nodeAgg.c.

{
    ExprContext *econtext = node->ss.ps.ps_ExprContext;
    PlanState  *outerPlan = outerPlanState(node);
    Agg        *aggnode = (Agg *) node->ss.ps.plan;
    int         transno;
    int         numGroupingSets = Max(node->maxsets, 1);
    int         setno;
 
    node->agg_done = false;
 
    if (node->aggstrategy == AGG_HASHED)
    {
        /*
         * In the hashed case, if we haven't yet built the hash table then we
         * can just return; nothing done yet, so nothing to undo. If subnode's
         * chgParam is not NULL then it will be re-scanned by ExecProcNode,
         * else no reason to re-scan it at all.
         */
        if (!node->table_filled)
            return;
 
        /*
         * If we do have the hash table, and it never spilled, and the subplan
         * does not have any parameter changes, and none of our own parameter
         * changes affect input expressions of the aggregated functions, then
         * we can just rescan the existing hash table; no need to build it
         * again.
         */
        if (outerPlan->chgParam == NULL && !node->hash_ever_spilled &&
            !bms_overlap(node->ss.ps.chgParam, aggnode->aggParams))
        {
            ResetTupleHashIterator(node->perhash[0].hashtable,
                                   &node->perhash[0].hashiter);
            select_current_set(node, 0, true);
            return;
        }
    }
 
    /* Make sure we have closed any open tuplesorts */
    for (transno = 0; transno < node->numtrans; transno++)
    {
        for (setno = 0; setno < numGroupingSets; setno++)
        {
            AggStatePerTrans pertrans = &node->pertrans[transno];
 
            if (pertrans->sortstates[setno])
            {
                tuplesort_end(pertrans->sortstates[setno]);
                pertrans->sortstates[setno] = NULL;
            }
        }
    }
 
    /*
     * We don't need to ReScanExprContext the output tuple context here;
     * ExecReScan already did it. But we do need to reset our per-grouping-set
     * contexts, which may have transvalues stored in them. (We use rescan
     * rather than just reset because transfns may have registered callbacks
     * that need to be run now.) For the AGG_HASHED case, see below.
     */
 
    for (setno = 0; setno < numGroupingSets; setno++)
    {
        ReScanExprContext(node->aggcontexts[setno]);
    }
 
    /* Release first tuple of group, if we have made a copy */
    if (node->grp_firstTuple != NULL)
    {
        heap_freetuple(node->grp_firstTuple);
        node->grp_firstTuple = NULL;
    }
    ExecClearTuple(node->ss.ss_ScanTupleSlot);
 
    /* Forget current agg values */
    MemSet(econtext->ecxt_aggvalues, 0, sizeof(Datum) * node->numaggs);
    MemSet(econtext->ecxt_aggnulls, 0, sizeof(bool) * node->numaggs);
 
    /*
     * With AGG_HASHED/MIXED, the hash table is allocated in a sub-context of
     * the hashcontext. This used to be an issue, but now, resetting a context
     * automatically deletes sub-contexts too.
     */
    if (node->aggstrategy == AGG_HASHED || node->aggstrategy == AGG_MIXED)
    {
        hashagg_reset_spill_state(node);
 
        node->hash_ever_spilled = false;
        node->hash_spill_mode = false;
        node->hash_ngroups_current = 0;
 
        ReScanExprContext(node->hashcontext);
        /* Rebuild empty hash table(s) */
        build_hash_tables(node);
        node->table_filled = false;
        /* iterator will be reset when the table is filled */
 
        hashagg_recompile_expressions(node, false, false);
    }
 
    if (node->aggstrategy != AGG_HASHED)
    {
        /*
         * Reset the per-group state (in particular, mark transvalues null)
         */
        for (setno = 0; setno < numGroupingSets; setno++)
        {
            MemSet(node->pergroups[setno], 0,
                   sizeof(AggStatePerGroupData) * node->numaggs);
        }
 
        /* reset to phase 1 */
        initialize_phase(node, 1);
 
        node->input_done = false;
        node->projected_set = -1;
    }
 
    if (outerPlan->chgParam == NULL)
        ExecReScan(outerPlan);
}

References AggState::agg_done, AGG_HASHED, AGG_MIXED, AggState::aggcontexts, Agg::aggParams, AggState::aggstrategy, bms_overlap(), build_hash_tables(), PlanState::chgParam, ExprContext::ecxt_aggnulls, ExprContext::ecxt_aggvalues, ExecClearTuple(), ExecReScan(), fb(), AggState::grp_firstTuple, AggState::hash_ever_spilled, AggState::hash_ngroups_current, AggState::hash_spill_mode, hashagg_recompile_expressions(), hashagg_reset_spill_state(), AggState::hashcontext, AggStatePerHashData::hashiter, AggStatePerHashData::hashtable, heap_freetuple(), initialize_phase(), AggState::input_done, Max, AggState::maxsets, MemSet, AggState::numaggs, AggState::numtrans, outerPlan, outerPlanState, AggState::pergroups, AggState::perhash, AggState::pertrans, PlanState::plan, AggState::projected_set, ScanState::ps, PlanState::ps_ExprContext, ReScanExprContext(), ResetTupleHashIterator, select_current_set(), AggStatePerTransData::sortstates, AggState::ss, ScanState::ss_ScanTupleSlot, AggState::table_filled, and tuplesort_end().

Referenced by ExecReScan().

hash_agg_entry_size()

Size hash_agg_entry_size ( int  numTrans, Size  tupleWidth, Size  transitionSpace  )

extern

Definition at line 1698 of file nodeAgg.c.

{
    Size        tupleChunkSize;
    Size        pergroupChunkSize;
    Size        transitionChunkSize;
    Size        tupleSize = (MAXALIGN(SizeofMinimalTupleHeader) +
                             tupleWidth);
    Size        pergroupSize = numTrans * sizeof(AggStatePerGroupData);
 
    /*
     * Entries use the Bump allocator, so the chunk sizes are the same as the
     * requested sizes.
     */
    tupleChunkSize = MAXALIGN(tupleSize);
    pergroupChunkSize = pergroupSize;
 
    /*
     * Transition values use AllocSet, which has a chunk header and also uses
     * power-of-two allocations.
     */
    if (transitionSpace > 0)
        transitionChunkSize = CHUNKHDRSZ + pg_nextpower2_size_t(transitionSpace);
    else
        transitionChunkSize = 0;
 
    return
        TupleHashEntrySize() +
        tupleChunkSize +
        pergroupChunkSize +
        transitionChunkSize;
}

References CHUNKHDRSZ, fb(), MAXALIGN, pg_nextpower2_size_t, SizeofMinimalTupleHeader, and TupleHashEntrySize().

Referenced by cost_agg(), estimate_hashagg_tablesize(), and ExecInitAgg().

hash_agg_set_limits()

void hash_agg_set_limits ( double  hashentrysize, double  input_groups, int  used_bits, Size *  mem_limit, uint64 *  ngroups_limit, int *  num_partitions  )

extern

Definition at line 1806 of file nodeAgg.c.

{
    int         npartitions;
    Size        partition_mem;
    Size        hash_mem_limit = get_hash_memory_limit();
 
    /* if not expected to spill, use all of hash_mem */
    if (input_groups * hashentrysize <= hash_mem_limit)
    {
        if (num_partitions != NULL)
            *num_partitions = 0;
        *mem_limit = hash_mem_limit;
        *ngroups_limit = hash_mem_limit / hashentrysize;
        return;
    }
 
    /*
     * Calculate expected memory requirements for spilling, which is the size
     * of the buffers needed for all the tapes that need to be open at once.
     * Then, subtract that from the memory available for holding hash tables.
     */
    npartitions = hash_choose_num_partitions(input_groups,
                                             hashentrysize,
                                             used_bits,
                                             NULL);
    if (num_partitions != NULL)
        *num_partitions = npartitions;
 
    partition_mem =
        HASHAGG_READ_BUFFER_SIZE +
        HASHAGG_WRITE_BUFFER_SIZE * npartitions;
 
    /*
     * Don't set the limit below 3/4 of hash_mem. In that case, we are at the
     * minimum number of partitions, so we aren't going to dramatically exceed
     * work mem anyway.
     */
    if (hash_mem_limit > 4 * partition_mem)
        *mem_limit = hash_mem_limit - partition_mem;
    else
        *mem_limit = hash_mem_limit * 0.75;
 
    if (*mem_limit > hashentrysize)
        *ngroups_limit = *mem_limit / hashentrysize;
    else
        *ngroups_limit = 1;
}

References fb(), get_hash_memory_limit(), hash_choose_num_partitions(), HASHAGG_READ_BUFFER_SIZE, and HASHAGG_WRITE_BUFFER_SIZE.

Referenced by agg_refill_hash_table(), cost_agg(), and ExecInitAgg().