Introduce TupleHashTableHash() and LookupTupleHashEntryHash().

Expose two new entry points: one for only calculating the hash value
of a tuple, and another for looking up a hash entry when the hash
value is already known. This will be useful for disk-based Hash
Aggregation to avoid recomputing the hash value for the same tuple
after saving and restoring it from disk.

Discussion: https://postgr.es/m/37091115219dd522fd9ed67333ee8ed1b7e09443.camel%40j-davis.com

diff --git a/src/backend/executor/execGrouping.c b/src/backend/executor/execGrouping.c
index 3603c58b63ec63f459331cdec20921450a831fd7..f0737fecca8acb479f2d371b2300a6c0b384d2a7 100644 (file)
--- a/src/backend/executor/execGrouping.c
+++ b/src/backend/executor/execGrouping.c
@@ -25,8 +25,9 @@
 #include "utils/lsyscache.h"
 #include "utils/memutils.h"
 
-static uint32 TupleHashTableHash(struct tuplehash_hash *tb, const MinimalTuple tuple);
 static int TupleHashTableMatch(struct tuplehash_hash *tb, const MinimalTuple tuple1, const MinimalTuple tuple2);
+static TupleHashEntry LookupTupleHashEntry_internal(
+   TupleHashTable hashtable, TupleTableSlot *slot, bool *isnew, uint32 hash);
 
 /*
  * Define parameters for tuple hash table code generation. The interface is
@@ -300,10 +301,9 @@ TupleHashEntry
 LookupTupleHashEntry(TupleHashTable hashtable, TupleTableSlot *slot,
                     bool *isnew)
 {
-   TupleHashEntryData *entry;
-   MemoryContext oldContext;
-   bool        found;
-   MinimalTuple key;
+   TupleHashEntry  entry;
+   MemoryContext   oldContext;
+   uint32          hash;
 
    /* Need to run the hash functions in short-lived context */
    oldContext = MemoryContextSwitchTo(hashtable->tempcxt);
@@ -313,32 +313,34 @@ LookupTupleHashEntry(TupleHashTable hashtable, TupleTableSlot *slot,
    hashtable->in_hash_funcs = hashtable->tab_hash_funcs;
    hashtable->cur_eq_func = hashtable->tab_eq_func;
 
-   key = NULL;                 /* flag to reference inputslot */
+   hash = TupleHashTableHash(hashtable->hashtab, NULL);
+   entry = LookupTupleHashEntry_internal(hashtable, slot, isnew, hash);
 
-   if (isnew)
-   {
-       entry = tuplehash_insert(hashtable->hashtab, key, &found);
+   MemoryContextSwitchTo(oldContext);
 
-       if (found)
-       {
-           /* found pre-existing entry */
-           *isnew = false;
-       }
-       else
-       {
-           /* created new entry */
-           *isnew = true;
-           /* zero caller data */
-           entry->additional = NULL;
-           MemoryContextSwitchTo(hashtable->tablecxt);
-           /* Copy the first tuple into the table context */
-           entry->firstTuple = ExecCopySlotMinimalTuple(slot);
-       }
-   }
-   else
-   {
-       entry = tuplehash_lookup(hashtable->hashtab, key);
-   }
+   return entry;
+}
+
+/*
+ * A variant of LookupTupleHashEntry for callers that have already computed
+ * the hash value.
+ */
+TupleHashEntry
+LookupTupleHashEntryHash(TupleHashTable hashtable, TupleTableSlot *slot,
+                        bool *isnew, uint32 hash)
+{
+   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_funcs = hashtable->tab_hash_funcs;
+   hashtable->cur_eq_func = hashtable->tab_eq_func;
+
+   entry = LookupTupleHashEntry_internal(hashtable, slot, isnew, hash);
 
    MemoryContextSwitchTo(oldContext);
 
@@ -389,7 +391,7 @@ 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.)
  */
-static uint32
+uint32
 TupleHashTableHash(struct tuplehash_hash *tb, const MinimalTuple tuple)
 {
    TupleHashTable hashtable = (TupleHashTable) tb->private_data;
@@ -450,6 +452,52 @@ TupleHashTableHash(struct tuplehash_hash *tb, const MinimalTuple tuple)
    return murmurhash32(hashkey);
 }
 
+/*
+ * Does the work of LookupTupleHashEntry and LookupTupleHashEntryHash. Useful
+ * so that we can avoid switching the memory context multiple times for
+ * LookupTupleHashEntry.
+ *
+ * NB: This function may or may not change the memory context. Caller is
+ * expected to change it back.
+ */
+static TupleHashEntry
+LookupTupleHashEntry_internal(TupleHashTable hashtable, TupleTableSlot *slot,
+                             bool *isnew, uint32 hash)
+{
+   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;
+           /* zero caller data */
+           entry->additional = NULL;
+           MemoryContextSwitchTo(hashtable->tablecxt);
+           /* Copy the first tuple into the table context */
+           entry->firstTuple = ExecCopySlotMinimalTuple(slot);
+       }
+   }
+   else
+   {
+       entry = tuplehash_lookup_hash(hashtable->hashtab, key, hash);
+   }
+
+   return entry;
+}
+
 /*
  * See whether two tuples (presumably of the same hash value) match
  */

diff --git a/src/include/executor/executor.h b/src/include/executor/executor.h
index 6ef3e1fe0691e5df6f60d073d2e31699ebef5adc..e49cb11046150feebd573364293fb9bd541c2f1f 100644 (file)
--- a/src/include/executor/executor.h
+++ b/src/include/executor/executor.h
@@ -140,6 +140,11 @@ 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 TupleHashEntry LookupTupleHashEntryHash(TupleHashTable hashtable,
+                                              TupleTableSlot *slot,
+                                              bool *isnew, uint32 hash);
 extern TupleHashEntry FindTupleHashEntry(TupleHashTable hashtable,
                                         TupleTableSlot *slot,
                                         ExprState *eqcomp,