Change signature of TupleHashTableHash().

Commit 4eaea3db introduced TupleHashTableHash(), but the signature
didn't match the other exposed functions. Separate it into internal
and external versions. The external version hides the details behind
an API more consistent with the other external functions, and the
internal version is still suitable for simplehash.

diff --git a/src/backend/executor/execGrouping.c b/src/backend/executor/execGrouping.c
index f0737fecca8acb479f2d371b2300a6c0b384d2a7..de0205f4fcdcd902c611eaaccebbd16089555f87 100644 (file)
--- a/src/backend/executor/execGrouping.c
+++ b/src/backend/executor/execGrouping.c
@@ -26,6 +26,8 @@
 #include "utils/memutils.h"
 
 static int     TupleHashTableMatch(struct tuplehash_hash *tb, const MinimalTuple tuple1, const MinimalTuple tuple2);
+static uint32 TupleHashTableHash_internal(struct tuplehash_hash *tb,
+                                                                                 const MinimalTuple tuple);
 static TupleHashEntry LookupTupleHashEntry_internal(
        TupleHashTable hashtable, TupleTableSlot *slot, bool *isnew, uint32 hash);
 
@@ -38,7 +40,7 @@ static TupleHashEntry LookupTupleHashEntry_internal(
 #define SH_ELEMENT_TYPE TupleHashEntryData
 #define SH_KEY_TYPE MinimalTuple
 #define SH_KEY firstTuple
-#define SH_HASH_KEY(tb, key) TupleHashTableHash(tb, key)
+#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
@@ -313,7 +315,7 @@ LookupTupleHashEntry(TupleHashTable hashtable, TupleTableSlot *slot,
        hashtable->in_hash_funcs = hashtable->tab_hash_funcs;
        hashtable->cur_eq_func = hashtable->tab_eq_func;
 
-       hash = TupleHashTableHash(hashtable->hashtab, NULL);
+       hash = TupleHashTableHash_internal(hashtable->hashtab, NULL);
        entry = LookupTupleHashEntry_internal(hashtable, slot, isnew, hash);
 
        MemoryContextSwitchTo(oldContext);
@@ -321,6 +323,28 @@ LookupTupleHashEntry(TupleHashTable hashtable, TupleTableSlot *slot,
        return entry;
 }
 
+/*
+ * Compute the hash value for a tuple
+ */
+uint32
+TupleHashTableHash(TupleHashTable hashtable, TupleTableSlot *slot)
+{
+       MemoryContext   oldContext;
+       uint32          hash;
+
+       hashtable->inputslot = slot;
+       hashtable->in_hash_funcs = hashtable->tab_hash_funcs;
+
+       /* Need to run the hash functions in short-lived context */
+       oldContext = MemoryContextSwitchTo(hashtable->tempcxt);
+
+       hash = TupleHashTableHash_internal(hashtable->hashtab, NULL);
+
+       MemoryContextSwitchTo(oldContext);
+
+       return hash;
+}
+
 /*
  * A variant of LookupTupleHashEntry for callers that have already computed
  * the hash value.
@@ -382,8 +406,6 @@ FindTupleHashEntry(TupleHashTable hashtable, TupleTableSlot *slot,
 }
 
 /*
- * Compute the hash value for a tuple
- *
  * If tuple is NULL, use the input slot instead. This convention avoids the
  * need to materialize virtual input tuples unless they actually need to get
  * copied into the table.
@@ -391,8 +413,9 @@ FindTupleHashEntry(TupleHashTable hashtable, TupleTableSlot *slot,
  * Also, the caller must select an appropriate memory context for running
  * the hash functions. (dynahash.c doesn't change CurrentMemoryContext.)
  */
-uint32
-TupleHashTableHash(struct tuplehash_hash *tb, const MinimalTuple tuple)
+static uint32
+TupleHashTableHash_internal(struct tuplehash_hash *tb,
+                                                       const MinimalTuple tuple)
 {
        TupleHashTable hashtable = (TupleHashTable) tb->private_data;
        int                     numCols = hashtable->numCols;

diff --git a/src/include/executor/executor.h b/src/include/executor/executor.h
index e49cb11046150feebd573364293fb9bd541c2f1f..81fdfa4add32164660ae09136e63969050234e33 100644 (file)
--- a/src/include/executor/executor.h
+++ b/src/include/executor/executor.h
@@ -140,8 +140,8 @@ extern TupleHashTable BuildTupleHashTableExt(PlanState *parent,
 extern TupleHashEntry LookupTupleHashEntry(TupleHashTable hashtable,
                                                                                   TupleTableSlot *slot,
                                                                                   bool *isnew);
-extern uint32 TupleHashTableHash(struct tuplehash_hash *tb,
-                                                                const MinimalTuple tuple);
+extern uint32 TupleHashTableHash(TupleHashTable hashtable,
+                                                                TupleTableSlot *slot);
 extern TupleHashEntry LookupTupleHashEntryHash(TupleHashTable hashtable,
                                                                                           TupleTableSlot *slot,
                                                                                           bool *isnew, uint32 hash);