Refactor typcache.c's record typmod hash table.

Previously, tuple descriptors were stored in chains keyed by a fixed size
array of OIDs.  That meant there were effectively two levels of collision
chain -- one inside and one outside the hash table.  Instead, let dynahash.c
look after conflicts for us by supplying a proper hash and equal function
pair.

This is a nice cleanup on its own, but also simplifies followup
changes allowing blessed TupleDescs to be shared between backends
participating in parallel query.

Author: Thomas Munro
Reviewed-By: Andres Freund
Discussion: https://postgr.es/m/CAEepm%3D34GVhOL%2BarUx56yx7OPk7%3DqpGsv3CpO54feqjAwQKm5g%40mail.gmail.com

diff --git a/src/backend/access/common/tupdesc.c b/src/backend/access/common/tupdesc.c
index 75b191ba2aa96bbe87eb51bf3ba41ddf1cee2427..4436c8636170a2489b7eda7e99039b588ce1ac2b 100644 (file)
--- a/src/backend/access/common/tupdesc.c
+++ b/src/backend/access/common/tupdesc.c
@@ -19,6 +19,7 @@
 
 #include "postgres.h"
 
+#include "access/hash.h"
 #include "access/htup_details.h"
 #include "catalog/pg_collation.h"
 #include "catalog/pg_type.h"
@@ -26,6 +27,7 @@
 #include "parser/parse_type.h"
 #include "utils/acl.h"
 #include "utils/builtins.h"
+#include "utils/hashutils.h"
 #include "utils/resowner_private.h"
 #include "utils/syscache.h"
 
@@ -443,6 +445,31 @@ equalTupleDescs(TupleDesc tupdesc1, TupleDesc tupdesc2)
    return true;
 }
 
+/*
+ * hashTupleDesc
+ *     Compute a hash value for a tuple descriptor.
+ *
+ * If two tuple descriptors would be considered equal by equalTupleDescs()
+ * then their hash value will be equal according to this function.
+ *
+ * Note that currently contents of constraint are not hashed - it'd be a bit
+ * painful to do so, and conflicts just due to constraints are unlikely.
+ */
+uint32
+hashTupleDesc(TupleDesc desc)
+{
+   uint32      s;
+   int         i;
+
+   s = hash_combine(0, hash_uint32(desc->natts));
+   s = hash_combine(s, hash_uint32(desc->tdtypeid));
+   s = hash_combine(s, hash_uint32(desc->tdhasoid));
+   for (i = 0; i < desc->natts; ++i)
+       s = hash_combine(s, hash_uint32(TupleDescAttr(desc, i)->atttypid));
+
+   return s;
+}
+
 /*
  * TupleDescInitEntry
  *     This function initializes a single attribute structure in

diff --git a/src/backend/utils/cache/typcache.c b/src/backend/utils/cache/typcache.c
index 20567a394b2109bd93f69b4305a82c7ac6b1b48b..691d4987b160889ae743e6fce08af1ef18429e6c 100644 (file)
--- a/src/backend/utils/cache/typcache.c
+++ b/src/backend/utils/cache/typcache.c
@@ -133,19 +133,12 @@ typedef struct TypeCacheEnumData
  *
  * Stored record types are remembered in a linear array of TupleDescs,
  * which can be indexed quickly with the assigned typmod.  There is also
- * a hash table to speed searches for matching TupleDescs.  The hash key
- * uses just the first N columns' type OIDs, and so we may have multiple
- * entries with the same hash key.
+ * a hash table to speed searches for matching TupleDescs.
  */
-#define REC_HASH_KEYS  16      /* use this many columns in hash key */
 
 typedef struct RecordCacheEntry
 {
-   /* the hash lookup key MUST BE FIRST */
-   Oid         hashkey[REC_HASH_KEYS]; /* column type IDs, zero-filled */
-
-   /* list of TupleDescs for record types with this hashkey */
-   List       *tupdescs;
+   TupleDesc   tupdesc;
 } RecordCacheEntry;
 
 static HTAB *RecordCacheHash = NULL;
@@ -1297,6 +1290,28 @@ lookup_rowtype_tupdesc_copy(Oid type_id, int32 typmod)
    return CreateTupleDescCopyConstr(tmp);
 }
 
