execGrouping.c File Reference

#include "postgres.h"
#include <math.h>
#include "access/htup_details.h"
#include "access/parallel.h"
#include "common/hashfn.h"
#include "executor/executor.h"
#include "miscadmin.h"
#include "utils/lsyscache.h"
#include "lib/simplehash.h"

Include dependency graph for execGrouping.c:

Go to the source code of this file.

Macros
#define	SH_PREFIX   tuplehash
#define	SH_ELEMENT_TYPE   TupleHashEntryData
#define	SH_KEY_TYPE   MinimalTuple
#define	SH_KEY   firstTuple
#define	SH_HASH_KEY(tb, key)   TupleHashTableHash_internal(tb, key)
#define	SH_EQUAL(tb, a, b)   TupleHashTableMatch(tb, a, b) == 0
#define	SH_SCOPE   extern
#define	SH_STORE_HASH
#define	SH_GET_HASH(tb, a)   a->hash
#define	SH_DEFINE

Functions
static int	TupleHashTableMatch (struct tuplehash_hash *tb, MinimalTuple tuple1, MinimalTuple tuple2)
static uint32	TupleHashTableHash_internal (struct tuplehash_hash *tb, MinimalTuple tuple)
static TupleHashEntry	LookupTupleHashEntry_internal (TupleHashTable hashtable, TupleTableSlot *slot, bool *isnew, uint32 hash)
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)
TupleHashTable	BuildTupleHashTable (PlanState *parent, TupleDesc inputDesc, const TupleTableSlotOps *inputOps, int numCols, AttrNumber *keyColIdx, const Oid *eqfuncoids, FmgrInfo *hashfunctions, Oid *collations, double nelements, Size additionalsize, MemoryContext metacxt, MemoryContext tuplescxt, MemoryContext tempcxt, bool use_variable_hash_iv)
void	ResetTupleHashTable (TupleHashTable hashtable)
Size	EstimateTupleHashTableSpace (double nentries, Size tupleWidth, Size additionalsize)
TupleHashEntry	LookupTupleHashEntry (TupleHashTable hashtable, TupleTableSlot *slot, bool *isnew, uint32 *hash)
uint32	TupleHashTableHash (TupleHashTable hashtable, TupleTableSlot *slot)
TupleHashEntry	LookupTupleHashEntryHash (TupleHashTable hashtable, TupleTableSlot *slot, bool *isnew, uint32 hash)
TupleHashEntry	FindTupleHashEntry (TupleHashTable hashtable, TupleTableSlot *slot, ExprState *eqcomp, ExprState *hashexpr)

Macro Definition Documentation

SH_DEFINE

#define SH_DEFINE

Definition at line 47 of file execGrouping.c.

SH_ELEMENT_TYPE

#define SH_ELEMENT_TYPE   TupleHashEntryData

Definition at line 39 of file execGrouping.c.

SH_EQUAL

#define SH_EQUAL	(		tb,
			a,
			b
	)		TupleHashTableMatch(tb, a, b) == 0

Definition at line 43 of file execGrouping.c.

SH_GET_HASH

#define SH_GET_HASH	(		tb,
			a
	)		a->hash

Definition at line 46 of file execGrouping.c.

SH_HASH_KEY

#define SH_HASH_KEY	(		tb,
			key
	)		TupleHashTableHash_internal(tb, key)

Definition at line 42 of file execGrouping.c.

SH_KEY

#define SH_KEY   firstTuple

Definition at line 41 of file execGrouping.c.

SH_KEY_TYPE

#define SH_KEY_TYPE   MinimalTuple

Definition at line 40 of file execGrouping.c.

SH_PREFIX

#define SH_PREFIX   tuplehash

Definition at line 38 of file execGrouping.c.

SH_SCOPE

#define SH_SCOPE   extern

Definition at line 44 of file execGrouping.c.

SH_STORE_HASH

#define SH_STORE_HASH

Definition at line 45 of file execGrouping.c.

Function Documentation

BuildTupleHashTable()

