297#define HASHAGG_PARTITION_FACTOR 1.50
298#define HASHAGG_MIN_PARTITIONS 4
299#define HASHAGG_MAX_PARTITIONS 1024
307#define HASHAGG_READ_BUFFER_SIZE BLCKSZ
308#define HASHAGG_WRITE_BUFFER_SIZE BLCKSZ
316#define HASHAGG_HLL_BIT_WIDTH 5
321#define CHUNKHDRSZ sizeof(MemoryChunk)
387 Datum *resultVal,
bool *resultIsNull);
391 Datum *resultVal,
bool *resultIsNull);
410 long ngroups,
Size memory);
412 double hashentrysize,
414 int *log2_npartitions);
431 int64 input_tuples,
double input_card,
435 int used_bits,
double input_groups,
436 double hashentrysize);
445 Oid aggtranstype,
Oid aggserialfn,
447 bool initValueIsNull,
Oid *inputTypes,
480 Assert(newphase <= 1 || newphase == aggstate->current_phase + 1);
519 if (newphase > 0 && newphase < aggstate->numphases - 1)
527 sortnode->sortColIdx,
528 sortnode->sortOperators,
529 sortnode->collations,
530 sortnode->nullsFirst,
677 numReset = numGroupingSets;
679 for (setno = 0; setno < numReset; setno++)
685 for (transno = 0; transno < numTrans; transno++)
724 for (
i = 1;
i <= numTransInputs;
i++)
854 bool oldIsNull =
true;
855 bool haveOldVal =
false;
880 true,
false, newVal, isNull, &newAbbrevVal))
894 ((oldIsNull && *isNull) ||
895 (!oldIsNull && !*isNull &&
896 oldAbbrevVal == newAbbrevVal &&
924 oldAbbrevVal = newAbbrevVal;
962 bool haveOldValue =
false;
973 true,
true, slot1, &newAbbrevVal))
980 if (numDistinctCols == 0 ||
982 newAbbrevVal != oldAbbrevVal ||
993 for (
i = 0;
i < numTransInputs;
i++)
1001 if (numDistinctCols > 0)
1009 oldAbbrevVal = newAbbrevVal;
1010 haveOldValue =
true;
1050 Datum *resultVal,
bool *resultIsNull)
1053 bool anynull =
false;
1074 &fcinfo->args[
i].isnull);
1075 anynull |= fcinfo->args[
i].isnull;
1092 (
Node *) aggstate, NULL);
1095 fcinfo->args[0].value =
1103 for (;
i < numFinalArgs;
i++)
1105 fcinfo->args[
i].value = (
Datum) 0;
1106 fcinfo->args[
i].isnull =
true;
1110 if (fcinfo->flinfo->fn_strict && anynull)
1113 *resultVal = (
Datum) 0;
1114 *resultIsNull =
true;
1121 *resultIsNull = fcinfo->isnull;
1126 aggstate->curperagg = NULL;
1150 Datum *resultVal,
bool *resultIsNull)
1166 *resultVal = (
Datum) 0;
1167 *resultIsNull =
true;
1182 *resultIsNull = fcinfo->
isnull;
1308 for (
int transno = 0; transno < aggstate->
numtrans; transno++)
1313 pergroupstate = &pergroup[transno];
1349 for (aggno = 0; aggno < aggstate->
numaggs; aggno++)
1352 int transno = peragg->
transno;
1355 pergroupstate = &pergroup[transno];
1359 &aggvalues[aggno], &aggnulls[aggno]);
1362 &aggvalues[aggno], &aggnulls[aggno]);
1404 context.aggregated = NULL;
1405 context.unaggregated = NULL;
1416 *aggregated = context.aggregated;
1417 *unaggregated = context.unaggregated;
1472 for (setno = 0; setno < aggstate->
num_hashes; ++setno)
1493#ifdef USE_INJECTION_POINTS
1517 Size additionalsize;
1537 perhash->
aggnode->grpCollations,
1583 find_cols(aggstate, &aggregated_colnos, &base_colnos);
1588 for (
int i = 0;
i < scanDesc->
natts;
i++)
1598 for (
j = 0;
j < numHashes; ++
j)
1685 perhash->
aggnode->grpOperators,
1705 Size tupleChunkSize;
1706 Size pergroupChunkSize;
1707 Size transitionChunkSize;
1714 if (pergroupSize > 0)
1715 pergroupChunkSize =
CHUNKHDRSZ + pergroupSize;
1717 pergroupChunkSize = 0;
1719 if (transitionSpace > 0)
1720 transitionChunkSize =
CHUNKHDRSZ + transitionSpace;
1722 transitionChunkSize = 0;
1728 transitionChunkSize;
1753 int i = minslot ? 1 : 0;
1754 int j = nullcheck ? 1 : 0;
1760 phase = &aggstate->
phases[0];
1762 phase = &aggstate->
phases[1];
1769 bool dosort =
false;
1809 int *num_partitions)
1816 if (input_groups * hashentrysize <= hash_mem_limit)
1818 if (num_partitions != NULL)
1819 *num_partitions = 0;
1820 *mem_limit = hash_mem_limit;
1821 *ngroups_limit = hash_mem_limit / hashentrysize;
1834 if (num_partitions != NULL)
1835 *num_partitions = npartitions;
1846 if (hash_mem_limit > 4 * partition_mem)
1847 *mem_limit = hash_mem_limit - partition_mem;
1849 *mem_limit = hash_mem_limit * 0.75;
1851 if (*mem_limit > hashentrysize)
1852 *ngroups_limit = *mem_limit / hashentrysize;
1872 bool do_spill =
false;
1874#ifdef USE_INJECTION_POINTS
1875 if (ngroups >= 1000)
1923 for (
int setno = 0; setno < aggstate->
num_hashes; setno++)
1965 total_mem = meta_mem + hashkey_mem + buffer_mem;
1994 long nbuckets = ngroups;
1996 max_nbuckets = memory / hashentrysize;
2004 if (nbuckets > max_nbuckets)
2005 nbuckets = max_nbuckets;
2007 return Max(nbuckets, 1);
2017 int used_bits,
int *log2_npartitions)
2020 double partition_limit;
2037 dpartitions = 1 + (mem_wanted / hash_mem_limit);
2039 if (dpartitions > partition_limit)
2040 dpartitions = partition_limit;
2048 npartitions = (int) dpartitions;
2051 partition_bits =
my_log2(npartitions);
2054 if (partition_bits + used_bits >= 32)
2055 partition_bits = 32 - used_bits;
2057 if (log2_npartitions != NULL)
2058 *log2_npartitions = partition_bits;
2061 npartitions = 1 << partition_bits;
2093 for (transno = 0; transno < aggstate->
numtrans; transno++)
2126 for (setno = 0; setno < aggstate->
num_hashes; setno++)
2164 pergroup[setno] = NULL;
2246 peragg = aggstate->
peragg;
2282 numReset = numGroupingSets;
2291 for (
i = 0;
i < numReset;
i++)
2310 numReset = numGroupingSets;
2401 if (hasGroupingSets)
2494 if (hasGroupingSets)
2546 pergroups[currentSet]);
2625 bool spill_initialized =
false;
2650 for (
int setno = 0; setno < aggstate->
num_hashes; setno++)
2715 if (!spill_initialized)
2721 spill_initialized =
true;
2744 if (spill_initialized)
2776 while (result == NULL)
2813 peragg = aggstate->
peragg;
2841 if (nextset < aggstate->num_hashes)
2921 double input_groups,
double hashentrysize)
2927 used_bits, &partition_bits);
2929#ifdef USE_INJECTION_POINTS
2942 for (
int i = 0;
i < npartitions;
i++)
2945 spill->
shift = 32 - used_bits - partition_bits;
2946 if (spill->
shift < 32)
2947 spill->
mask = (npartitions - 1) << spill->
shift;
2952 for (
int i = 0;
i < npartitions;
i++)
2970 int total_written = 0;
2994 spillslot = inputslot;
2998 if (spill->
shift < 32)
3015 total_written +=
sizeof(
uint32);
3018 total_written += tuple->
t_len;
3023 return total_written;
3034 int64 input_tuples,
double input_card,
int used_bits)
3038 batch->
setno = setno;
3063 if (nread !=
sizeof(
uint32))
3066 errmsg_internal(
"unexpected EOF for tape %p: requested %zu bytes, read %zu bytes",
3067 tape,
sizeof(
uint32), nread)));
3072 if (nread !=
sizeof(
uint32))
3075 errmsg_internal(
"unexpected EOF for tape %p: requested %zu bytes, read %zu bytes",
3076 tape,
sizeof(
uint32), nread)));
3079 tuple->
t_len = t_len;
3082 (
char *) tuple +
sizeof(
uint32),
3084 if (nread != t_len -
sizeof(
uint32))
3087 errmsg_internal(
"unexpected EOF for tape %p: requested %zu bytes, read %zu bytes",
3088 tape, t_len -
sizeof(
uint32), nread)));
3104 int total_npartitions = 0;
3108 for (setno = 0; setno < aggstate->
num_hashes; setno++)
3138 int used_bits = 32 - spill->
shift;
3182 for (setno = 0; setno < aggstate->
num_hashes; setno++)
3233 int numGroupingSets = 1;
3274 numPhases = (use_hashing ? 1 : 2);
3275 numHashes = (use_hashing ? 1 : 0);
3286 foreach(l, node->
chain)
3290 numGroupingSets =
Max(numGroupingSets,
3304 aggstate->
maxsets = numGroupingSets;
3327 for (
i = 0;
i < numGroupingSets; ++
i)
3345 eflags &= ~EXEC_FLAG_REWIND;
3417 foreach(l, aggstate->
aggs)
3421 max_aggno =
Max(max_aggno, aggref->aggno);
3422 max_transno =
Max(max_transno, aggref->aggtransno);
3424 aggstate->
numaggs = numaggs = max_aggno + 1;
3425 aggstate->
numtrans = numtrans = max_transno + 1;
3459 Assert(phase <= 1 || sortnode);
3508 for (
j = 0;
j < current_length; ++
j)
3541 for (
int k = 0; k < phasedata->
numsets; k++)
3557 aggnode->grpOperators,
3558 aggnode->grpCollations,
3570 aggnode->grpOperators,
3571 aggnode->grpCollations,
3600 aggstate->
peragg = peraggs;
3601 aggstate->
pertrans = pertransstates;
3606 * (numGroupingSets + numHashes));
3611 for (
i = 0;
i < numGroupingSets;
i++)
3618 pergroups += numGroupingSets;
3630 "HashAgg meta context",
3650 for (
int k = 0; k < aggstate->
num_hashes; k++)
3692 foreach(l, aggstate->
aggs)
3698 int numAggTransFnArgs;
3711 Assert(aggref->agglevelsup == 0);
3715 peragg = &peraggs[aggref->aggno];
3718 if (peragg->
aggref != NULL)
3722 peragg->
transno = aggref->aggtransno;
3728 elog(
ERROR,
"cache lookup failed for aggregate %u",
3741 aggtranstype = aggref->aggtranstype;
3748 peragg->
finalfn_oid = finalfn_oid = aggform->aggfinalfn;
3757 if (aggtranstype == INTERNALOID)
3770 elog(
ERROR,
"serialfunc not provided for serialization aggregation");
3771 serialfn_oid = aggform->aggserialfn;
3781 elog(
ERROR,
"deserialfunc not provided for deserialization aggregation");
3782 deserialfn_oid = aggform->aggdeserialfn;
3793 elog(
ERROR,
"cache lookup failed for function %u",
3800 aclresult =
object_aclcheck(ProcedureRelationId, finalfn_oid, aggOwner,
3809 aclresult =
object_aclcheck(ProcedureRelationId, serialfn_oid, aggOwner,
3818 aclresult =
object_aclcheck(ProcedureRelationId, deserialfn_oid, aggOwner,
3833 aggTransFnInputTypes);
3839 if (aggform->aggfinalextra)
3858 aggref->inputcollid,
3874 pertrans = &pertransstates[aggref->aggtransno];
3875 if (pertrans->
aggref == NULL)
3879 bool initValueIsNull;
3889 transfn_oid = aggform->aggcombinefn;
3893 elog(
ERROR,
"combinefn not set for aggregate function");
3896 transfn_oid = aggform->aggtransfn;
3909 Anum_pg_aggregate_agginitval,
3911 if (initValueIsNull)
3918 Oid combineFnInputTypes[] = {aggtranstype,
3930 aggref, transfn_oid, aggtranstype,
3931 serialfn_oid, deserialfn_oid,
3933 combineFnInputTypes, 2);
3943 (
errcode(ERRCODE_INVALID_FUNCTION_DEFINITION),
3944 errmsg(
"combine function with transition type %s must not be declared STRICT",
3950 if (AGGKIND_IS_ORDERED_SET(aggref->aggkind))
3956 aggref, transfn_oid, aggtranstype,
3957 serialfn_oid, deserialfn_oid,
3959 aggTransFnInputTypes,
3973 if (numAggTransFnArgs <= numDirectArgs ||
3977 (
errcode(ERRCODE_INVALID_FUNCTION_DEFINITION),
3978 errmsg(
"aggregate %u needs to have compatible input type and transition type",
4000 (
errcode(ERRCODE_GROUPING_ERROR),
4001 errmsg(
"aggregate function calls cannot be nested")));
4010 for (phaseidx = 0; phaseidx < aggstate->
numphases; phaseidx++)
4013 bool dohash =
false;
4014 bool dosort =
false;
4076 Oid transfn_oid,
Oid aggtranstype,
4077 Oid aggserialfn,
Oid aggdeserialfn,
4079 Oid *inputTypes,
int numArguments)
4081 int numGroupingSets =
Max(aggstate->
maxsets, 1);
4084 Expr *serialfnexpr = NULL;
4085 Expr *deserialfnexpr = NULL;
4091 int numDistinctCols;
4095 pertrans->
aggref = aggref;
4122 aggref->aggvariadic,
4124 aggref->inputcollid,
4139 (
Node *) aggstate, NULL);
4159 (
Node *) aggstate, NULL);
4175 (
Node *) aggstate, NULL);
4193 if (AGGKIND_IS_ORDERED_SET(aggref->aggkind))
4196 numSortCols = numDistinctCols = 0;
4202 numSortCols = numDistinctCols = 0;
4208 numSortCols = numDistinctCols =
list_length(sortlist);
4216 numDistinctCols = 0;
4228 if (numSortCols > 0 || aggref->
aggfilter)
4236 if (numSortCols > 0)
4254 else if (numDistinctCols > 0)
4270 (
bool *)
palloc(numSortCols *
sizeof(
bool));
4273 foreach(lc, sortlist)
4294 Assert(numArguments > 0);
4297 ops =
palloc(numDistinctCols *
sizeof(
Oid));
4304 if (numDistinctCols == 1)
4355 Assert(ParallelWorkerNumber <= node->shared_info->num_workers);
4377 for (transno = 0; transno < node->
numtrans; transno++)
4381 for (setno = 0; setno < numGroupingSets; setno++)
4389 for (setno = 0; setno < numGroupingSets; setno++)
4439 for (transno = 0; transno < node->
numtrans; transno++)
4441 for (setno = 0; setno < numGroupingSets; setno++)
4461 for (setno = 0; setno < numGroupingSets; setno++)
4505 for (setno = 0; setno < numGroupingSets; setno++)
4602 return curperagg->aggref;
4608 return curpertrans->
aggref;
4702 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)
Bitmapset * bms_del_member(Bitmapset *a, int x)
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_add_members(Bitmapset *a, const Bitmapset *b)
Bitmapset * bms_union(const Bitmapset *a, const Bitmapset *b)
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)
ExprState * ExecInitQual(List *qual, PlanState *parent)
List * ExecInitExprList(List *nodes, PlanState *parent)
ExprState * ExecBuildAggTrans(AggState *aggstate, AggStatePerPhase phase, bool doSort, bool doHash, bool nullcheck)
ExprState * execTuplesMatchPrepare(TupleDesc desc, int numCols, const AttrNumber *keyColIdx, const Oid *eqOperators, const Oid *collations, 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 BuildTupleHashTable(PlanState *parent, TupleDesc inputDesc, const TupleTableSlotOps *inputOps, 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)
void ExecEndNode(PlanState *node)
PlanState * ExecInitNode(Plan *node, EState *estate, int eflags)
const TupleTableSlotOps TTSOpsVirtual
TupleTableSlot * ExecStoreVirtualTuple(TupleTableSlot *slot)
TupleTableSlot * ExecAllocTableSlot(List **tupleTable, TupleDesc desc, const TupleTableSlotOps *tts_ops)
MinimalTuple ExecFetchSlotMinimalTuple(TupleTableSlot *slot, bool *shouldFree)
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
TupleTableSlot * ExecStoreAllNullTuple(TupleTableSlot *slot)
TupleDesc ExecTypeFromTL(List *targetList)
void ExecForceStoreHeapTuple(HeapTuple tuple, TupleTableSlot *slot, bool shouldFree)
TupleDesc ExecGetResultType(PlanState *planstate)
void ReScanExprContext(ExprContext *econtext)
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)
ExprContext * CreateWorkExprContext(EState *estate)
const TupleTableSlotOps * ExecGetResultSlotOps(PlanState *planstate, bool *isfixed)
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 TupleTableSlot * ExecProcNode(PlanState *node)
static Datum ExecEvalExpr(ExprState *state, ExprContext *econtext, bool *isNull)
static Datum ExecEvalExprSwitchContext(ExprState *state, ExprContext *econtext, bool *isNull)
#define EXEC_FLAG_EXPLAIN_ONLY
#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
static void * GETSTRUCT(const HeapTupleData *tuple)
void initHyperLogLog(hyperLogLogState *cState, uint8 bwidth)
double estimateHyperLogLog(hyperLogLogState *cState)
void addHyperLogLog(hyperLogLogState *cState, uint32 hash)
void freeHyperLogLog(hyperLogLogState *cState)
#define IsParallelWorker()
#define INJECTION_POINT(name)
#define INJECTION_POINT_CACHED(name)
#define IS_INJECTION_POINT_ATTACHED(name)
if(TABLE==NULL||TABLE_index==NULL)
List * lappend(List *list, void *datum)
List * lcons_int(int datum, List *list)
List * list_delete_last(List *list)
void list_free(List *list)
void list_free_deep(List *list)
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)
LogicalTapeSet * LogicalTapeSetCreate(bool preallocate, SharedFileSet *fileset, int worker)
void LogicalTapeWrite(LogicalTape *lt, const void *ptr, size_t size)
LogicalTape * LogicalTapeCreate(LogicalTapeSet *lts)
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 * MemoryContextAlloc(MemoryContext context, Size size)
void MemoryContextReset(MemoryContext context)
void pfree(void *pointer)
void * palloc0(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)
Aggref * AggGetAggref(FunctionCallInfo fcinfo)
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)
void ExecAggRetrieveInstrumentation(AggState *node)
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)
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 TupleTableSlot * ExecAgg(PlanState *pstate)
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)
AggState * ExecInitAgg(Agg *node, EState *estate, int eflags)
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)
static MemoryContext MemoryContextSwitchTo(MemoryContext context)
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)
static unsigned hash(unsigned *uv, int n)
void * shm_toc_allocate(shm_toc *toc, Size nbytes)
void shm_toc_insert(shm_toc *toc, uint64 key, void *address)
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)