Re: HASH_FIXED_SIZE flag gets lost when attaching to existing hash table

[Aidar Imamov]

On 2025-07-24 20:24, Tom Lane wrote:

Aidar Imamov <a.ima...@postgrespro.ru> writes:

Recently, while working with hash tables in dynahash.c, I noticed
something weird.
When a hash table is already created in shared memory, and the another
process
calls hash_create attempting to attach to it, it seems like the
HASH_FIXED_SIZE
flag gets lost.

Yeah, you are right.  This seems to be an oversight in 7c797e719
which introduced that flag.  It only affects predicate-lock tables
because we don't use HASH_FIXED_SIZE anywhere else, and it'd only
matter in EXEC_BACKEND builds, so it's not that surprising that
nobody noticed.  But we ought to fix it going forward.

I don't really like your solution though.  ISTM the intent of the
code is that if the shared hashtable already exists, we adhere to the
properties it has, we don't rely on the current caller to specify the
exact same values.  So relying on the caller to get HASH_FIXED_SIZE
correct here seems like the wrong thing.  I think we ought to add
an isfixed flag to the shared hashtable header and copy that.
(IOW, isfixed ought to act more like keysize/ssize/sshift, and should
perhaps be grouped with them.)

                        regards, tom lane

Thank's, I agree with you.
Attaching an edited version of the patch.

regards,
Aidar Imamov

diff --git a/src/backend/utils/hash/dynahash.c b/src/backend/utils/hash/dynahash.c
index 1ad155d446e..50069d20fb5 100644
--- a/src/backend/utils/hash/dynahash.c
+++ b/src/backend/utils/hash/dynahash.c
@@ -195,6 +195,8 @@ struct HASHHDR
 	long		ssize;			/* segment size --- must be power of 2 */
 	int			sshift;			/* segment shift = log2(ssize) */
 	int			nelem_alloc;	/* number of entries to allocate at once */
+	bool		isfixed;		/* if true, don't enlarge */
+
 
 #ifdef HASH_STATISTICS
 
@@ -496,6 +498,12 @@ hash_create(const char *tabname, long nelem, const HASHCTL *info, int flags)
 			hashp->ssize = hctl->ssize;
 			hashp->sshift = hctl->sshift;
 
+			/*
+			 * make a local copy of the value to determine if the initial
+			 * table's size was defined as a hard limit
+			 */
+			hashp->isfixed = hctl->isfixed;
+
 			return hashp;
 		}
 	}
@@ -517,6 +525,7 @@ hash_create(const char *tabname, long nelem, const HASHCTL *info, int flags)
 					 errmsg("out of memory")));
 	}
 
+	hashp->isfixed = false;
 	hashp->frozen = false;
 
 	hdefault(hashp);
@@ -619,7 +628,8 @@ hash_create(const char *tabname, long nelem, const HASHCTL *info, int flags)
 	}
 
 	if (flags & HASH_FIXED_SIZE)
-		hashp->isfixed = true;
+		hashp->isfixed = hctl->isfixed = true;
+
 	return hashp;
 }
 
@@ -644,6 +654,8 @@ hdefault(HTAB *hashp)
 	hctl->ssize = DEF_SEGSIZE;
 	hctl->sshift = DEF_SEGSIZE_SHIFT;
 
+	hctl->isfixed = false;		/* can be enlarged */
+
 #ifdef HASH_STATISTICS
 	hctl->accesses = hctl->collisions = 0;
 #endif