TupleHashTable BuildTupleHashTable	(	PlanState *	parent,
		TupleDesc	inputDesc,
		const TupleTableSlotOps *	inputOps,
		int	numCols,
		AttrNumber *	keyColIdx,
		const Oid *	eqfuncoids,
		FmgrInfo *	hashfunctions,
		Oid *	collations,
		double	nelements,
		Size	additionalsize,
		MemoryContext	metacxt,
		MemoryContext	tuplescxt,
		MemoryContext	tempcxt,
		bool	use_variable_hash_iv
	)

Definition at line 184 of file execGrouping.c.

{
    TupleHashTable hashtable;
    uint32      nbuckets;
    MemoryContext oldcontext;
    uint32      hash_iv = 0;
 
    /*
     * tuplehash_create requires a uint32 element count, so we had better
     * clamp the given nelements to fit in that.  As long as we have to do
     * that, we might as well protect against completely insane input like
     * zero or NaN.  But it is not our job here to enforce issues like staying
     * within hash_mem: the caller should have done that, and we don't have
     * enough info to second-guess.
     */
    if (isnan(nelements) || nelements <= 0)
        nbuckets = 1;
    else if (nelements >= PG_UINT32_MAX)
        nbuckets = PG_UINT32_MAX;
    else
        nbuckets = (uint32) nelements;
 
    /* tuplescxt must be separate, else ResetTupleHashTable breaks things */
    Assert(metacxt != tuplescxt);
 
    /* ensure additionalsize is maxalign'ed */
    additionalsize = MAXALIGN(additionalsize);
 
    oldcontext = MemoryContextSwitchTo(metacxt);
 
    hashtable = (TupleHashTable) palloc(sizeof(TupleHashTableData));
 
    hashtable->numCols = numCols;
    hashtable->keyColIdx = keyColIdx;
    hashtable->tab_collations = collations;
    hashtable->tuplescxt = tuplescxt;
    hashtable->tempcxt = tempcxt;
    hashtable->additionalsize = additionalsize;
    hashtable->tableslot = NULL;    /* will be made on first lookup */
    hashtable->inputslot = NULL;
    hashtable->in_hash_expr = NULL;
    hashtable->cur_eq_func = NULL;
 
    /*
     * If parallelism is in use, even if the leader backend is performing the
     * scan itself, we don't want to create the hashtable exactly the same way
     * in all workers. As hashtables are iterated over in keyspace-order,
     * doing so in all processes in the same way is likely to lead to
     * "unbalanced" hashtables when the table size initially is
     * underestimated.
     */
    if (use_variable_hash_iv)
        hash_iv = murmurhash32(ParallelWorkerNumber);
 
    hashtable->hashtab = tuplehash_create(metacxt, nbuckets, hashtable);
 
    /*
     * We copy the input tuple descriptor just for safety --- we assume all
     * input tuples will have equivalent descriptors.
     */
    hashtable->tableslot = MakeSingleTupleTableSlot(CreateTupleDescCopy(inputDesc),
                                                    &TTSOpsMinimalTuple);
 
    /* build hash ExprState for all columns */
    hashtable->tab_hash_expr = ExecBuildHash32FromAttrs(inputDesc,
                                                        inputOps,
                                                        hashfunctions,
                                                        collations,
                                                        numCols,
                                                        keyColIdx,
                                                        parent,
                                                        hash_iv);
 
    /* build comparator for all columns */
    hashtable->tab_eq_func = ExecBuildGroupingEqual(inputDesc, inputDesc,
                                                    inputOps,
                                                    &TTSOpsMinimalTuple,
                                                    numCols,
                                                    keyColIdx, eqfuncoids, collations,
                                                    parent);
 
    /*
     * While not pretty, it's ok to not shut down this context, but instead
     * rely on the containing memory context being reset, as
     * ExecBuildGroupingEqual() only builds a very simple expression calling
     * functions (i.e. nothing that'd employ RegisterExprContextCallback()).
     */
    hashtable->exprcontext = CreateStandaloneExprContext();
 
    MemoryContextSwitchTo(oldcontext);
 
    return hashtable;
}

