295 #define HASHAGG_PARTITION_FACTOR 1.50
296 #define HASHAGG_MIN_PARTITIONS 4
297 #define HASHAGG_MAX_PARTITIONS 1024
305 #define HASHAGG_READ_BUFFER_SIZE BLCKSZ
306 #define HASHAGG_WRITE_BUFFER_SIZE BLCKSZ
314 #define HASHAGG_HLL_BIT_WIDTH 5
320 #define CHUNKHDRSZ 16
386 Datum *resultVal,
bool *resultIsNull);
390 Datum *resultVal,
bool *resultIsNull);
409 long ngroups,
Size memory);
411 double hashentrysize,
413 int *log2_npartitions);
430 int64 input_tuples,
double input_card,
434 int used_bits,
double input_groups,
435 double hashentrysize);
444 Oid aggtranstype,
Oid aggserialfn,
446 bool initValueIsNull,
Oid *inputTypes,
479 Assert(newphase <= 1 || newphase == aggstate->current_phase + 1);
518 if (newphase > 0 && newphase < aggstate->numphases - 1)
526 sortnode->sortColIdx,
527 sortnode->sortOperators,
528 sortnode->collations,
529 sortnode->nullsFirst,
676 numReset = numGroupingSets;
678 for (setno = 0; setno < numReset; setno++)
684 for (transno = 0; transno < numTrans; transno++)
723 for (
i = 1;
i <= numTransInputs;
i++)
853 bool oldIsNull =
true;
854 bool haveOldVal =
false;
879 true,
false, newVal, isNull, &newAbbrevVal))
893 ((oldIsNull && *isNull) ||
894 (!oldIsNull && !*isNull &&
895 oldAbbrevVal == newAbbrevVal &&
923 oldAbbrevVal = newAbbrevVal;
961 bool haveOldValue =
false;
972 true,
true, slot1, &newAbbrevVal))
979 if (numDistinctCols == 0 ||
981 newAbbrevVal != oldAbbrevVal ||
992 for (
i = 0;
i < numTransInputs;
i++)
1000 if (numDistinctCols > 0)
1008 oldAbbrevVal = newAbbrevVal;
1009 haveOldValue =
true;
1049 Datum *resultVal,
bool *resultIsNull)
1052 bool anynull =
false;
1073 &fcinfo->args[
i].isnull);
1074 anynull |= fcinfo->args[
i].isnull;
1091 (
void *) aggstate, NULL);
1094 fcinfo->args[0].value =
1102 for (;
i < numFinalArgs;
i++)
1104 fcinfo->args[
i].value = (
Datum) 0;
1105 fcinfo->args[
i].isnull =
true;
1109 if (fcinfo->flinfo->fn_strict && anynull)
1112 *resultVal = (
Datum) 0;
1113 *resultIsNull =
true;
1120 *resultIsNull = fcinfo->isnull;
1125 aggstate->curperagg = NULL;
1149 Datum *resultVal,
bool *resultIsNull)
1165 *resultVal = (
Datum) 0;
1166 *resultIsNull =
true;
1181 *resultIsNull = fcinfo->
isnull;
1307 for (
int transno = 0; transno < aggstate->
numtrans; transno++)
1312 pergroupstate = &pergroup[transno];
1348 for (aggno = 0; aggno < aggstate->
numaggs; aggno++)
1351 int transno = peragg->
transno;
1354 pergroupstate = &pergroup[transno];
1358 &aggvalues[aggno], &aggnulls[aggno]);
1361 &aggvalues[aggno], &aggnulls[aggno]);
1415 *aggregated =
context.aggregated;
1416 *unaggregated =
context.unaggregated;
1472 for (setno = 0; setno < aggstate->
num_hashes; ++setno)
1509 Size additionalsize;
1528 perhash->
aggnode->grpCollations,
1574 find_cols(aggstate, &aggregated_colnos, &base_colnos);
1579 for (
int i = 0;
i < scanDesc->
natts;
i++)
1589 for (
j = 0;
j < numHashes; ++
j)
1676 perhash->
aggnode->grpOperators,
1696 Size tupleChunkSize;
1697 Size pergroupChunkSize;
1698 Size transitionChunkSize;
1705 if (pergroupSize > 0)
1706 pergroupChunkSize =
CHUNKHDRSZ + pergroupSize;
1708 pergroupChunkSize = 0;
1710 if (transitionSpace > 0)
1711 transitionChunkSize =
CHUNKHDRSZ + transitionSpace;
1713 transitionChunkSize = 0;
1719 transitionChunkSize;
1744 int i = minslot ? 1 : 0;
1745 int j = nullcheck ? 1 : 0;
1751 phase = &aggstate->
phases[0];
1753 phase = &aggstate->
phases[1];
1760 bool dosort =
false;
1799 Size *mem_limit, uint64 *ngroups_limit,
1800 int *num_partitions)
1807 if (input_groups * hashentrysize <= hash_mem_limit)
1809 if (num_partitions != NULL)
1810 *num_partitions = 0;
1811 *mem_limit = hash_mem_limit;
1812 *ngroups_limit = hash_mem_limit / hashentrysize;
1825 if (num_partitions != NULL)
1826 *num_partitions = npartitions;
1837 if (hash_mem_limit > 4 * partition_mem)
1838 *mem_limit = hash_mem_limit - partition_mem;
1840 *mem_limit = hash_mem_limit * 0.75;
1842 if (*mem_limit > hashentrysize)
1843 *ngroups_limit = *mem_limit / hashentrysize;
1898 for (
int setno = 0; setno < aggstate->
num_hashes; setno++)
1940 total_mem = meta_mem + hashkey_mem + buffer_mem;
1969 long nbuckets = ngroups;
1971 max_nbuckets = memory / hashentrysize;
1979 if (nbuckets > max_nbuckets)
1980 nbuckets = max_nbuckets;
1982 return Max(nbuckets, 1);
1992 int used_bits,
int *log2_npartitions)
1995 double partition_limit;
2012 dpartitions = 1 + (mem_wanted / hash_mem_limit);
2014 if (dpartitions > partition_limit)
2015 dpartitions = partition_limit;
2023 npartitions = (int) dpartitions;
2026 partition_bits =
my_log2(npartitions);
2029 if (partition_bits + used_bits >= 32)
2030 partition_bits = 32 - used_bits;
2032 if (log2_npartitions != NULL)
2033 *log2_npartitions = partition_bits;
2036 npartitions = 1 << partition_bits;
2068 for (transno = 0; transno < aggstate->
numtrans; transno++)
2101 for (setno = 0; setno < aggstate->
num_hashes; setno++)
2139 pergroup[setno] = NULL;
2221 peragg = aggstate->
peragg;
2257 numReset = numGroupingSets;
2266 for (
i = 0;
i < numReset;
i++)
2285 numReset = numGroupingSets;
2376 if (hasGroupingSets)
2469 if (hasGroupingSets)
2521 pergroups[currentSet]);
2600 bool spill_initialized =
false;
2625 for (
int setno = 0; setno < aggstate->
num_hashes; setno++)
2689 if (!spill_initialized)
2695 spill_initialized =
true;
2718 if (spill_initialized)
2750 while (result == NULL)
2787 peragg = aggstate->
peragg;
2815 if (nextset < aggstate->num_hashes)
2895 double input_groups,
double hashentrysize)
2901 used_bits, &partition_bits);
2907 for (
int i = 0;
i < npartitions;
i++)
2910 spill->
shift = 32 - used_bits - partition_bits;
2911 spill->
mask = (npartitions - 1) << spill->
shift;
2914 for (
int i = 0;
i < npartitions;
i++)
2932 int total_written = 0;
2956 spillslot = inputslot;
2973 total_written +=
sizeof(
uint32);
2976 total_written += tuple->
t_len;
2981 return total_written;
2992 int64 input_tuples,
double input_card,
int used_bits)
2996 batch->
setno = setno;
3021 if (nread !=
sizeof(
uint32))
3024 errmsg_internal(
"unexpected EOF for tape %p: requested %zu bytes, read %zu bytes",
3025 tape,
sizeof(
uint32), nread)));
3030 if (nread !=
sizeof(
uint32))
3033 errmsg_internal(
"unexpected EOF for tape %p: requested %zu bytes, read %zu bytes",
3034 tape,
sizeof(
uint32), nread)));
3037 tuple->
t_len = t_len;
3040 (
char *) tuple +
sizeof(
uint32),
3042 if (nread != t_len -
sizeof(
uint32))
3045 errmsg_internal(
"unexpected EOF for tape %p: requested %zu bytes, read %zu bytes",
3046 tape, t_len -
sizeof(
uint32), nread)));
3062 int total_npartitions = 0;
3066 for (setno = 0; setno < aggstate->
num_hashes; setno++)
3096 int used_bits = 32 - spill->
shift;
3140 for (setno = 0; setno < aggstate->
num_hashes; setno++)
3191 int numGroupingSets = 1;
3232 numPhases = (use_hashing ? 1 : 2);
3233 numHashes = (use_hashing ? 1 : 0);
3244 foreach(l, node->
chain)
3248 numGroupingSets =
Max(numGroupingSets,
3262 aggstate->
maxsets = numGroupingSets;
3285 for (
i = 0;
i < numGroupingSets; ++
i)
3375 foreach(l, aggstate->
aggs)
3379 max_aggno =
Max(max_aggno, aggref->aggno);
3380 max_transno =
Max(max_transno, aggref->aggtransno);
3382 numaggs = max_aggno + 1;
3383 numtrans = max_transno + 1;
3417 Assert(phase <= 1 || sortnode);
3466 for (
j = 0;
j < current_length; ++
j)
3499 for (
int k = 0; k < phasedata->
numsets; k++)
3515 aggnode->grpOperators,
3516 aggnode->grpCollations,
3528 aggnode->grpOperators,
3529 aggnode->grpCollations,
3558 aggstate->
peragg = peraggs;
3559 aggstate->
pertrans = pertransstates;
3564 * (numGroupingSets + numHashes));
3569 for (
i = 0;
i < numGroupingSets;
i++)
3576 pergroups += numGroupingSets;
3585 uint64 totalGroups = 0;
3588 "HashAgg meta context",
3608 for (
int k = 0; k < aggstate->
num_hashes; k++)
3650 foreach(l, aggstate->
aggs)
3656 int numAggTransFnArgs;
3669 Assert(aggref->agglevelsup == 0);
3673 peragg = &peraggs[aggref->aggno];
3676 if (peragg->
aggref != NULL)
3680 peragg->
transno = aggref->aggtransno;
3686 elog(
ERROR,
"cache lookup failed for aggregate %u",
3699 aggtranstype = aggref->aggtranstype;
3706 peragg->
finalfn_oid = finalfn_oid = aggform->aggfinalfn;
3715 if (aggtranstype == INTERNALOID)
3728 elog(
ERROR,
"serialfunc not provided for serialization aggregation");
3729 serialfn_oid = aggform->aggserialfn;
3739 elog(
ERROR,
"deserialfunc not provided for deserialization aggregation");
3740 deserialfn_oid = aggform->aggdeserialfn;
3751 elog(
ERROR,
"cache lookup failed for function %u",
3758 aclresult =
object_aclcheck(ProcedureRelationId, finalfn_oid, aggOwner,
3767 aclresult =
object_aclcheck(ProcedureRelationId, serialfn_oid, aggOwner,
3776 aclresult =
object_aclcheck(ProcedureRelationId, deserialfn_oid, aggOwner,
3791 aggTransFnInputTypes);
3797 if (aggform->aggfinalextra)
3816 aggref->inputcollid,
3832 pertrans = &pertransstates[aggref->aggtransno];
3833 if (pertrans->
aggref == NULL)
3837 bool initValueIsNull;
3847 transfn_oid = aggform->aggcombinefn;
3851 elog(
ERROR,
"combinefn not set for aggregate function");
3854 transfn_oid = aggform->aggtransfn;
3867 Anum_pg_aggregate_agginitval,
3869 if (initValueIsNull)
3876 Oid combineFnInputTypes[] = {aggtranstype,
3888 aggref, transfn_oid, aggtranstype,
3889 serialfn_oid, deserialfn_oid,
3891 combineFnInputTypes, 2);
3901 (
errcode(ERRCODE_INVALID_FUNCTION_DEFINITION),
3902 errmsg(
"combine function with transition type %s must not be declared STRICT",
3908 if (AGGKIND_IS_ORDERED_SET(aggref->aggkind))
3914 aggref, transfn_oid, aggtranstype,
3915 serialfn_oid, deserialfn_oid,
3917 aggTransFnInputTypes,
3931 if (numAggTransFnArgs <= numDirectArgs ||
3935 (
errcode(ERRCODE_INVALID_FUNCTION_DEFINITION),
3936 errmsg(
"aggregate %u needs to have compatible input type and transition type",
3965 (
errcode(ERRCODE_GROUPING_ERROR),
3966 errmsg(
"aggregate function calls cannot be nested")));
3975 for (phaseidx = 0; phaseidx < aggstate->
numphases; phaseidx++)
3978 bool dohash =
false;
3979 bool dosort =
false;
4041 Oid transfn_oid,
Oid aggtranstype,
4042 Oid aggserialfn,
Oid aggdeserialfn,
4044 Oid *inputTypes,
int numArguments)
4046 int numGroupingSets =
Max(aggstate->
maxsets, 1);
4049 Expr *serialfnexpr = NULL;
4050 Expr *deserialfnexpr = NULL;
4056 int numDistinctCols;
4060 pertrans->
aggref = aggref;
4087 aggref->aggvariadic,
4089 aggref->inputcollid,
4104 (
void *) aggstate, NULL);
4124 (
void *) aggstate, NULL);
4140 (
void *) aggstate, NULL);
4158 if (AGGKIND_IS_ORDERED_SET(aggref->aggkind))
4161 numSortCols = numDistinctCols = 0;
4167 numSortCols = numDistinctCols = 0;
4173 numSortCols = numDistinctCols =
list_length(sortlist);
4181 numDistinctCols = 0;
4193 if (numSortCols > 0 || aggref->
aggfilter)
4201 if (numSortCols > 0)
4219 else if (numDistinctCols > 0)
4235 (
bool *)
palloc(numSortCols *
sizeof(
bool));
4238 foreach(lc, sortlist)
4259 Assert(numArguments > 0);
4262 ops =
palloc(numDistinctCols *
sizeof(
Oid));
4269 if (numDistinctCols == 1)
4320 Assert(ParallelWorkerNumber <= node->shared_info->num_workers);
4342 for (transno = 0; transno < node->
numtrans; transno++)
4346 for (setno = 0; setno < numGroupingSets; setno++)
4354 for (setno = 0; setno < numGroupingSets; setno++)
4404 for (transno = 0; transno < node->
numtrans; transno++)
4406 for (setno = 0; setno < numGroupingSets; setno++)
4426 for (setno = 0; setno < numGroupingSets; setno++)
4470 for (setno = 0; setno < numGroupingSets; setno++)
4567 return curperagg->aggref;
4573 return curpertrans->
aggref;
4667 elog(
ERROR,
"aggregate function cannot register a callback in this context");
void aclcheck_error(AclResult aclerr, ObjectType objtype, const char *objectname)
AclResult object_aclcheck(Oid classid, Oid objectid, Oid roleid, AclMode mode)
int bms_next_member(const Bitmapset *a, int prevbit)
void bms_free(Bitmapset *a)
int bms_num_members(const Bitmapset *a)
bool bms_is_member(int x, const Bitmapset *a)
Bitmapset * bms_add_member(Bitmapset *a, int x)
Bitmapset * bms_union(const Bitmapset *a, const Bitmapset *b)
Bitmapset * bms_add_members(Bitmapset *a, const Bitmapset *b)
Bitmapset * bms_del_member(Bitmapset *a, int x)
bool bms_overlap(const Bitmapset *a, const Bitmapset *b)
Bitmapset * bms_copy(const Bitmapset *a)
#define TextDatumGetCString(d)
#define Assert(condition)
#define MemSet(start, val, len)
#define OidIsValid(objectId)
Datum datumCopy(Datum value, bool typByVal, int typLen)
int errmsg_internal(const char *fmt,...)
int errcode_for_file_access(void)
int errcode(int sqlerrcode)
int errmsg(const char *fmt,...)
#define ereport(elevel,...)
void ExecReScan(PlanState *node)
Datum ExecAggCopyTransValue(AggState *aggstate, AggStatePerTrans pertrans, Datum newValue, bool newValueIsNull, Datum oldValue, bool oldValueIsNull)
List * ExecInitExprList(List *nodes, PlanState *parent)
ExprState * ExecBuildAggTrans(AggState *aggstate, AggStatePerPhase phase, bool doSort, bool doHash, bool nullcheck)
ExprState * ExecInitQual(List *qual, PlanState *parent)
void execTuplesHashPrepare(int numCols, const Oid *eqOperators, Oid **eqFuncOids, FmgrInfo **hashFunctions)
TupleHashEntry LookupTupleHashEntryHash(TupleHashTable hashtable, TupleTableSlot *slot, bool *isnew, uint32 hash)
TupleHashEntry LookupTupleHashEntry(TupleHashTable hashtable, TupleTableSlot *slot, bool *isnew, uint32 *hash)
TupleHashTable BuildTupleHashTableExt(PlanState *parent, TupleDesc inputDesc, int numCols, AttrNumber *keyColIdx, const Oid *eqfuncoids, FmgrInfo *hashfunctions, Oid *collations, long nbuckets, Size additionalsize, MemoryContext metacxt, MemoryContext tablecxt, MemoryContext tempcxt, bool use_variable_hash_iv)
void ResetTupleHashTable(TupleHashTable hashtable)
ExprState * execTuplesMatchPrepare(TupleDesc desc, int numCols, const AttrNumber *keyColIdx, const Oid *eqOperators, const Oid *collations, PlanState *parent)
void ExecEndNode(PlanState *node)
PlanState * ExecInitNode(Plan *node, EState *estate, int eflags)
const TupleTableSlotOps TTSOpsVirtual
TupleTableSlot * ExecStoreVirtualTuple(TupleTableSlot *slot)
MinimalTuple ExecFetchSlotMinimalTuple(TupleTableSlot *slot, bool *shouldFree)
TupleTableSlot * ExecStoreAllNullTuple(TupleTableSlot *slot)
TupleTableSlot * ExecStoreMinimalTuple(MinimalTuple mtup, TupleTableSlot *slot, bool shouldFree)
TupleTableSlot * ExecInitExtraTupleSlot(EState *estate, TupleDesc tupledesc, const TupleTableSlotOps *tts_ops)
void ExecInitResultTupleSlotTL(PlanState *planstate, const TupleTableSlotOps *tts_ops)
const TupleTableSlotOps TTSOpsMinimalTuple
TupleDesc ExecTypeFromTL(List *targetList)
TupleTableSlot * ExecAllocTableSlot(List **tupleTable, TupleDesc desc, const TupleTableSlotOps *tts_ops)
void ExecForceStoreHeapTuple(HeapTuple tuple, TupleTableSlot *slot, bool shouldFree)
TupleDesc ExecGetResultType(PlanState *planstate)
void ReScanExprContext(ExprContext *econtext)
ExprContext * CreateWorkExprContext(EState *estate)
const TupleTableSlotOps * ExecGetResultSlotOps(PlanState *planstate, bool *isfixed)
void ExecCreateScanSlotFromOuterPlan(EState *estate, ScanState *scanstate, const TupleTableSlotOps *tts_ops)
void ExecAssignExprContext(EState *estate, PlanState *planstate)
void ExecAssignProjectionInfo(PlanState *planstate, TupleDesc inputDesc)
void RegisterExprContextCallback(ExprContext *econtext, ExprContextCallbackFunction function, Datum arg)
void(* ExprContextCallbackFunction)(Datum arg)
#define InstrCountFiltered1(node, delta)
#define outerPlanState(node)
#define ScanTupleHashTable(htable, iter)
#define ResetTupleHashIterator(htable, iter)
struct AggStatePerGroupData * AggStatePerGroup
struct AggStatePerTransData * AggStatePerTrans
struct TupleHashEntryData TupleHashEntryData
struct AggregateInstrumentation AggregateInstrumentation
struct AggStatePerAggData * AggStatePerAgg
#define EXEC_FLAG_BACKWARD
static TupleTableSlot * ExecProject(ProjectionInfo *projInfo)
#define ResetExprContext(econtext)
static bool ExecQual(ExprState *state, ExprContext *econtext)
static bool ExecQualAndReset(ExprState *state, ExprContext *econtext)
static Datum ExecEvalExpr(ExprState *state, ExprContext *econtext, bool *isNull)
static Datum ExecEvalExprSwitchContext(ExprState *state, ExprContext *econtext, bool *isNull)
#define EXEC_FLAG_EXPLAIN_ONLY
static TupleTableSlot * ExecProcNode(PlanState *node)
#define MakeExpandedObjectReadOnly(d, isnull, typlen)
Datum FunctionCall2Coll(FmgrInfo *flinfo, Oid collation, Datum arg1, Datum arg2)
void fmgr_info(Oid functionId, FmgrInfo *finfo)
Datum OidInputFunctionCall(Oid functionId, char *str, Oid typioparam, int32 typmod)
#define SizeForFunctionCallInfo(nargs)
#define InitFunctionCallInfoData(Fcinfo, Flinfo, Nargs, Collation, Context, Resultinfo)
#define AGG_CONTEXT_WINDOW
#define LOCAL_FCINFO(name, nargs)
#define AGG_CONTEXT_AGGREGATE
struct FunctionCallInfoBaseData * FunctionCallInfo
#define FunctionCallInvoke(fcinfo)
#define fmgr_info_set_expr(expr, finfo)
uint32 hash_bytes_uint32(uint32 k)
void heap_freetuple(HeapTuple htup)
MinimalTupleData * MinimalTuple
#define HeapTupleIsValid(tuple)
#define SizeofMinimalTupleHeader
void initHyperLogLog(hyperLogLogState *cState, uint8 bwidth)
double estimateHyperLogLog(hyperLogLogState *cState)
void addHyperLogLog(hyperLogLogState *cState, uint32 hash)
void freeHyperLogLog(hyperLogLogState *cState)
#define IsParallelWorker()
if(TABLE==NULL||TABLE_index==NULL)
List * lcons_int(int datum, List *list)
List * lappend(List *list, void *datum)
void list_free(List *list)
void list_free_deep(List *list)
List * list_delete_last(List *list)
LogicalTape * LogicalTapeCreate(LogicalTapeSet *lts)
void LogicalTapeRewindForRead(LogicalTape *lt, size_t buffer_size)
size_t LogicalTapeRead(LogicalTape *lt, void *ptr, size_t size)
int64 LogicalTapeSetBlocks(LogicalTapeSet *lts)
void LogicalTapeClose(LogicalTape *lt)
void LogicalTapeSetClose(LogicalTapeSet *lts)
void LogicalTapeWrite(LogicalTape *lt, const void *ptr, size_t size)
LogicalTapeSet * LogicalTapeSetCreate(bool preallocate, SharedFileSet *fileset, int worker)
void get_typlenbyval(Oid typid, int16 *typlen, bool *typbyval)
RegProcedure get_opcode(Oid opno)
void getTypeInputInfo(Oid type, Oid *typInput, Oid *typIOParam)
char * get_func_name(Oid funcid)
void MemoryContextReset(MemoryContext context)
void pfree(void *pointer)
void * palloc0(Size size)
void * MemoryContextAlloc(MemoryContext context, Size size)
Size MemoryContextMemAllocated(MemoryContext context, bool recurse)
void MemoryContextDelete(MemoryContext context)
#define AllocSetContextCreate
#define ALLOCSET_DEFAULT_SIZES
#define CHECK_FOR_INTERRUPTS()
static void hashagg_finish_initial_spills(AggState *aggstate)
static long hash_choose_num_buckets(double hashentrysize, long ngroups, Size memory)
static void hash_agg_check_limits(AggState *aggstate)
static void initialize_hash_entry(AggState *aggstate, TupleHashTable hashtable, TupleHashEntry entry)
static void find_hash_columns(AggState *aggstate)
static bool agg_refill_hash_table(AggState *aggstate)
static void build_hash_table(AggState *aggstate, int setno, long nbuckets)
void ExecAggEstimate(AggState *node, ParallelContext *pcxt)
struct FindColsContext FindColsContext
static void hash_agg_enter_spill_mode(AggState *aggstate)
struct HashAggBatch HashAggBatch
static Datum GetAggInitVal(Datum textInitVal, Oid transtype)
static void find_cols(AggState *aggstate, Bitmapset **aggregated, Bitmapset **unaggregated)
void AggRegisterCallback(FunctionCallInfo fcinfo, ExprContextCallbackFunction func, Datum arg)
#define HASHAGG_HLL_BIT_WIDTH
static void agg_fill_hash_table(AggState *aggstate)
static void initialize_aggregate(AggState *aggstate, AggStatePerTrans pertrans, AggStatePerGroup pergroupstate)
static TupleTableSlot * fetch_input_tuple(AggState *aggstate)
static void hashagg_spill_finish(AggState *aggstate, HashAggSpill *spill, int setno)
static bool find_cols_walker(Node *node, FindColsContext *context)
void ExecAggInitializeWorker(AggState *node, ParallelWorkerContext *pwcxt)
AggState * ExecInitAgg(Agg *node, EState *estate, int eflags)
void ExecAggRetrieveInstrumentation(AggState *node)
static TupleTableSlot * ExecAgg(PlanState *pstate)
static TupleTableSlot * project_aggregates(AggState *aggstate)
static MinimalTuple hashagg_batch_read(HashAggBatch *batch, uint32 *hashp)
struct HashAggSpill HashAggSpill
static void process_ordered_aggregate_multi(AggState *aggstate, AggStatePerTrans pertrans, AggStatePerGroup pergroupstate)
void ExecReScanAgg(AggState *node)
int AggCheckCallContext(FunctionCallInfo fcinfo, MemoryContext *aggcontext)
static void advance_transition_function(AggState *aggstate, AggStatePerTrans pertrans, AggStatePerGroup pergroupstate)
static void hash_agg_update_metrics(AggState *aggstate, bool from_tape, int npartitions)
static void finalize_aggregates(AggState *aggstate, AggStatePerAgg peraggs, AggStatePerGroup pergroup)
static void initialize_phase(AggState *aggstate, int newphase)
Size hash_agg_entry_size(int numTrans, Size tupleWidth, Size transitionSpace)
static void initialize_aggregates(AggState *aggstate, AggStatePerGroup *pergroups, int numReset)
static TupleTableSlot * agg_retrieve_hash_table_in_memory(AggState *aggstate)
void ExecAggInitializeDSM(AggState *node, ParallelContext *pcxt)
static void finalize_aggregate(AggState *aggstate, AggStatePerAgg peragg, AggStatePerGroup pergroupstate, Datum *resultVal, bool *resultIsNull)
#define HASHAGG_MAX_PARTITIONS
static void lookup_hash_entries(AggState *aggstate)
static TupleTableSlot * agg_retrieve_direct(AggState *aggstate)
static void hashagg_recompile_expressions(AggState *aggstate, bool minslot, bool nullcheck)
static void prepare_projection_slot(AggState *aggstate, TupleTableSlot *slot, int currentSet)
bool AggStateIsShared(FunctionCallInfo fcinfo)
static void build_pertrans_for_aggref(AggStatePerTrans pertrans, AggState *aggstate, EState *estate, Aggref *aggref, Oid transfn_oid, Oid aggtranstype, Oid aggserialfn, Oid aggdeserialfn, Datum initValue, bool initValueIsNull, Oid *inputTypes, int numArguments)
Aggref * AggGetAggref(FunctionCallInfo fcinfo)
static TupleTableSlot * agg_retrieve_hash_table(AggState *aggstate)
static void process_ordered_aggregate_single(AggState *aggstate, AggStatePerTrans pertrans, AggStatePerGroup pergroupstate)
static void advance_aggregates(AggState *aggstate)
static void prepare_hash_slot(AggStatePerHash perhash, TupleTableSlot *inputslot, TupleTableSlot *hashslot)
static void build_hash_tables(AggState *aggstate)
void ExecEndAgg(AggState *node)
#define HASHAGG_READ_BUFFER_SIZE
static void hashagg_reset_spill_state(AggState *aggstate)
static Size hashagg_spill_tuple(AggState *aggstate, HashAggSpill *spill, TupleTableSlot *inputslot, uint32 hash)
static void select_current_set(AggState *aggstate, int setno, bool is_hash)
static void finalize_partialaggregate(AggState *aggstate, AggStatePerAgg peragg, AggStatePerGroup pergroupstate, Datum *resultVal, bool *resultIsNull)
static void hashagg_spill_init(HashAggSpill *spill, LogicalTapeSet *tapeset, int used_bits, double input_groups, double hashentrysize)
#define HASHAGG_MIN_PARTITIONS
void hash_agg_set_limits(double hashentrysize, double input_groups, int used_bits, Size *mem_limit, uint64 *ngroups_limit, int *num_partitions)
MemoryContext AggGetTempMemoryContext(FunctionCallInfo fcinfo)
#define HASHAGG_PARTITION_FACTOR
static HashAggBatch * hashagg_batch_new(LogicalTape *input_tape, int setno, int64 input_tuples, double input_card, int used_bits)
#define HASHAGG_WRITE_BUFFER_SIZE
static int hash_choose_num_partitions(double input_groups, double hashentrysize, int used_bits, int *log2_npartitions)
struct AggStatePerGroupData AggStatePerGroupData
Oid exprCollation(const Node *expr)
#define expression_tree_walker(n, w, c)
size_t get_hash_memory_limit(void)
#define DO_AGGSPLIT_SKIPFINAL(as)
#define IsA(nodeptr, _type_)
#define DO_AGGSPLIT_DESERIALIZE(as)
#define DO_AGGSPLIT_COMBINE(as)
#define DO_AGGSPLIT_SERIALIZE(as)
#define castNode(_type_, nodeptr)
#define InvokeFunctionExecuteHook(objectId)
void build_aggregate_finalfn_expr(Oid *agg_input_types, int num_finalfn_inputs, Oid agg_state_type, Oid agg_result_type, Oid agg_input_collation, Oid finalfn_oid, Expr **finalfnexpr)
void build_aggregate_deserialfn_expr(Oid deserialfn_oid, Expr **deserialfnexpr)
void build_aggregate_transfn_expr(Oid *agg_input_types, int agg_num_inputs, int agg_num_direct_inputs, bool agg_variadic, Oid agg_state_type, Oid agg_input_collation, Oid transfn_oid, Oid invtransfn_oid, Expr **transfnexpr, Expr **invtransfnexpr)
int get_aggregate_argtypes(Aggref *aggref, Oid *inputTypes)
void build_aggregate_serialfn_expr(Oid serialfn_oid, Expr **serialfnexpr)
bool IsBinaryCoercible(Oid srctype, Oid targettype)
FormData_pg_aggregate * Form_pg_aggregate
FormData_pg_attribute * Form_pg_attribute
static int list_length(const List *l)
static void * list_nth(const List *list, int n)
#define list_nth_node(type, list, n)
FormData_pg_proc * Form_pg_proc
static bool DatumGetBool(Datum X)
static Datum ObjectIdGetDatum(Oid X)
static Pointer DatumGetPointer(Datum X)
MemoryContextSwitchTo(old_ctx)
static unsigned hash(unsigned *uv, int n)
void shm_toc_insert(shm_toc *toc, uint64 key, void *address)
void * shm_toc_allocate(shm_toc *toc, Size nbytes)
void * shm_toc_lookup(shm_toc *toc, uint64 key, bool noError)
#define shm_toc_estimate_chunk(e, sz)
#define shm_toc_estimate_keys(e, cnt)
Size add_size(Size s1, Size s2)
Size mul_size(Size s1, Size s2)
static pg_noinline void Size size
TupleTableSlot * hashslot
TupleHashIterator hashiter
AttrNumber * hashGrpColIdxHash
AttrNumber * hashGrpColIdxInput
Bitmapset ** grouped_cols
ExprState * evaltrans_cache[2][2]
TupleTableSlot * sortslot
Tuplesortstate ** sortstates
TupleTableSlot * uniqslot
FunctionCallInfo deserialfn_fcinfo
FunctionCallInfo serialfn_fcinfo
FunctionCallInfo transfn_fcinfo
MemoryContext hash_metacxt
Tuplesortstate * sort_out
AggStatePerGroup * all_pergroups
AggStatePerGroup * hash_pergroup
int hash_planned_partitions
ExprContext * curaggcontext
AggStatePerTrans curpertrans
AggStatePerTrans pertrans
struct LogicalTapeSet * hash_tapeset
ExprContext * hashcontext
SharedAggInfo * shared_info
uint64 hash_ngroups_limit
AggStatePerGroup * pergroups
uint64 hash_ngroups_current
TupleTableSlot * hash_spill_wslot
struct HashAggSpill * hash_spills
TupleTableSlot * sort_slot
TupleTableSlot * hash_spill_rslot
ExprContext ** aggcontexts
Bitmapset * colnos_needed
MemoryContext es_query_cxt
MemoryContext ecxt_per_tuple_memory
TupleTableSlot * ecxt_innertuple
TupleTableSlot * ecxt_outertuple
NullableDatum args[FLEXIBLE_ARRAY_MEMBER]
hyperLogLogState * hll_card
LogicalTape ** partitions
shm_toc_estimator estimator
Instrumentation * instrument
const TupleTableSlotOps * outerops
ExprContext * ps_ExprContext
ProjectionInfo * ps_ProjInfo
ExecProcNodeMtd ExecProcNode
TupleTableSlot * ss_ScanTupleSlot
AggregateInstrumentation sinstrument[FLEXIBLE_ARRAY_MEMBER]
TupleDesc tts_tupleDescriptor
void ReleaseSysCache(HeapTuple tuple)
HeapTuple SearchSysCache1(int cacheId, Datum key1)
Datum SysCacheGetAttr(int cacheId, HeapTuple tup, AttrNumber attributeNumber, bool *isNull)
TargetEntry * get_sortgroupclause_tle(SortGroupClause *sgClause, List *targetList)
#define TupleDescAttr(tupdesc, i)
void tuplesort_performsort(Tuplesortstate *state)
void tuplesort_end(Tuplesortstate *state)
void tuplesort_puttupleslot(Tuplesortstate *state, TupleTableSlot *slot)
Tuplesortstate * tuplesort_begin_datum(Oid datumType, Oid sortOperator, Oid sortCollation, bool nullsFirstFlag, int workMem, SortCoordinate coordinate, int sortopt)
bool tuplesort_gettupleslot(Tuplesortstate *state, bool forward, bool copy, TupleTableSlot *slot, Datum *abbrev)
bool tuplesort_getdatum(Tuplesortstate *state, bool forward, bool copy, Datum *val, bool *isNull, Datum *abbrev)
Tuplesortstate * tuplesort_begin_heap(TupleDesc tupDesc, int nkeys, AttrNumber *attNums, Oid *sortOperators, Oid *sortCollations, bool *nullsFirstFlags, int workMem, SortCoordinate coordinate, int sortopt)
static TupleTableSlot * ExecClearTuple(TupleTableSlot *slot)
static void slot_getsomeattrs(TupleTableSlot *slot, int attnum)
static HeapTuple ExecCopySlotHeapTuple(TupleTableSlot *slot)
static void slot_getallattrs(TupleTableSlot *slot)