Fix misimplementation of typcache logic for extended hashing.

The previous coding would report that an array type supports extended
hashing if its element type supports regular hashing.  This bug is
only latent at the moment, since AFAICS there is not yet any code
that depends on checking presence of extended-hashing support to make
any decisions.  (And in any case it wouldn't matter unless the element
type has only regular hashing, which isn't true of any core data type.)
But that doesn't make it less broken.  Extend the
cache_array_element_properties infrastructure to check this properly.

diff --git a/src/backend/utils/cache/typcache.c b/src/backend/utils/cache/typcache.c
index 16c52c5a38af2c131ecc97c05930f5daf4a1c668..a0a71dd86a89370b646f88accba0a442c02653f2 100644 (file)
--- a/src/backend/utils/cache/typcache.c
+++ b/src/backend/utils/cache/typcache.c
@@ -79,22 +79,23 @@ static HTAB *TypeCacheHash = NULL;
 static TypeCacheEntry *firstDomainTypeEntry = NULL;
 
 /* Private flag bits in the TypeCacheEntry.flags field */
-#define TCFLAGS_CHECKED_BTREE_OPCLASS      0x0001
-#define TCFLAGS_CHECKED_HASH_OPCLASS       0x0002
-#define TCFLAGS_CHECKED_EQ_OPR             0x0004
-#define TCFLAGS_CHECKED_LT_OPR             0x0008
-#define TCFLAGS_CHECKED_GT_OPR             0x0010
-#define TCFLAGS_CHECKED_CMP_PROC           0x0020
-#define TCFLAGS_CHECKED_HASH_PROC          0x0040
-#define TCFLAGS_CHECKED_ELEM_PROPERTIES        0x0080
-#define TCFLAGS_HAVE_ELEM_EQUALITY         0x0100
-#define TCFLAGS_HAVE_ELEM_COMPARE          0x0200
-#define TCFLAGS_HAVE_ELEM_HASHING          0x0400
-#define TCFLAGS_CHECKED_FIELD_PROPERTIES   0x0800
-#define TCFLAGS_HAVE_FIELD_EQUALITY            0x1000
-#define TCFLAGS_HAVE_FIELD_COMPARE         0x2000
-#define TCFLAGS_CHECKED_DOMAIN_CONSTRAINTS 0x4000
-#define TCFLAGS_CHECKED_HASH_EXTENDED_PROC 0x8000
+#define TCFLAGS_CHECKED_BTREE_OPCLASS      0x000001
+#define TCFLAGS_CHECKED_HASH_OPCLASS       0x000002
+#define TCFLAGS_CHECKED_EQ_OPR             0x000004
+#define TCFLAGS_CHECKED_LT_OPR             0x000008
+#define TCFLAGS_CHECKED_GT_OPR             0x000010
+#define TCFLAGS_CHECKED_CMP_PROC           0x000020
+#define TCFLAGS_CHECKED_HASH_PROC          0x000040
+#define TCFLAGS_CHECKED_HASH_EXTENDED_PROC 0x000080
+#define TCFLAGS_CHECKED_ELEM_PROPERTIES        0x000100
+#define TCFLAGS_HAVE_ELEM_EQUALITY         0x000200
+#define TCFLAGS_HAVE_ELEM_COMPARE          0x000400
+#define TCFLAGS_HAVE_ELEM_HASHING          0x000800
+#define TCFLAGS_HAVE_ELEM_EXTENDED_HASHING 0x001000
+#define TCFLAGS_CHECKED_FIELD_PROPERTIES   0x002000
+#define TCFLAGS_HAVE_FIELD_EQUALITY            0x004000
+#define TCFLAGS_HAVE_FIELD_COMPARE         0x008000
+#define TCFLAGS_CHECKED_DOMAIN_CONSTRAINTS 0x010000
 
 /*
  * Data stored about a domain type's constraints.  Note that we do not create
@@ -273,6 +274,7 @@ static List *prep_domain_constraints(List *constraints, MemoryContext execctx);
 static bool array_element_has_equality(TypeCacheEntry *typentry);
 static bool array_element_has_compare(TypeCacheEntry *typentry);
 static bool array_element_has_hashing(TypeCacheEntry *typentry);
+static bool array_element_has_extended_hashing(TypeCacheEntry *typentry);
 static void cache_array_element_properties(TypeCacheEntry *typentry);
 static bool record_fields_have_equality(TypeCacheEntry *typentry);
 static bool record_fields_have_compare(TypeCacheEntry *typentry);
@@ -451,8 +453,8 @@ lookup_type_cache(Oid type_id, int flags)
         * eq_opr; if we already found one from the btree opclass, that
         * decision is still good.
         */
-       typentry->flags &= ~(TCFLAGS_CHECKED_HASH_PROC);
-       typentry->flags &= ~(TCFLAGS_CHECKED_HASH_EXTENDED_PROC);
+       typentry->flags &= ~(TCFLAGS_CHECKED_HASH_PROC |
+                            TCFLAGS_CHECKED_HASH_EXTENDED_PROC);
        typentry->flags |= TCFLAGS_CHECKED_HASH_OPCLASS;
    }
 