References TupleHashTableData::additionalsize, Assert(), CreateStandaloneExprContext(), CreateTupleDescCopy(), TupleHashTableData::cur_eq_func, ExecBuildGroupingEqual(), ExecBuildHash32FromAttrs(), TupleHashTableData::exprcontext, TupleHashTableData::hashtab, TupleHashTableData::in_hash_expr, TupleHashTableData::inputslot, TupleHashTableData::keyColIdx, MakeSingleTupleTableSlot(), MAXALIGN, MemoryContextSwitchTo(), murmurhash32(), TupleHashTableData::numCols, palloc(), ParallelWorkerNumber, PG_UINT32_MAX, TupleHashTableData::tab_collations, TupleHashTableData::tab_eq_func, TupleHashTableData::tab_hash_expr, TupleHashTableData::tableslot, TupleHashTableData::tempcxt, TTSOpsMinimalTuple, and TupleHashTableData::tuplescxt.

Referenced by build_hash_table(), and buildSubPlanHash().

EstimateTupleHashTableSpace()

Size EstimateTupleHashTableSpace	(	double	nentries,
		Size	tupleWidth,
		Size	additionalsize
	)

Definition at line 321 of file execGrouping.c.

{
    Size        sh_space;
    double      tuples_space;
 
    /* First estimate the space needed for the simplehash table */
    sh_space = tuplehash_estimate_space(nentries);
 
    /* Give up if that's already too big */
    if (sh_space >= SIZE_MAX)
        return sh_space;
 
    /*
     * Compute space needed for hashed tuples with additional data.  nentries
     * must be somewhat sane, so it should be safe to compute this product.
     *
     * We assume that the hashed tuples will be kept in a BumpContext so that
     * there is not additional per-tuple overhead.
     *
     * (Note that this is only accurate if MEMORY_CONTEXT_CHECKING is off,
     * else bump.c will add a MemoryChunk header to each tuple.  However, it
     * seems undesirable for debug builds to make different planning choices
     * than production builds, so we assume the production behavior always.)
     */
    tuples_space = nentries * (MAXALIGN(SizeofMinimalTupleHeader) +
                               MAXALIGN(tupleWidth) +
                               MAXALIGN(additionalsize));
 
    /*
     * Check for size_t overflow.  This coding is trickier than it may appear,
     * because on 64-bit machines SIZE_MAX cannot be represented exactly as a
     * double.  We must cast it explicitly to suppress compiler warnings about
     * an inexact conversion, and we must trust that any double value that
     * compares strictly less than "(double) SIZE_MAX" will cast to a
     * representable size_t value.
     */
    if (sh_space + tuples_space >= (double) SIZE_MAX)
        return SIZE_MAX;
 
    /* We don't bother estimating size of the miscellaneous overhead data */
    return (Size) (sh_space + tuples_space);
}

References MAXALIGN, and SizeofMinimalTupleHeader.

Referenced by EstimateSetOpHashTableSpace(), and EstimateSubplanHashTableSpace().

execTuplesHashPrepare()

void execTuplesHashPrepare	(	int	numCols,
		const Oid *	eqOperators,
		Oid **	eqFuncOids,
		FmgrInfo **	hashFunctions
	)

Definition at line 100 of file execGrouping.c.

{
    int         i;
 
    *eqFuncOids = (Oid *) palloc(numCols * sizeof(Oid));
    *hashFunctions = (FmgrInfo *) palloc(numCols * sizeof(FmgrInfo));
 
    for (i = 0; i < numCols; i++)
    {
        Oid         eq_opr = eqOperators[i];
        Oid         eq_function;
        Oid         left_hash_function;
        Oid         right_hash_function;
 
        eq_function = get_opcode(eq_opr);
        if (!get_op_hash_functions(eq_opr,
                                   &left_hash_function, &right_hash_function))
            elog(ERROR, "could not find hash function for hash operator %u",
                 eq_opr);
        /* We're not supporting cross-type cases here */
        Assert(left_hash_function == right_hash_function);
        (*eqFuncOids)[i] = eq_function;
        fmgr_info(right_hash_function, &(*hashFunctions)[i]);
    }
}

