/*
* Construct an empty TupleHashTable
*
- * inputOps: slot ops for input hash values, or NULL if unknown or not fixed
- * numCols, keyColIdx: identify the tuple fields to use as lookup key
- * eqfunctions: equality comparison functions to use
- * hashfunctions: datatype-specific hashing functions to use
+ * parent: PlanState node that will own this hash table
+ * inputDesc: tuple descriptor for input tuples
+ * inputOps: slot ops for input tuples, or NULL if unknown or not fixed
+ * numCols: number of columns to be compared (length of next 4 arrays)
+ * keyColIdx: indexes of tuple columns to compare
+ * eqfuncoids: OIDs of equality comparison functions to use
+ * hashfunctions: FmgrInfos of datatype-specific hashing functions to use
+ * collations: collations to use in comparisons
* nbuckets: initial estimate of hashtable size
* additionalsize: size of data stored in ->additional
* metacxt: memory context for long-lived allocation, but not per-entry data
* tablecxt: memory context in which to store table entries
* tempcxt: short-lived context for evaluation hash and comparison functions
+ * use_variable_hash_iv: if true, adjust hash IV per-parallel-worker
*
- * The function arrays may be made with execTuplesHashPrepare(). Note they
+ * The hashfunctions array may be made with execTuplesHashPrepare(). Note they
* are not cross-type functions, but expect to see the table datatype(s)
* on both sides.
*
- * Note that keyColIdx, eqfunctions, and hashfunctions must be allocated in
- * storage that will live as long as the hashtable does.
+ * Note that the keyColIdx, hashfunctions, and collations arrays must be
+ * allocated in storage that will live as long as the hashtable does.
*/
TupleHashTable
-BuildTupleHashTableExt(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)
+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)
{
TupleHashTable hashtable;
Size entrysize = sizeof(TupleHashEntryData) + additionalsize;
&TTSOpsMinimalTuple);
/*
- * If the old reset interface is used (i.e. BuildTupleHashTable, rather
- * than BuildTupleHashTableExt), allowing JIT would lead to the generated
- * functions to a) live longer than the query b) be re-generated each time
- * the table is being reset. Therefore prevent JIT from being used in that
- * case, by not providing a parent node (which prevents accessing the
- * JitContext in the EState).
+ * If the caller fails to make the metacxt different from the tablecxt,
+ * allowing JIT would lead to the generated functions to a) live longer
+ * than the query or b) be re-generated each time the table is being
+ * reset. Therefore prevent JIT from being used in that case, by not
+ * providing a parent node (which prevents accessing the JitContext in the
+ * EState).
*/
- allow_jit = metacxt != tablecxt;
+ allow_jit = (metacxt != tablecxt);
/* build hash ExprState for all columns */
hashtable->tab_hash_expr = ExecBuildHash32FromAttrs(inputDesc,
return hashtable;
}
-/*
- * BuildTupleHashTable is a backwards-compatibility wrapper for
- * BuildTupleHashTableExt(), that allocates the hashtable's metadata in
- * tablecxt. Note that hashtables created this way cannot be reset leak-free
- * with ResetTupleHashTable().
- */
-TupleHashTable
-BuildTupleHashTable(PlanState *parent,
- TupleDesc inputDesc,
- int numCols, AttrNumber *keyColIdx,
- const Oid *eqfuncoids,
- FmgrInfo *hashfunctions,
- Oid *collations,
- long nbuckets, Size additionalsize,
- MemoryContext tablecxt,
- MemoryContext tempcxt,
- bool use_variable_hash_iv)
-{
- return BuildTupleHashTableExt(parent,
- inputDesc,
- NULL,
- numCols, keyColIdx,
- eqfuncoids,
- hashfunctions,
- collations,
- nbuckets, additionalsize,
- tablecxt,
- tablecxt,
- tempcxt,
- use_variable_hash_iv);
-}
-
/*
* Reset contents of the hashtable to be empty, preserving all the non-content
- * state. Note that the tablecxt passed to BuildTupleHashTableExt() should
+ * state. Note that the tablecxt passed to BuildTupleHashTable() should
* also be reset, otherwise there will be leaks.
*/
void
*/
additionalsize = aggstate->numtrans * sizeof(AggStatePerGroupData);
- perhash->hashtable = BuildTupleHashTableExt(&aggstate->ss.ps,
- perhash->hashslot->tts_tupleDescriptor,
- perhash->hashslot->tts_ops,
- perhash->numCols,
- perhash->hashGrpColIdxHash,
- perhash->eqfuncoids,
- perhash->hashfunctions,
- perhash->aggnode->grpCollations,
- nbuckets,
- additionalsize,
- metacxt,
- hashcxt,
- tmpcxt,
- DO_AGGSPLIT_SKIPFINAL(aggstate->aggsplit));
+ perhash->hashtable = BuildTupleHashTable(&aggstate->ss.ps,
+ perhash->hashslot->tts_tupleDescriptor,
+ perhash->hashslot->tts_ops,
+ perhash->numCols,
+ perhash->hashGrpColIdxHash,
+ perhash->eqfuncoids,
+ perhash->hashfunctions,
+ perhash->aggnode->grpCollations,
+ nbuckets,
+ additionalsize,
+ metacxt,
+ hashcxt,
+ tmpcxt,
+ DO_AGGSPLIT_SKIPFINAL(aggstate->aggsplit));
}
/*
/*
* If both child plans deliver the same fixed tuple slot type, we can tell
- * BuildTupleHashTableExt to expect that slot type as input. Otherwise,
+ * BuildTupleHashTable to expect that slot type as input. Otherwise,
* we'll pass NULL denoting that any slot type is possible.
*/
- rustate->hashtable = BuildTupleHashTableExt(&rustate->ps,
- desc,
- ExecGetCommonChildSlotOps(&rustate->ps),
- node->numCols,
- node->dupColIdx,
- rustate->eqfuncoids,
- rustate->hashfunctions,
- node->dupCollations,
- node->numGroups,
- 0,
- rustate->ps.state->es_query_cxt,
- rustate->tableContext,
- rustate->tempContext,
- false);
+ rustate->hashtable = BuildTupleHashTable(&rustate->ps,
+ desc,
+ ExecGetCommonChildSlotOps(&rustate->ps),
+ node->numCols,
+ node->dupColIdx,
+ rustate->eqfuncoids,
+ rustate->hashfunctions,
+ node->dupCollations,
+ node->numGroups,
+ 0,
+ rustate->ps.state->es_query_cxt,
+ rustate->tableContext,
+ rustate->tempContext,
+ false);
}
/*
* If both child plans deliver the same fixed tuple slot type, we can tell
- * BuildTupleHashTableExt to expect that slot type as input. Otherwise,
+ * BuildTupleHashTable to expect that slot type as input. Otherwise,
* we'll pass NULL denoting that any slot type is possible.
*/
- setopstate->hashtable = BuildTupleHashTableExt(&setopstate->ps,
- desc,
- ExecGetCommonChildSlotOps(&setopstate->ps),
- node->numCols,
- node->cmpColIdx,
- setopstate->eqfuncoids,
- setopstate->hashfunctions,
- node->cmpCollations,
- node->numGroups,
- 0,
- setopstate->ps.state->es_query_cxt,
- setopstate->tableContext,
- econtext->ecxt_per_tuple_memory,
- false);
+ setopstate->hashtable = BuildTupleHashTable(&setopstate->ps,
+ desc,
+ ExecGetCommonChildSlotOps(&setopstate->ps),
+ node->numCols,
+ node->cmpColIdx,
+ setopstate->eqfuncoids,
+ setopstate->hashfunctions,
+ node->cmpCollations,
+ node->numGroups,
+ 0,
+ setopstate->ps.state->es_query_cxt,
+ setopstate->tableContext,
+ econtext->ecxt_per_tuple_memory,
+ false);
}
/*
* Because the input slot for each hash table is always the slot resulting
* from an ExecProject(), we can use TTSOpsVirtual for the input ops. This
* saves a needless fetch inner op step for the hashing ExprState created
- * in BuildTupleHashTableExt().
+ * in BuildTupleHashTable().
*/
MemoryContextReset(node->hashtablecxt);
node->havehashrows = false;
if (node->hashtable)
ResetTupleHashTable(node->hashtable);
else
- node->hashtable = BuildTupleHashTableExt(node->parent,
- node->descRight,
- &TTSOpsVirtual,
- ncols,
- node->keyColIdx,
- node->tab_eq_funcoids,
- node->tab_hash_funcs,
- node->tab_collations,
- nbuckets,
- 0,
- node->planstate->state->es_query_cxt,
- node->hashtablecxt,
- node->hashtempcxt,
- false);
+ node->hashtable = BuildTupleHashTable(node->parent,
+ node->descRight,
+ &TTSOpsVirtual,
+ ncols,
+ node->keyColIdx,
+ node->tab_eq_funcoids,
+ node->tab_hash_funcs,
+ node->tab_collations,
+ nbuckets,
+ 0,
+ node->planstate->state->es_query_cxt,
+ node->hashtablecxt,
+ node->hashtempcxt,
+ false);
if (!subplan->unknownEqFalse)
{
if (node->hashnulls)
ResetTupleHashTable(node->hashnulls);
else
- node->hashnulls = BuildTupleHashTableExt(node->parent,
- node->descRight,
- &TTSOpsVirtual,
- ncols,
- node->keyColIdx,
- node->tab_eq_funcoids,
- node->tab_hash_funcs,
- node->tab_collations,
- nbuckets,
- 0,
- node->planstate->state->es_query_cxt,
- node->hashtablecxt,
- node->hashtempcxt,
- false);
+ node->hashnulls = BuildTupleHashTable(node->parent,
+ node->descRight,
+ &TTSOpsVirtual,
+ ncols,
+ node->keyColIdx,
+ node->tab_eq_funcoids,
+ node->tab_hash_funcs,
+ node->tab_collations,
+ nbuckets,
+ 0,
+ node->planstate->state->es_query_cxt,
+ node->hashtablecxt,
+ node->hashtempcxt,
+ false);
}
else
node->hashnulls = NULL;
FmgrInfo **hashFunctions);
extern TupleHashTable BuildTupleHashTable(PlanState *parent,
TupleDesc inputDesc,
- int numCols, AttrNumber *keyColIdx,
+ const TupleTableSlotOps *inputOps,
+ int numCols,
+ AttrNumber *keyColIdx,
const Oid *eqfuncoids,
FmgrInfo *hashfunctions,
Oid *collations,
- long nbuckets, Size additionalsize,
+ long nbuckets,
+ Size additionalsize,
+ MemoryContext metacxt,
MemoryContext tablecxt,
- MemoryContext tempcxt, bool use_variable_hash_iv);
-extern TupleHashTable BuildTupleHashTableExt(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);
+ MemoryContext tempcxt,
+ bool use_variable_hash_iv);
extern TupleHashEntry LookupTupleHashEntry(TupleHashTable hashtable,
TupleTableSlot *slot,
bool *isnew, uint32 *hash);
projects / postgresql.git / commitdiff