@@ -500,8 +502,8 @@ lookup_type_cache(Oid type_id, int flags)
         * equality operator.  This is so we can ensure that the hash
         * functions match the operator.
         */
-       typentry->flags &= ~(TCFLAGS_CHECKED_HASH_PROC);
-       typentry->flags &= ~(TCFLAGS_CHECKED_HASH_EXTENDED_PROC);
+       typentry->flags &= ~(TCFLAGS_CHECKED_HASH_PROC |
+                            TCFLAGS_CHECKED_HASH_EXTENDED_PROC);
        typentry->flags |= TCFLAGS_CHECKED_EQ_OPR;
    }
    if ((flags & TYPECACHE_LT_OPR) &&
@@ -637,10 +639,10 @@ lookup_type_cache(Oid type_id, int flags)
         * we'll need more logic here to check that case too.
         */
        if (hash_extended_proc == F_HASH_ARRAY_EXTENDED &&
-           !array_element_has_hashing(typentry))
+           !array_element_has_extended_hashing(typentry))
            hash_extended_proc = InvalidOid;
 
-       /* Force update of hash_proc_finfo only if we're changing state */
+       /* Force update of proc finfo only if we're changing state */
        if (typentry->hash_extended_proc != hash_extended_proc)
            typentry->hash_extended_proc_finfo.fn_oid = InvalidOid;
 
@@ -1269,6 +1271,14 @@ array_element_has_hashing(TypeCacheEntry *typentry)
    return (typentry->flags & TCFLAGS_HAVE_ELEM_HASHING) != 0;
 }
 
+static bool
+array_element_has_extended_hashing(TypeCacheEntry *typentry)
+{
+   if (!(typentry->flags & TCFLAGS_CHECKED_ELEM_PROPERTIES))
+       cache_array_element_properties(typentry);
+   return (typentry->flags & TCFLAGS_HAVE_ELEM_EXTENDED_HASHING) != 0;
+}
+
 static void
 cache_array_element_properties(TypeCacheEntry *typentry)
 {
@@ -1281,13 +1291,16 @@ cache_array_element_properties(TypeCacheEntry *typentry)
        elementry = lookup_type_cache(elem_type,
                                      TYPECACHE_EQ_OPR |
                                      TYPECACHE_CMP_PROC |
-                                     TYPECACHE_HASH_PROC);
+                                     TYPECACHE_HASH_PROC |
+                                     TYPECACHE_HASH_EXTENDED_PROC);
        if (OidIsValid(elementry->eq_opr))
            typentry->flags |= TCFLAGS_HAVE_ELEM_EQUALITY;
        if (OidIsValid(elementry->cmp_proc))
            typentry->flags |= TCFLAGS_HAVE_ELEM_COMPARE;
        if (OidIsValid(elementry->hash_proc))
            typentry->flags |= TCFLAGS_HAVE_ELEM_HASHING;
+       if (OidIsValid(elementry->hash_extended_proc))
+           typentry->flags |= TCFLAGS_HAVE_ELEM_EXTENDED_HASHING;
    }
    typentry->flags |= TCFLAGS_CHECKED_ELEM_PROPERTIES;
 }