References Assert(), elog, ERROR, fmgr_info(), get_op_hash_functions(), get_opcode(), i, and palloc().

Referenced by ExecInitRecursiveUnion(), ExecInitSetOp(), and find_hash_columns().

execTuplesMatchPrepare()

ExprState * execTuplesMatchPrepare	(	TupleDesc	desc,
		int	numCols,
		const AttrNumber *	keyColIdx,
		const Oid *	eqOperators,
		const Oid *	collations,
		PlanState *	parent
	)

Definition at line 61 of file execGrouping.c.

{
    Oid        *eqFunctions;
    int         i;
    ExprState  *expr;
 
    if (numCols == 0)
        return NULL;
 
    eqFunctions = (Oid *) palloc(numCols * sizeof(Oid));
 
    /* lookup equality functions */
    for (i = 0; i < numCols; i++)
        eqFunctions[i] = get_opcode(eqOperators[i]);
 
    /* build actual expression */
    expr = ExecBuildGroupingEqual(desc, desc, NULL, NULL,
                                  numCols, keyColIdx, eqFunctions, collations,
                                  parent);
 
    return expr;
}

References ExecBuildGroupingEqual(), get_opcode(), i, and palloc().

Referenced by build_pertrans_for_aggref(), ExecInitAgg(), ExecInitGroup(), ExecInitLimit(), ExecInitUnique(), ExecInitWindowAgg(), and hypothetical_dense_rank_final().

FindTupleHashEntry()

TupleHashEntry FindTupleHashEntry	(	TupleHashTable	hashtable,
		TupleTableSlot *	slot,
		ExprState *	eqcomp,
		ExprState *	hashexpr
	)

Definition at line 469 of file execGrouping.c.

{
    TupleHashEntry entry;
    MemoryContext oldContext;
    MinimalTuple key;
 
    /* Need to run the hash functions in short-lived context */
    oldContext = MemoryContextSwitchTo(hashtable->tempcxt);
 
    /* Set up data needed by hash and match functions */
    hashtable->inputslot = slot;
    hashtable->in_hash_expr = hashexpr;
    hashtable->cur_eq_func = eqcomp;
 
    /* Search the hash table */
    key = NULL;                 /* flag to reference inputslot */
    entry = tuplehash_lookup(hashtable->hashtab, key);
    MemoryContextSwitchTo(oldContext);
 
    return entry;
}

References TupleHashTableData::cur_eq_func, TupleHashTableData::hashtab, TupleHashTableData::in_hash_expr, TupleHashTableData::inputslot, sort-test::key, MemoryContextSwitchTo(), and TupleHashTableData::tempcxt.

Referenced by ExecHashSubPlan().

LookupTupleHashEntry()

TupleHashEntry LookupTupleHashEntry	(	TupleHashTable	hashtable,
		TupleTableSlot *	slot,
		bool *	isnew,
		uint32 *	hash
	)

Definition at line 382 of file execGrouping.c.

{
    TupleHashEntry entry;
    MemoryContext oldContext;
    uint32      local_hash;
 
    /* Need to run the hash functions in short-lived context */
    oldContext = MemoryContextSwitchTo(hashtable->tempcxt);
 
    /* set up data needed by hash and match functions */
    hashtable->inputslot = slot;
    hashtable->in_hash_expr = hashtable->tab_hash_expr;
    hashtable->cur_eq_func = hashtable->tab_eq_func;
 
    local_hash = TupleHashTableHash_internal(hashtable->hashtab, NULL);
    entry = LookupTupleHashEntry_internal(hashtable, slot, isnew, local_hash);
 
    if (hash != NULL)
        *hash = local_hash;
 
    Assert(entry == NULL || entry->hash == local_hash);
 
    MemoryContextSwitchTo(oldContext);
 
    return entry;
}

References Assert(), TupleHashTableData::cur_eq_func, hash(), TupleHashEntryData::hash, TupleHashTableData::hashtab, TupleHashTableData::in_hash_expr, TupleHashTableData::inputslot, LookupTupleHashEntry_internal(), MemoryContextSwitchTo(), TupleHashTableData::tab_eq_func, TupleHashTableData::tab_hash_expr, TupleHashTableData::tempcxt, and TupleHashTableHash_internal().