+/*
+ * Hash function for the hash table of RecordCacheEntry.
+ */
+static uint32
+record_type_typmod_hash(const void *data, size_t size)
+{
+   RecordCacheEntry *entry = (RecordCacheEntry *) data;
+
+   return hashTupleDesc(entry->tupdesc);
+}
+
+/*
+ * Match function for the hash table of RecordCacheEntry.
+ */
+static int
+record_type_typmod_compare(const void *a, const void *b, size_t size)
+{
+   RecordCacheEntry *left = (RecordCacheEntry *) a;
+   RecordCacheEntry *right = (RecordCacheEntry *) b;
+
+   return equalTupleDescs(left->tupdesc, right->tupdesc) ? 0 : 1;
+}
 
 /*
  * assign_record_type_typmod
@@ -1310,10 +1325,7 @@ assign_record_type_typmod(TupleDesc tupDesc)
 {
    RecordCacheEntry *recentry;
    TupleDesc   entDesc;
-   Oid         hashkey[REC_HASH_KEYS];
    bool        found;
-   int         i;
-   ListCell   *l;
    int32       newtypmod;
    MemoryContext oldcxt;
 
@@ -1325,45 +1337,31 @@ assign_record_type_typmod(TupleDesc tupDesc)
        HASHCTL     ctl;
 
        MemSet(&ctl, 0, sizeof(ctl));
-       ctl.keysize = REC_HASH_KEYS * sizeof(Oid);
+       ctl.keysize = sizeof(TupleDesc);    /* just the pointer */
        ctl.entrysize = sizeof(RecordCacheEntry);
+       ctl.hash = record_type_typmod_hash;
+       ctl.match = record_type_typmod_compare;
        RecordCacheHash = hash_create("Record information cache", 64,
-                                     &ctl, HASH_ELEM | HASH_BLOBS);
+                                     &ctl,
+                                     HASH_ELEM | HASH_FUNCTION | HASH_COMPARE);
 
        /* Also make sure CacheMemoryContext exists */
        if (!CacheMemoryContext)
            CreateCacheMemoryContext();
    }
 
-   /* Find or create a hashtable entry for this hash class */
-   MemSet(hashkey, 0, sizeof(hashkey));
-   for (i = 0; i < tupDesc->natts; i++)
-   {
-       if (i >= REC_HASH_KEYS)
-           break;
-       hashkey[i] = TupleDescAttr(tupDesc, i)->atttypid;
-   }
+   /* Find or create a hashtable entry for this tuple descriptor */
    recentry = (RecordCacheEntry *) hash_search(RecordCacheHash,
-                                               (void *) hashkey,
+                                               (void *) &tupDesc,
                                                HASH_ENTER, &found);
-   if (!found)
+   if (found && recentry->tupdesc != NULL)
    {
-       /* New entry ... hash_search initialized only the hash key */
-       recentry->tupdescs = NIL;
-   }
-
-   /* Look for existing record cache entry */
-   foreach(l, recentry->tupdescs)
-   {
-       entDesc = (TupleDesc) lfirst(l);
-       if (equalTupleDescs(tupDesc, entDesc))
-       {
-           tupDesc->tdtypmod = entDesc->tdtypmod;
-           return;
-       }
+       tupDesc->tdtypmod = recentry->tupdesc->tdtypmod;
+       return;
    }
 
    /* Not present, so need to manufacture an entry */
+   recentry->tupdesc = NULL;
    oldcxt = MemoryContextSwitchTo(CacheMemoryContext);
 
    if (RecordCacheArray == NULL)
@@ -1382,7 +1380,7 @@ assign_record_type_typmod(TupleDesc tupDesc)
 
    /* if fail in subrs, no damage except possibly some wasted memory... */
    entDesc = CreateTupleDescCopy(tupDesc);
-   recentry->tupdescs = lcons(entDesc, recentry->tupdescs);
+   recentry->tupdesc = entDesc;
    /* mark it as a reference-counted tupdesc */
    entDesc->tdrefcount = 1;
    /* now it's safe to advance NextRecordTypmod */

diff --git a/src/include/access/tupdesc.h b/src/include/access/tupdesc.h
index 39fd59686a7145d28c614c83c9857610862cd9ec..989fe738bbe7675632383e6330f3ab15f37c6954 100644 (file)
--- a/src/include/access/tupdesc.h
+++ b/src/include/access/tupdesc.h
@@ -114,6 +114,8 @@ extern void DecrTupleDescRefCount(TupleDesc tupdesc);
 
 extern bool equalTupleDescs(TupleDesc tupdesc1, TupleDesc tupdesc2);
 
+extern uint32 hashTupleDesc(TupleDesc tupdesc);
+
 extern void TupleDescInitEntry(TupleDesc desc,
                   AttrNumber attributeNumber,
                   const char *attributeName,