Referenced by buildSubPlanHash(), ExecRecursiveUnion(), lookup_hash_entries(), and setop_fill_hash_table().

LookupTupleHashEntry_internal()

static TupleHashEntry LookupTupleHashEntry_internal ( TupleHashTable  hashtable, TupleTableSlot *  slot, bool *  isnew, uint32  hash  )

inlinestatic

Definition at line 550 of file execGrouping.c.

{
    TupleHashEntryData *entry;
    bool        found;
    MinimalTuple key;
 
    key = NULL;                 /* flag to reference inputslot */
 
    if (isnew)
    {
        entry = tuplehash_insert_hash(hashtable->hashtab, key, hash, &found);
 
        if (found)
        {
            /* found pre-existing entry */
            *isnew = false;
        }
        else
        {
            /* created new entry */
            *isnew = true;
 
            MemoryContextSwitchTo(hashtable->tuplescxt);
 
            /*
             * Copy the first tuple into the tuples context, and request
             * additionalsize extra bytes before the allocation.
             *
             * The caller can get a pointer to the additional data with
             * TupleHashEntryGetAdditional(), and store arbitrary data there.
             * Placing both the tuple and additional data in the same
             * allocation avoids the need to store an extra pointer in
             * TupleHashEntryData or allocate an additional chunk.
             */
            entry->firstTuple = ExecCopySlotMinimalTupleExtra(slot,
                                                              hashtable->additionalsize);
        }
    }
    else
    {
        entry = tuplehash_lookup_hash(hashtable->hashtab, key, hash);
    }
 
    return entry;
}

References TupleHashTableData::additionalsize, ExecCopySlotMinimalTupleExtra(), TupleHashEntryData::firstTuple, hash(), TupleHashTableData::hashtab, sort-test::key, MemoryContextSwitchTo(), and TupleHashTableData::tuplescxt.

Referenced by LookupTupleHashEntry(), and LookupTupleHashEntryHash().

LookupTupleHashEntryHash()

TupleHashEntry LookupTupleHashEntryHash	(	TupleHashTable	hashtable,
		TupleTableSlot *	slot,
		bool *	isnew,
		uint32	hash
	)

Definition at line 437 of file execGrouping.c.

{
    TupleHashEntry entry;
    MemoryContext oldContext;
 
    /* Need to run the hash functions in short-lived context */
    oldContext = MemoryContextSwitchTo(hashtable->tempcxt);
 
    /* set up data needed by hash and match functions */
    hashtable->inputslot = slot;
    hashtable->in_hash_expr = hashtable->tab_hash_expr;
    hashtable->cur_eq_func = hashtable->tab_eq_func;
 
    entry = LookupTupleHashEntry_internal(hashtable, slot, isnew, hash);
    Assert(entry == NULL || entry->hash == hash);
 
    MemoryContextSwitchTo(oldContext);
 
    return entry;
}

References Assert(), TupleHashTableData::cur_eq_func, hash(), TupleHashEntryData::hash, TupleHashTableData::in_hash_expr, TupleHashTableData::inputslot, LookupTupleHashEntry_internal(), MemoryContextSwitchTo(), TupleHashTableData::tab_eq_func, TupleHashTableData::tab_hash_expr, and TupleHashTableData::tempcxt.

Referenced by agg_refill_hash_table().

ResetTupleHashTable()

void ResetTupleHashTable

(

TupleHashTable

hashtable

)

Definition at line 302 of file execGrouping.c.

{
    tuplehash_reset(hashtable->hashtab);
    MemoryContextReset(hashtable->tuplescxt);
}

References TupleHashTableData::hashtab, MemoryContextReset(), and TupleHashTableData::tuplescxt.

Referenced by agg_refill_hash_table(), build_hash_tables(), buildSubPlanHash(), ExecReScanRecursiveUnion(), and ExecReScanSetOp().

TupleHashTableHash()

uint32 TupleHashTableHash	(	TupleHashTable	hashtable,
		TupleTableSlot *	slot
	)

Definition at line 414 of file execGrouping.c.

{
    MemoryContext oldContext;
    uint32      hash;
 
    hashtable->inputslot = slot;
    hashtable->in_hash_expr = hashtable->tab_hash_expr;
 
    /* Need to run the hash functions in short-lived context */
    oldContext = MemoryContextSwitchTo(hashtable->tempcxt);
 
    hash = TupleHashTableHash_internal(hashtable->hashtab, NULL);
 
    MemoryContextSwitchTo(oldContext);
 
    return hash;
}

References hash(), TupleHashTableData::hashtab, TupleHashTableData::in_hash_expr, TupleHashTableData::inputslot, MemoryContextSwitchTo(), TupleHashTableData::tab_hash_expr, TupleHashTableData::tempcxt, and TupleHashTableHash_internal().

TupleHashTableHash_internal()

static uint32 TupleHashTableHash_internal ( struct tuplehash_hash *  tb, MinimalTuple  tuple  )

inlinestatic

Definition at line 502 of file execGrouping.c.

{
    TupleHashTable hashtable = (TupleHashTable) tb->private_data;
    uint32      hashkey;
    TupleTableSlot *slot;
    bool        isnull;
 
    if (tuple == NULL)
    {
        /* Process the current input tuple for the table */
        hashtable->exprcontext->ecxt_innertuple = hashtable->inputslot;
        hashkey = DatumGetUInt32(ExecEvalExpr(hashtable->in_hash_expr,
                                              hashtable->exprcontext,
                                              &isnull));
    }
    else
    {
        /*
         * Process a tuple already stored in the table.
         *
         * (this case never actually occurs due to the way simplehash.h is
         * used, as the hash-value is stored in the entries)
         */
        slot = hashtable->exprcontext->ecxt_innertuple = hashtable->tableslot;
        ExecStoreMinimalTuple(tuple, slot, false);
        hashkey = DatumGetUInt32(ExecEvalExpr(hashtable->tab_hash_expr,
                                              hashtable->exprcontext,
                                              &isnull));
    }
 
    /*
     * The hashing done above, even with an initial value, doesn't tend to
     * result in good hash perturbation.  Running the value produced above
     * through murmurhash32 leads to near perfect hash perturbation.
     */
    return murmurhash32(hashkey);
}

References DatumGetUInt32(), ExprContext::ecxt_innertuple, ExecEvalExpr(), ExecStoreMinimalTuple(), TupleHashTableData::exprcontext, if(), TupleHashTableData::in_hash_expr, TupleHashTableData::inputslot, murmurhash32(), TupleHashTableData::tab_hash_expr, and TupleHashTableData::tableslot.

Referenced by LookupTupleHashEntry(), and TupleHashTableHash().

TupleHashTableMatch()

static int TupleHashTableMatch ( struct tuplehash_hash *  tb, MinimalTuple  tuple1, MinimalTuple  tuple2  )

static

Definition at line 601 of file execGrouping.c.

{
    TupleTableSlot *slot1;
    TupleTableSlot *slot2;
    TupleHashTable hashtable = (TupleHashTable) tb->private_data;
    ExprContext *econtext = hashtable->exprcontext;
 
    /*
     * We assume that simplehash.h will only ever call us with the first
     * argument being an actual table entry, and the second argument being
     * LookupTupleHashEntry's dummy TupleHashEntryData.  The other direction
     * could be supported too, but is not currently required.
     */
    Assert(tuple1 != NULL);
    slot1 = hashtable->tableslot;
    ExecStoreMinimalTuple(tuple1, slot1, false);
    Assert(tuple2 == NULL);
    slot2 = hashtable->inputslot;
 
    /* For crosstype comparisons, the inputslot must be first */
    econtext->ecxt_innertuple = slot2;
    econtext->ecxt_outertuple = slot1;
    return !ExecQualAndReset(hashtable->cur_eq_func, econtext);
}

References Assert(), TupleHashTableData::cur_eq_func, ExecQualAndReset(), ExecStoreMinimalTuple(), TupleHashTableData::exprcontext, TupleHashTableData::inputslot, and TupleHashTableData::tableslot.