Further cleanup of dynahash.c API, in pursuit of portability and

readability.  Bizarre '(long *) TRUE' return convention is gone,
in favor of just raising an error internally in dynahash.c when
we detect hashtable corruption.  HashTableWalk is gone, in favor
of using hash_seq_search directly, since it had no hope of working
with non-LONGALIGNable datatypes.  Simplify some other code that was
made undesirably grotty by promixity to HashTableWalk.

src/backend/access/transam/xlogutils.c

@@ -6,7 +6,7 @@
  * Portions Copyright (c) 1996-2001, PostgreSQL Global Development Group
  * Portions Copyright (c) 1994, Regents of the University of California
  *
- * $Header: /cvsroot/pgsql/src/backend/access/transam/xlogutils.c,v 1.19 2001/10/01 05:36:13 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/access/transam/xlogutils.c,v 1.20 2001/10/05 17:28:11 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -15,9 +15,9 @@
 #include "access/htup.h"
 #include "access/xlogutils.h"
 #include "catalog/pg_database.h"
-#include "lib/hasht.h"
 #include "storage/bufpage.h"
 #include "storage/smgr.h"
+#include "utils/hsearch.h"
 #include "utils/relcache.h"
 
 
@@ -233,27 +233,22 @@ _xl_init_rel_cache(void)
 	ctl.entrysize = sizeof(XLogRelCacheEntry);
 	ctl.hash = tag_hash;
 
-	_xlrelcache = hash_create(_XLOG_RELCACHESIZE, &ctl,
-							  HASH_ELEM | HASH_FUNCTION);
+	_xlrelcache = hash_create("XLOG relcache", _XLOG_RELCACHESIZE,
+							  &ctl, HASH_ELEM | HASH_FUNCTION);
 }
 
 static void
-_xl_remove_hash_entry(XLogRelDesc **edata, Datum dummy)
+_xl_remove_hash_entry(XLogRelDesc *rdesc)
 {
-	XLogRelCacheEntry *hentry;
-	bool		found;
-	XLogRelDesc *rdesc = *edata;
 	Form_pg_class tpgc = rdesc->reldata.rd_rel;
+	XLogRelCacheEntry *hentry;
 
 	rdesc->lessRecently->moreRecently = rdesc->moreRecently;
 	rdesc->moreRecently->lessRecently = rdesc->lessRecently;
 
 	hentry = (XLogRelCacheEntry *) hash_search(_xlrelcache,
-				(void *) &(rdesc->reldata.rd_node), HASH_REMOVE, &found);
-
+				(void *) &(rdesc->reldata.rd_node), HASH_REMOVE, NULL);
 	if (hentry == NULL)
-		elog(STOP, "_xl_remove_hash_entry: can't delete from cache");
-	if (!found)
 		elog(STOP, "_xl_remove_hash_entry: file was not found in cache");
 
 	if (rdesc->reldata.rd_fd >= 0)
@@ -281,7 +276,7 @@ _xl_new_reldesc(void)
 	/* reuse */
 	res = _xlrelarr[0].moreRecently;
 
-	_xl_remove_hash_entry(&res, 0);
+	_xl_remove_hash_entry(res);
 
 	_xlast--;
 	return (res);
@@ -298,13 +293,21 @@ XLogInitRelationCache(void)
 void
 XLogCloseRelationCache(void)
 {
+	HASH_SEQ_STATUS status;
+	XLogRelCacheEntry *hentry;
 
 	DestroyDummyCaches();
 
 	if (!_xlrelarr)
 		return;
 
-	HashTableWalk(_xlrelcache, (HashtFunc) _xl_remove_hash_entry, 0);
+	hash_seq_init(&status, _xlrelcache);
+
+	while ((hentry = (XLogRelCacheEntry *) hash_seq_search(&status)) != NULL)
+	{
+		_xl_remove_hash_entry(hentry->rdesc);
+	}
+
 	hash_destroy(_xlrelcache);
 
 	free(_xlrelarr);
@@ -321,12 +324,9 @@ XLogOpenRelation(bool redo, RmgrId rmid, RelFileNode rnode)
 	bool		found;
 
 	hentry = (XLogRelCacheEntry *)
-		hash_search(_xlrelcache, (void *) &rnode, HASH_FIND, &found);
-
-	if (hentry == NULL)
-		elog(STOP, "XLogOpenRelation: error in cache");
+		hash_search(_xlrelcache, (void *) &rnode, HASH_FIND, NULL);
 
-	if (found)
+	if (hentry)
 	{
 		res = hentry->rdesc;
 
@@ -348,7 +348,7 @@ XLogOpenRelation(bool redo, RmgrId rmid, RelFileNode rnode)
 			hash_search(_xlrelcache, (void *) &rnode, HASH_ENTER, &found);
 
 		if (hentry == NULL)
-			elog(STOP, "XLogOpenRelation: can't insert into cache");
+			elog(STOP, "XLogOpenRelation: out of memory for cache");
 
 		if (found)
 			elog(STOP, "XLogOpenRelation: file found on insert into cache");

src/backend/commands/command.c

@@ -8,7 +8,7 @@
  *
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/commands/Attic/command.c,v 1.142 2001/09/07 21:57:53 momjian Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/commands/Attic/command.c,v 1.143 2001/10/05 17:28:11 tgl Exp $
  *
  * NOTES
  *	  The PerformAddAttribute() code, like most of the relation
@@ -259,7 +259,7 @@ PerformPortalClose(char *name, CommandDest dest)
 	/*
 	 * Note: PortalCleanup is called as a side-effect
 	 */
-	PortalDrop(&portal);
+	PortalDrop(portal);
 }
 
 /* ----------------

src/backend/executor/spi.c

@@ -8,7 +8,7 @@
  *
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/executor/spi.c,v 1.57 2001/08/02 18:08:43 tgl Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/executor/spi.c,v 1.58 2001/10/05 17:28:12 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -783,12 +783,10 @@ SPI_cursor_move(Portal portal, bool forward, int count)
 void
 SPI_cursor_close(Portal portal)
 {
-	Portal	my_portal = portal;
-
-	if (!PortalIsValid(my_portal))
+	if (!PortalIsValid(portal))
 		elog(ERROR, "invalid portal in SPI cursor operation");
 
-	PortalDrop(&my_portal);
+	PortalDrop(portal);
 }
 
 /* =================== private functions =================== */

src/backend/lib/Makefile

@@ -4,7 +4,7 @@
 #    Makefile for lib (miscellaneous stuff)
 #
 # IDENTIFICATION
-#    $Header: /cvsroot/pgsql/src/backend/lib/Makefile,v 1.15 2000/08/31 16:09:59 petere Exp $
+#    $Header: /cvsroot/pgsql/src/backend/lib/Makefile,v 1.16 2001/10/05 17:28:12 tgl Exp $
 #
 #-------------------------------------------------------------------------
 
@@ -12,7 +12,7 @@ subdir = src/backend/lib
 top_builddir = ../../..
 include $(top_builddir)/src/Makefile.global
 
-OBJS = bit.o hasht.o lispsort.o stringinfo.o dllist.o
+OBJS = bit.o dllist.o lispsort.o stringinfo.o
 
 all: SUBSYS.o
 

src/backend/lib/hasht.c

-/*-------------------------------------------------------------------------
- *
- * hasht.c
- *	  hash table related functions that are not directly supported
- *	  by the hashing packages under utils/hash.
- *
- * Portions Copyright (c) 1996-2001, PostgreSQL Global Development Group
- * Portions Copyright (c) 1994, Regents of the University of California
- *
- *
- * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/lib/Attic/hasht.c,v 1.15 2001/01/24 19:42:55 momjian Exp $
- *
- *-------------------------------------------------------------------------
- */
-#include "postgres.h"
-
-#include "lib/hasht.h"
-#include "utils/memutils.h"
-
-/* -----------------------------------
- *		HashTableWalk
- *
- * call given function on every element in hashtable
- *
- * one extra argument (arg) may be supplied
- *
- * NOTE: it is allowed for the given function to delete the hashtable entry
- * it is passed.  However, deleting any other element while the scan is
- * in progress is UNDEFINED (see hash_seq functions).  Also, if elements are
- * added to the table while the scan is in progress, it is unspecified
- * whether they will be visited by the scan or not.
- * -----------------------------------
- */
-void
-HashTableWalk(HTAB *hashtable, HashtFunc function, Datum arg)
-{
-	HASH_SEQ_STATUS status;
-	long	   *hashent;
-	void	   *data;
-	int			keysize;
-
-	hash_seq_init(&status, hashtable);
-	keysize = hashtable->hctl->keysize;
-
-	while ((hashent = hash_seq_search(&status)) != (long *) TRUE)
-	{
-		if (hashent == NULL)
-			elog(FATAL, "error in HashTableWalk");
-
-		/*
-		 * XXX the corresponding hash table insertion does NOT LONGALIGN
-		 * -- make sure the keysize is ok
-		 */
-		data = (void *) LONGALIGN((char *) hashent + keysize);
-		(*function) (data, arg);
-	}
-}

src/backend/storage/buffer/buf_table.c

@@ -8,7 +8,7 @@
  *
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/storage/buffer/buf_table.c,v 1.23 2001/10/01 05:36:13 tgl Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/storage/buffer/buf_table.c,v 1.24 2001/10/05 17:28:12 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -62,21 +62,15 @@ BufferDesc *
 BufTableLookup(BufferTag *tagPtr)
 {
 	BufferLookupEnt  *result;
-	bool		found;
 
 	if (tagPtr->blockNum == P_NEW)
 		return NULL;
 
 	result = (BufferLookupEnt *)
-		hash_search(SharedBufHash, (void *) tagPtr, HASH_FIND, &found);
-
+		hash_search(SharedBufHash, (void *) tagPtr, HASH_FIND, NULL);
 	if (!result)
-	{
-		elog(ERROR, "BufTableLookup: BufferLookup table corrupted");
-		return NULL;
-	}
-	if (!found)
 		return NULL;
+
 	return &(BufferDescriptors[result->id]);
 }
 
@@ -87,7 +81,6 @@ bool
 BufTableDelete(BufferDesc *buf)
 {
 	BufferLookupEnt  *result;
-	bool		found;
 
 	/*
 	 * buffer not initialized or has been removed from table already.
@@ -99,10 +92,11 @@ BufTableDelete(BufferDesc *buf)
 	buf->flags |= BM_DELETED;
 
 	result = (BufferLookupEnt *)
-		hash_search(SharedBufHash, (void *) &(buf->tag), HASH_REMOVE, &found);
+		hash_search(SharedBufHash, (void *) &(buf->tag), HASH_REMOVE, NULL);
 
-	if (!(result && found))
+	if (!result)
 	{
+		/* shouldn't happen */
 		elog(ERROR, "BufTableDelete: BufferLookup table corrupted");
 		return FALSE;
 	}
@@ -134,14 +128,13 @@ BufTableInsert(BufferDesc *buf)
 
 	if (!result)
 	{
-		Assert(0);
-		elog(ERROR, "BufTableInsert: BufferLookup table corrupted");
+		elog(ERROR, "BufTableInsert: BufferLookup table out of memory");
 		return FALSE;
 	}
+
 	/* found something else in the table ! */
 	if (found)
 	{
-		Assert(0);
 		elog(ERROR, "BufTableInsert: BufferLookup table corrupted");
 		return FALSE;
 	}

src/backend/storage/freespace/freespace.c

@@ -8,7 +8,7 @@
  * Portions Copyright (c) 1994, Regents of the University of California
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/storage/freespace/freespace.c,v 1.6 2001/10/01 05:36:14 tgl Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/storage/freespace/freespace.c,v 1.7 2001/10/05 17:28:12 tgl Exp $
  *
  *
  * NOTES:
@@ -490,16 +490,12 @@ static FSMRelation *
 lookup_fsm_rel(RelFileNode *rel)
 {
 	FSMRelation *fsmrel;
-	bool		found;
 
 	fsmrel = (FSMRelation *) hash_search(FreeSpaceMap->relHash,
 										 (void *) rel,
 										 HASH_FIND,
-										 &found);
+										 NULL);
 	if (!fsmrel)
-		elog(ERROR, "FreeSpaceMap hashtable corrupted");
-
-	if (!found)
 		return NULL;
 
 	return fsmrel;
@@ -523,7 +519,7 @@ create_fsm_rel(RelFileNode *rel)
 										 HASH_ENTER,
 										 &found);
 	if (!fsmrel)
-		elog(ERROR, "FreeSpaceMap hashtable corrupted");
+		elog(ERROR, "FreeSpaceMap hashtable out of memory");
 
 	if (!found)
 	{
@@ -584,7 +580,6 @@ static void
 delete_fsm_rel(FSMRelation *fsmrel)
 {
 	FSMRelation *result;
-	bool		found;
 
 	free_chunk_chain(fsmrel->relChunks);
 	unlink_fsm_rel(fsmrel);
@@ -592,8 +587,8 @@ delete_fsm_rel(FSMRelation *fsmrel)
 	result = (FSMRelation *) hash_search(FreeSpaceMap->relHash,
 										 (void *) &(fsmrel->key),
 										 HASH_REMOVE,
-										 &found);
-	if (!result || !found)
+										 NULL);
+	if (!result)
 		elog(ERROR, "FreeSpaceMap hashtable corrupted");
 }
 

src/backend/storage/ipc/shmem.c

@@ -8,7 +8,7 @@
  *
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/storage/ipc/shmem.c,v 1.60 2001/10/01 05:36:14 tgl Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/storage/ipc/shmem.c,v 1.61 2001/10/05 17:28:12 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -210,7 +210,7 @@ InitShmemIndex(void)
 	result = (ShmemIndexEnt *)
 		hash_search(ShmemIndex, (void *) &item, HASH_ENTER, &found);
 	if (!result)
-		elog(FATAL, "InitShmemIndex: corrupted shmem index");
+		elog(FATAL, "InitShmemIndex: Shmem Index out of memory");
 
 	Assert(ShmemBootstrap && !found);
 
@@ -234,7 +234,7 @@ InitShmemIndex(void)
  * table at once.
  */
 HTAB *
-ShmemInitHash(char *name,		/* table string name for shmem index */
+ShmemInitHash(const char *name,	/* table string name for shmem index */
 			  long init_size,	/* initial table size */
 			  long max_size,	/* max size of the table */
 			  HASHCTL *infoP,	/* info about key and bucket size */
@@ -277,7 +277,7 @@ ShmemInitHash(char *name,		/* table string name for shmem index */
 	infoP->hctl = (HASHHDR *) location;
 	infoP->dir = (HASHSEGMENT *) (((char *) location) + sizeof(HASHHDR));
 
-	return hash_create(init_size, infoP, hash_flags);
+	return hash_create(name, init_size, infoP, hash_flags);
 }
 
 /*
@@ -295,7 +295,7 @@ ShmemInitHash(char *name,		/* table string name for shmem index */
  *		initialized).
  */
 void *
-ShmemInitStruct(char *name, Size size, bool *foundPtr)
+ShmemInitStruct(const char *name, Size size, bool *foundPtr)
 {
 	ShmemIndexEnt *result,
 				item;
@@ -328,7 +328,7 @@ ShmemInitStruct(char *name, Size size, bool *foundPtr)
 	if (!result)
 	{
 		LWLockRelease(ShmemIndexLock);
-		elog(ERROR, "ShmemInitStruct: Shmem Index corrupted");
+		elog(ERROR, "ShmemInitStruct: Shmem Index out of memory");
 		return NULL;
 	}
 
@@ -357,12 +357,12 @@ ShmemInitStruct(char *name, Size size, bool *foundPtr)
 		{
 			/* out of memory */
 			Assert(ShmemIndex);
-			hash_search(ShmemIndex, (void *) &item, HASH_REMOVE, foundPtr);
+			hash_search(ShmemIndex, (void *) &item, HASH_REMOVE, NULL);
 			LWLockRelease(ShmemIndexLock);
-			*foundPtr = FALSE;
 
 			elog(NOTICE, "ShmemInitStruct: cannot allocate '%s'",
 				 name);
+			*foundPtr = FALSE;
 			return NULL;
 		}
 		result->size = size;

src/backend/storage/lmgr/lock.c

@@ -8,7 +8,7 @@
  *
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/storage/lmgr/lock.c,v 1.99 2001/10/01 05:36:14 tgl Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/storage/lmgr/lock.c,v 1.100 2001/10/05 17:28:12 tgl Exp $
  *
  * NOTES
  *	  Outside modules can create a lock table and acquire/release
@@ -491,7 +491,8 @@ LockAcquire(LOCKMETHOD lockmethod, LOCKTAG *locktag,
 	if (!lock)
 	{
 		LWLockRelease(masterLock);
-		elog(FATAL, "LockAcquire: lock table %d is corrupted", lockmethod);
+		elog(ERROR, "LockAcquire: lock table %d is out of memory",
+			 lockmethod);
 		return FALSE;
 	}
 
@@ -537,7 +538,7 @@ LockAcquire(LOCKMETHOD lockmethod, LOCKTAG *locktag,
 	if (!holder)
 	{
 		LWLockRelease(masterLock);
-		elog(FATAL, "LockAcquire: holder table corrupted");
+		elog(ERROR, "LockAcquire: holder table out of memory");
 		return FALSE;
 	}
 
@@ -658,8 +659,8 @@ LockAcquire(LOCKMETHOD lockmethod, LOCKTAG *locktag,
 				SHMQueueDelete(&holder->procLink);
 				holder = (HOLDER *) hash_search(holderTable,
 												(void *) holder,
-												HASH_REMOVE, &found);
-				if (!holder || !found)
+												HASH_REMOVE, NULL);
+				if (!holder)
 					elog(NOTICE, "LockAcquire: remove holder, table corrupted");
 			}
 			else
@@ -991,7 +992,6 @@ LockRelease(LOCKMETHOD lockmethod, LOCKTAG *locktag,
 {
 	LOCK	   *lock;
 	LWLockId	masterLock;
-	bool		found;
 	LOCKMETHODTABLE *lockMethodTable;
 	HOLDER	   *holder;
 	HOLDERTAG	holdertag;
@@ -1023,20 +1023,13 @@ LockRelease(LOCKMETHOD lockmethod, LOCKTAG *locktag,
 	Assert(lockMethodTable->lockHash->hash == tag_hash);
 	lock = (LOCK *) hash_search(lockMethodTable->lockHash,
 								(void *) locktag,
-								HASH_FIND, &found);
+								HASH_FIND, NULL);
 
 	/*
 	 * let the caller print its own error message, too. Do not
 	 * elog(ERROR).
 	 */
 	if (!lock)
-	{
-		LWLockRelease(masterLock);
-		elog(NOTICE, "LockRelease: locktable corrupted");
-		return FALSE;
-	}
-
-	if (!found)
 	{
 		LWLockRelease(masterLock);
 		elog(NOTICE, "LockRelease: no such lock");
@@ -1056,12 +1049,12 @@ LockRelease(LOCKMETHOD lockmethod, LOCKTAG *locktag,
 	holderTable = lockMethodTable->holderHash;
 	holder = (HOLDER *) hash_search(holderTable,
 									(void *) &holdertag,
-									HASH_FIND_SAVE, &found);
-	if (!holder || !found)
+									HASH_FIND_SAVE, NULL);
+	if (!holder)
 	{
 		LWLockRelease(masterLock);
 #ifdef USER_LOCKS
-		if (!found && lockmethod == USER_LOCKMETHOD)
+		if (lockmethod == USER_LOCKMETHOD)
 			elog(NOTICE, "LockRelease: no lock with this tag");
 		else
 #endif
@@ -1130,8 +1123,8 @@ LockRelease(LOCKMETHOD lockmethod, LOCKTAG *locktag,
 		lock = (LOCK *) hash_search(lockMethodTable->lockHash,
 									(void *) &(lock->tag),
 									HASH_REMOVE,
-									&found);
-		if (!lock || !found)
+									NULL);
+		if (!lock)
 		{
 			LWLockRelease(masterLock);
 			elog(NOTICE, "LockRelease: remove lock, table corrupted");
@@ -1159,8 +1152,8 @@ LockRelease(LOCKMETHOD lockmethod, LOCKTAG *locktag,
 		SHMQueueDelete(&holder->procLink);
 		holder = (HOLDER *) hash_search(holderTable,
 										(void *) &holder,
-										HASH_REMOVE_SAVED, &found);
-		if (!holder || !found)
+										HASH_REMOVE_SAVED, NULL);
+		if (!holder)
 		{
 			LWLockRelease(masterLock);
 			elog(NOTICE, "LockRelease: remove holder, table corrupted");
@@ -1201,7 +1194,6 @@ LockReleaseAll(LOCKMETHOD lockmethod, PROC *proc,
 	int			i,
 				numLockModes;
 	LOCK	   *lock;
-	bool		found;
 
 #ifdef LOCK_DEBUG
 	if (lockmethod == USER_LOCKMETHOD ? Trace_userlocks : Trace_locks)
@@ -1313,8 +1305,8 @@ LockReleaseAll(LOCKMETHOD lockmethod, PROC *proc,
 		holder = (HOLDER *) hash_search(lockMethodTable->holderHash,
 										(void *) holder,
 										HASH_REMOVE,
-										&found);
-		if (!holder || !found)
+										NULL);
+		if (!holder)
 		{
 			LWLockRelease(masterLock);
 			elog(NOTICE, "LockReleaseAll: holder table corrupted");
@@ -1323,7 +1315,6 @@ LockReleaseAll(LOCKMETHOD lockmethod, PROC *proc,
 
 		if (lock->nRequested == 0)
 		{
-
 			/*
 			 * We've just released the last lock, so garbage-collect the
 			 * lock object.
@@ -1332,8 +1323,8 @@ LockReleaseAll(LOCKMETHOD lockmethod, PROC *proc,
 			Assert(lockMethodTable->lockHash->hash == tag_hash);
 			lock = (LOCK *) hash_search(lockMethodTable->lockHash,
 										(void *) &(lock->tag),
-										HASH_REMOVE, &found);
-			if (!lock || !found)
+										HASH_REMOVE, NULL);
+			if (!lock)
 			{
 				LWLockRelease(masterLock);
 				elog(NOTICE, "LockReleaseAll: cannot remove lock from HTAB");
@@ -1438,7 +1429,7 @@ void
 DumpAllLocks(void)
 {
 	PROC	   *proc;
-	HOLDER	   *holder = NULL;
+	HOLDER	   *holder;
 	LOCK	   *lock;
 	int			lockmethod = DEFAULT_LOCKMETHOD;
 	LOCKMETHODTABLE *lockMethodTable;
@@ -1460,8 +1451,7 @@ DumpAllLocks(void)
 		LOCK_PRINT("DumpAllLocks: waiting on", proc->waitLock, 0);
 
 	hash_seq_init(&status, holderTable);
-	while ((holder = (HOLDER *) hash_seq_search(&status)) &&
-		   (holder != (HOLDER *) TRUE))
+	while ((holder = (HOLDER *) hash_seq_search(&status)) != NULL)
 	{
 		HOLDER_PRINT("DumpAllLocks", holder);
 

src/backend/storage/smgr/mm.c

@@ -11,7 +11,7 @@
  *
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/storage/smgr/Attic/mm.c,v 1.26 2001/10/01 05:36:15 tgl Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/storage/smgr/Attic/mm.c,v 1.27 2001/10/05 17:28:12 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -186,7 +186,7 @@ mmcreate(Relation reln)
 	if (entry == (MMRelHashEntry *) NULL)
 	{
 		LWLockRelease(MMCacheLock);
-		elog(FATAL, "main memory storage mgr rel cache hash table corrupt");
+		elog(FATAL, "main memory storage mgr hash table out of memory");
 	}
 
 	if (found)
@@ -214,7 +214,6 @@ mmunlink(RelFileNode rnode)
 	int			i;
 	MMHashEntry *entry;
 	MMRelHashEntry *rentry;
-	bool		found;
 	MMRelTag	rtag;
 
 	LWLockAcquire(MMCacheLock, LW_EXCLUSIVE);
@@ -226,8 +225,8 @@ mmunlink(RelFileNode rnode)
 		{
 			entry = (MMHashEntry *) hash_search(MMCacheHT,
 												(void *) &MMBlockTags[i],
-												HASH_REMOVE, &found);
-			if (entry == (MMHashEntry *) NULL || !found)
+												HASH_REMOVE, NULL);
+			if (entry == (MMHashEntry *) NULL)
 			{
 				LWLockRelease(MMCacheLock);
 				elog(FATAL, "mmunlink: cache hash table corrupted");
@@ -242,9 +241,9 @@ mmunlink(RelFileNode rnode)
 
 	rentry = (MMRelHashEntry *) hash_search(MMRelCacheHT,
 											(void *) &rtag,
-											HASH_REMOVE, &found);
+											HASH_REMOVE, NULL);
 
-	if (rentry == (MMRelHashEntry *) NULL || !found)
+	if (rentry == (MMRelHashEntry *) NULL)
 	{
 		LWLockRelease(MMCacheLock);
 		elog(FATAL, "mmunlink: rel cache hash table corrupted");
@@ -306,8 +305,8 @@ mmextend(Relation reln, BlockNumber blocknum, char *buffer)
 
 	rentry = (MMRelHashEntry *) hash_search(MMRelCacheHT,
 											(void *) &rtag,
-											HASH_FIND, &found);
-	if (rentry == (MMRelHashEntry *) NULL || !found)
+											HASH_FIND, NULL);
+	if (rentry == (MMRelHashEntry *) NULL)
 	{
 		LWLockRelease(MMCacheLock);
 		elog(FATAL, "mmextend: rel cache hash table corrupt");
@@ -372,7 +371,6 @@ int
 mmread(Relation reln, BlockNumber blocknum, char *buffer)
 {
 	MMHashEntry *entry;
-	bool		found;
 	int			offset;
 	MMCacheTag	tag;
 
@@ -387,15 +385,9 @@ mmread(Relation reln, BlockNumber blocknum, char *buffer)
 	LWLockAcquire(MMCacheLock, LW_EXCLUSIVE);
 	entry = (MMHashEntry *) hash_search(MMCacheHT,
 										(void *) &tag,
-										HASH_FIND, &found);
+										HASH_FIND, NULL);
 
 	if (entry == (MMHashEntry *) NULL)
-	{
-		LWLockRelease(MMCacheLock);
-		elog(FATAL, "mmread: hash table corrupt");
-	}
-
-	if (!found)
 	{
 		/* reading nonexistent pages is defined to fill them with zeroes */
 		LWLockRelease(MMCacheLock);
@@ -420,7 +412,6 @@ int
 mmwrite(Relation reln, BlockNumber blocknum, char *buffer)
 {
 	MMHashEntry *entry;
-	bool		found;
 	int			offset;
 	MMCacheTag	tag;
 
@@ -435,15 +426,9 @@ mmwrite(Relation reln, BlockNumber blocknum, char *buffer)
 	LWLockAcquire(MMCacheLock, LW_EXCLUSIVE);
 	entry = (MMHashEntry *) hash_search(MMCacheHT,
 										(void *) &tag,
-										HASH_FIND, &found);
+										HASH_FIND, NULL);
 
 	if (entry == (MMHashEntry *) NULL)
-	{
-		LWLockRelease(MMCacheLock);
-		elog(FATAL, "mmread: hash table corrupt");
-	}
-
-	if (!found)
 	{
 		LWLockRelease(MMCacheLock);
 		elog(FATAL, "mmwrite: hash table missing requested page");
@@ -496,7 +481,6 @@ mmnblocks(Relation reln)
 {
 	MMRelTag	rtag;
 	MMRelHashEntry *rentry;
-	bool		found;
 	BlockNumber	nblocks;
 
 	if (reln->rd_rel->relisshared)
@@ -510,15 +494,9 @@ mmnblocks(Relation reln)
 
 	rentry = (MMRelHashEntry *) hash_search(MMRelCacheHT,
 											(void *) &rtag,
-											HASH_FIND, &found);
-
-	if (rentry == (MMRelHashEntry *) NULL)
-	{
-		LWLockRelease(MMCacheLock);
-		elog(FATAL, "mmnblocks: rel cache hash table corrupt");
-	}
+											HASH_FIND, NULL);
 
-	if (found)
+	if (rentry)
 		nblocks = rentry->mmrhe_nblocks;
 	else
 		nblocks = InvalidBlockNumber;

src/backend/tcop/pquery.c

@@ -8,7 +8,7 @@
  *
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/tcop/pquery.c,v 1.44 2001/03/22 06:16:17 momjian Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/tcop/pquery.c,v 1.45 2001/10/05 17:28:12 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -147,7 +147,7 @@ PreparePortal(char *portalName)
 		 */
 		elog(NOTICE, "Closing pre-existing portal \"%s\"",
 			 portalName);
-		PortalDrop(&portal);
+		PortalDrop(portal);
 	}
 
 	/*

src/backend/utils/adt/ri_triggers.c

@@ -18,7 +18,7 @@
  * Portions Copyright (c) 2000-2001, PostgreSQL Global Development Group
  * Copyright 1999 Jan Wieck
  *
- * $Header: /cvsroot/pgsql/src/backend/utils/adt/ri_triggers.c,v 1.26 2001/10/01 05:36:16 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/utils/adt/ri_triggers.c,v 1.27 2001/10/05 17:28:12 tgl Exp $
  *
  * ----------
  */
@@ -2990,14 +2990,14 @@ ri_InitHashTables(void)
 	ctl.keysize = sizeof(RI_QueryKey);
 	ctl.entrysize = sizeof(RI_QueryHashEntry);
 	ctl.hash = tag_hash;
-	ri_query_cache = hash_create(RI_INIT_QUERYHASHSIZE, &ctl,
-								 HASH_ELEM | HASH_FUNCTION);
+	ri_query_cache = hash_create("RI query cache", RI_INIT_QUERYHASHSIZE,
+								 &ctl, HASH_ELEM | HASH_FUNCTION);
 
 	ctl.keysize = sizeof(Oid);
 	ctl.entrysize = sizeof(RI_OpreqHashEntry);
 	ctl.hash = tag_hash;
-	ri_opreq_cache = hash_create(RI_INIT_OPREQHASHSIZE, &ctl,
-								 HASH_ELEM | HASH_FUNCTION);
+	ri_opreq_cache = hash_create("RI OpReq cache", RI_INIT_OPREQHASHSIZE,
+								 &ctl, HASH_ELEM | HASH_FUNCTION);
 }
 
 
@@ -3012,7 +3012,6 @@ static void *
 ri_FetchPreparedPlan(RI_QueryKey *key)
 {
 	RI_QueryHashEntry *entry;
-	bool		found;
 
 	/*
 	 * On the first call initialize the hashtable
@@ -3025,10 +3024,8 @@ ri_FetchPreparedPlan(RI_QueryKey *key)
 	 */
 	entry = (RI_QueryHashEntry *) hash_search(ri_query_cache,
 											  (void *) key,
-											  HASH_FIND, &found);
+											  HASH_FIND, NULL);
 	if (entry == NULL)
-		elog(FATAL, "error in RI plan cache");
-	if (!found)
 		return NULL;
 	return entry->plan;
 }
@@ -3059,7 +3056,7 @@ ri_HashPreparedPlan(RI_QueryKey *key, void *plan)
 											  (void *) key,
 											  HASH_ENTER, &found);
 	if (entry == NULL)
-		elog(FATAL, "can't insert into RI plan cache");
+		elog(ERROR, "out of memory for RI plan cache");
 	entry->plan = plan;
 }
 
@@ -3235,16 +3232,14 @@ ri_AttributesEqual(Oid typeid, Datum oldvalue, Datum newvalue)
 	 */
 	entry = (RI_OpreqHashEntry *) hash_search(ri_opreq_cache,
 											  (void *) &typeid,
-											  HASH_FIND, &found);
-	if (entry == NULL)
-		elog(FATAL, "error in RI operator cache");
+											  HASH_FIND, NULL);
 
 	/*
 	 * If not found, lookup the OPERNAME system cache for it to get the
 	 * func OID, then do the function manager lookup, and remember that
 	 * info.
 	 */
-	if (!found)
+	if (!entry)
 	{
 		HeapTuple	opr_tup;
 		Oid			opr_proc;
@@ -3278,7 +3273,7 @@ ri_AttributesEqual(Oid typeid, Datum oldvalue, Datum newvalue)
 												  (void *) &typeid,
 												  HASH_ENTER, &found);
 		if (entry == NULL)
-			elog(FATAL, "can't insert into RI operator cache");
+			elog(ERROR, "out of memory for RI operator cache");
 
 		entry->typeid = typeid;
 		memcpy(&(entry->oprfmgrinfo), &finfo, sizeof(FmgrInfo));

src/backend/utils/hash/dynahash.c

@@ -9,7 +9,7 @@
  *
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/utils/hash/dynahash.c,v 1.37 2001/10/01 05:36:16 tgl Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/utils/hash/dynahash.c,v 1.38 2001/10/05 17:28:13 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -71,6 +71,7 @@ static bool	dir_realloc(HTAB *hashp);
 static bool	expand_table(HTAB *hashp);
 static bool	hdefault(HTAB *hashp);
 static bool	init_htab(HTAB *hashp, long nelem);
+static void hash_corrupted(HTAB *hashp);
 
 
 /*
@@ -100,7 +101,7 @@ static long hash_accesses,
 /************************** CREATE ROUTINES **********************/
 
 HTAB *
-hash_create(long nelem, HASHCTL *info, int flags)
+hash_create(const char *tabname, long nelem, HASHCTL *info, int flags)
 {
 	HTAB	   *hashp;
 	HASHHDR	   *hctl;
@@ -125,6 +126,9 @@ hash_create(long nelem, HASHCTL *info, int flags)
 		return NULL;
 	MemSet(hashp, 0, sizeof(HTAB));
 
+	hashp->tabname = (char *) MEM_ALLOC(strlen(tabname) + 1);
+	strcpy(hashp->tabname, tabname);
+
 	if (flags & HASH_FUNCTION)
 		hashp->hash = info->hash;
 	else
@@ -140,6 +144,7 @@ hash_create(long nelem, HASHCTL *info, int flags)
 		hashp->dir = info->dir;
 		hashp->alloc = info->alloc;
 		hashp->hcxt = NULL;
+		hashp->isshared = true;
 
 		/* hash table already exists, we're just attaching to it */
 		if (flags & HASH_ATTACH)
@@ -152,6 +157,7 @@ hash_create(long nelem, HASHCTL *info, int flags)
 		hashp->dir = NULL;
 		hashp->alloc = MEM_ALLOC;
 		hashp->hcxt = DynaHashCxt;
+		hashp->isshared = false;
 	}
 
 	if (!hashp->hctl)
@@ -434,12 +440,13 @@ hash_destroy(HTAB *hashp)
 		 * by the caller of hash_create()).
 		 */
 		MEM_FREE(hashp->hctl);
+		MEM_FREE(hashp->tabname);
 		MEM_FREE(hashp);
 	}
 }
 
 void
-hash_stats(char *where, HTAB *hashp)
+hash_stats(const char *where, HTAB *hashp)
 {
 #if HASH_STATISTICS
 
@@ -476,24 +483,37 @@ call_hash(HTAB *hashp, void *k)
 	return (uint32) bucket;
 }
 
-/*
+/*----------
  * hash_search -- look up key in table and perform action
  *
- * action is one of HASH_FIND/HASH_ENTER/HASH_REMOVE
+ * action is one of:
+ *		HASH_FIND: look up key in table
+ *		HASH_ENTER: look up key in table, creating entry if not present
+ *		HASH_REMOVE: look up key in table, remove entry if present
+ *		HASH_FIND_SAVE: look up key in table, also save in static var
+ *		HASH_REMOVE_SAVED: remove entry saved by HASH_FIND_SAVE
+ *
+ * Return value is a pointer to the element found/entered/removed if any,
+ * or NULL if no match was found.  (NB: in the case of the REMOVE actions,
+ * the result is a dangling pointer that shouldn't be dereferenced!)
+ * A NULL result for HASH_ENTER implies we ran out of memory.
+ *
+ * If foundPtr isn't NULL, then *foundPtr is set TRUE if we found an
+ * existing entry in the table, FALSE otherwise.  This is needed in the
+ * HASH_ENTER case, but is redundant with the return value otherwise.
  *
- * RETURNS: NULL if table is corrupted, a pointer to the element
- *		found/removed/entered if applicable, TRUE otherwise.
- *		foundPtr is TRUE if we found an element in the table
- *		(FALSE if we entered one).
+ * The HASH_FIND_SAVE/HASH_REMOVE_SAVED interface is a hack to save one
+ * table lookup in a find/process/remove scenario.  Note that no other
+ * addition or removal in the table can safely happen in between.
+ *----------
  */
 void *
 hash_search(HTAB *hashp,
 			void *keyPtr,
-			HASHACTION action,	/* HASH_FIND / HASH_ENTER / HASH_REMOVE
-								 * HASH_FIND_SAVE / HASH_REMOVE_SAVED */
+			HASHACTION action,
 			bool *foundPtr)
 {
-	HASHHDR	   *hctl;
+	HASHHDR	   *hctl = hashp->hctl;
 	uint32		bucket;
 	long		segment_num;
 	long		segment_ndx;
@@ -507,21 +527,14 @@ hash_search(HTAB *hashp,
 		HASHBUCKET *prevBucketPtr;
 	}			saveState;
 
-	Assert(hashp);
-	Assert(keyPtr);
-	Assert((action == HASH_FIND) ||
-		   (action == HASH_REMOVE) ||
-		   (action == HASH_ENTER) ||
-		   (action == HASH_FIND_SAVE) ||
-		   (action == HASH_REMOVE_SAVED));
-
-	hctl = hashp->hctl;
-
 #if HASH_STATISTICS
 	hash_accesses++;
-	hashp->hctl->accesses++;
+	hctl->accesses++;
 #endif
 
+	/*
+	 * Do the initial lookup (or recall result of prior lookup)
+	 */
 	if (action == HASH_REMOVE_SAVED)
 	{
 		currBucket = saveState.currBucket;
@@ -540,7 +553,8 @@ hash_search(HTAB *hashp,
 
 		segp = hashp->dir[segment_num];
 
-		Assert(segp);
+		if (segp == NULL)
+			hash_corrupted(hashp);
 
 		prevBucketPtr = &segp[segment_ndx];
 		currBucket = *prevBucketPtr;
@@ -556,23 +570,32 @@ hash_search(HTAB *hashp,
 			currBucket = *prevBucketPtr;
 #if HASH_STATISTICS
 			hash_collisions++;
-			hashp->hctl->collisions++;
+			hctl->collisions++;
 #endif
 		}
 	}
 
+	if (foundPtr)
+		*foundPtr = (bool) (currBucket != NULL);
+
 	/*
-	 * if we found an entry or if we weren't trying to insert, we're done
-	 * now.
+	 * OK, now what?
 	 */
-	*foundPtr = (bool) (currBucket != NULL);
-
 	switch (action)
 	{
-		case HASH_ENTER:
+		case HASH_FIND:
 			if (currBucket != NULL)
 				return (void *) ELEMENTKEY(currBucket);
-			break;
+			return NULL;
+
+		case HASH_FIND_SAVE:
+			if (currBucket != NULL)
+			{
+				saveState.currBucket = currBucket;
+				saveState.prevBucketPtr = prevBucketPtr;
+				return (void *) ELEMENTKEY(currBucket);
+			}
+			return NULL;
 
 		case HASH_REMOVE:
 		case HASH_REMOVE_SAVED:
@@ -595,78 +618,57 @@ hash_search(HTAB *hashp,
 				 */
 				return (void *) ELEMENTKEY(currBucket);
 			}
-			return (void *) TRUE;
+			return NULL;
 
-		case HASH_FIND:
+		case HASH_ENTER:
+			/* Return existing element if found, else create one */
 			if (currBucket != NULL)
 				return (void *) ELEMENTKEY(currBucket);
-			return (void *) TRUE;
 
-		case HASH_FIND_SAVE:
-			if (currBucket != NULL)
+			/* get the next free element */
+			currBucket = hctl->freeList;
+			if (currBucket == NULL)
 			{
-				saveState.currBucket = currBucket;
-				saveState.prevBucketPtr = prevBucketPtr;
-				return (void *) ELEMENTKEY(currBucket);
+				/* no free elements.  allocate another chunk of buckets */
+				if (!element_alloc(hashp))
+					return NULL; /* out of memory */
+				currBucket = hctl->freeList;
+				Assert(currBucket != NULL);
 			}
-			return (void *) TRUE;
-
-		default:
-			/* can't get here */
-			return NULL;
-	}
-
-	/*
-	 * If we got here, then we didn't find the element and we have to
-	 * insert it into the hash table
-	 */
-	Assert(currBucket == NULL);
 
-	/* get the next free bucket */
-	currBucket = hctl->freeList;
-	if (currBucket == NULL)
-	{
-		/* no free elements.  allocate another chunk of buckets */
-		if (!element_alloc(hashp))
-			return NULL;
-		currBucket = hctl->freeList;
-	}
-	Assert(currBucket != NULL);
-
-	hctl->freeList = currBucket->link;
+			hctl->freeList = currBucket->link;
 
-	/* link into chain */
-	*prevBucketPtr = currBucket;
-	currBucket->link = NULL;
+			/* link into hashbucket chain */
+			*prevBucketPtr = currBucket;
+			currBucket->link = NULL;
 
-	/* copy key into record */
-	memcpy(ELEMENTKEY(currBucket), keyPtr, hctl->keysize);
+			/* copy key into record */
+			memcpy(ELEMENTKEY(currBucket), keyPtr, hctl->keysize);
 
-	/*
-	 * let the caller initialize the data field after hash_search returns.
-	 */
+			/* caller is expected to fill the data field on return */
 
-	/*
-	 * Check if it is time to split the segment
-	 */
-	if (++hctl->nentries / (hctl->max_bucket + 1) > hctl->ffactor)
-	{
+			/* Check if it is time to split the segment */
+			if (++hctl->nentries / (hctl->max_bucket + 1) > hctl->ffactor)
+			{
+				/*
+				 * NOTE: failure to expand table is not a fatal error, it just
+				 * means we have to run at higher fill factor than we wanted.
+				 */
+				expand_table(hashp);
+			}
 
-		/*
-		 * NOTE: failure to expand table is not a fatal error, it just
-		 * means we have to run at higher fill factor than we wanted.
-		 */
-		expand_table(hashp);
+			return (void *) ELEMENTKEY(currBucket);
 	}
 
-	return (void *) ELEMENTKEY(currBucket);
+	elog(ERROR, "hash_search: bogus action %d", (int) action);
+
+	return NULL;				/* keep compiler quiet */
 }
 
 /*
  * hash_seq_init/_search
  *			Sequentially search through hash table and return
- *			all the elements one by one, return NULL on error and
- *			return (void *) TRUE in the end.
+ *			all the elements one by one, return NULL when no more.
  *
  * NOTE: caller may delete the returned element before continuing the scan.
  * However, deleting any other element while the scan is in progress is
@@ -717,8 +719,7 @@ hash_seq_search(HASH_SEQ_STATUS *status)
 		 */
 		segp = hashp->dir[segment_num];
 		if (segp == NULL)
-			/* this is probably an error */
-			return NULL;
+			hash_corrupted(hashp);
 
 		/*
 		 * now find the right index into the segment for the first item in
@@ -734,7 +735,7 @@ hash_seq_search(HASH_SEQ_STATUS *status)
 			++status->curBucket;
 	}
 
-	return (void *) TRUE;		/* out of buckets */
+	return NULL;				/* out of buckets */
 }
 
 
@@ -923,6 +924,20 @@ element_alloc(HTAB *hashp)
 	return true;
 }
 
+/* complain when we have detected a corrupted hashtable */
+static void
+hash_corrupted(HTAB *hashp)
+{
+	/*
+	 * If the corruption is in a shared hashtable, we'd better force a
+	 * systemwide restart.  Otherwise, just shut down this one backend.
+	 */
+	if (hashp->isshared)
+		elog(STOP, "Hash table '%s' corrupted", hashp->tabname);
+	else
+		elog(FATAL, "Hash table '%s' corrupted", hashp->tabname);
+}
+
 /* calculate ceil(log base 2) of num */
 int
 my_log2(long num)

src/backend/utils/mmgr/portalmem.c

@@ -8,7 +8,7 @@
  *
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/utils/mmgr/portalmem.c,v 1.42 2001/10/01 05:36:16 tgl Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/utils/mmgr/portalmem.c,v 1.43 2001/10/05 17:28:13 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -33,7 +33,7 @@
 
 #include "postgres.h"
 
-#include "lib/hasht.h"
+#include "utils/hsearch.h"
 #include "utils/memutils.h"
 #include "utils/portal.h"
 
@@ -42,7 +42,7 @@
  * ----------------
  */
 
-#define MAX_PORTALNAME_LEN		64		/* XXX LONGALIGNable value */
+#define MAX_PORTALNAME_LEN		64
 
 typedef struct portalhashent
 {
@@ -54,15 +54,13 @@ static HTAB *PortalHashTable = NULL;
 
 #define PortalHashTableLookup(NAME, PORTAL) \
 do { \
-	PortalHashEnt *hentry; bool found; char key[MAX_PORTALNAME_LEN]; \
+	PortalHashEnt *hentry; char key[MAX_PORTALNAME_LEN]; \
 	\
 	MemSet(key, 0, MAX_PORTALNAME_LEN); \
 	snprintf(key, MAX_PORTALNAME_LEN - 1, "%s", NAME); \
 	hentry = (PortalHashEnt*)hash_search(PortalHashTable, \
-										 key, HASH_FIND, &found); \
-	if (hentry == NULL) \
-		elog(FATAL, "error in PortalHashTable"); \
-	if (found) \
+										 key, HASH_FIND, NULL); \
+	if (hentry) \
 		PORTAL = hentry->portal; \
 	else \
 		PORTAL = NULL; \
@@ -77,7 +75,7 @@ do { \
 	hentry = (PortalHashEnt*)hash_search(PortalHashTable, \
 										 key, HASH_ENTER, &found); \
 	if (hentry == NULL) \
-		elog(FATAL, "error in PortalHashTable"); \
+		elog(ERROR, "out of memory in PortalHashTable"); \
 	if (found) \
 		elog(NOTICE, "trying to insert a portal name that exists."); \
 	hentry->portal = PORTAL; \
@@ -85,15 +83,13 @@ do { \
 
 #define PortalHashTableDelete(PORTAL) \
 do { \
-	PortalHashEnt *hentry; bool found; char key[MAX_PORTALNAME_LEN]; \
+	PortalHashEnt *hentry; char key[MAX_PORTALNAME_LEN]; \
 	\
 	MemSet(key, 0, MAX_PORTALNAME_LEN); \
 	snprintf(key, MAX_PORTALNAME_LEN - 1, "%s", PORTAL->name); \
 	hentry = (PortalHashEnt*)hash_search(PortalHashTable, \
-										 key, HASH_REMOVE, &found); \
+										 key, HASH_REMOVE, NULL); \
 	if (hentry == NULL) \
-		elog(FATAL, "error in PortalHashTable"); \
-	if (!found) \
 		elog(NOTICE, "trying to delete portal name that does not exist."); \
 } while(0)
 
@@ -129,7 +125,8 @@ EnablePortalManager(void)
 	 * use PORTALS_PER_USER, defined in utils/portal.h as a guess of how
 	 * many hash table entries to create, initially
 	 */
-	PortalHashTable = hash_create(PORTALS_PER_USER * 3, &ctl, HASH_ELEM);
+	PortalHashTable = hash_create("Portal hash", PORTALS_PER_USER,
+								  &ctl, HASH_ELEM);
 }
 
 /*
@@ -234,15 +231,10 @@ CreatePortal(char *name)
  * Exceptions:
  *		BadState if called when disabled.
  *		BadArg if portal is invalid.
- *
- * Note peculiar calling convention: pass a pointer to a portal pointer.
- * This is mainly so that this routine can be used as a hashtable walker.
  */
 void
-PortalDrop(Portal *portalP)
+PortalDrop(Portal portal)
 {
-	Portal		portal = *portalP;
-
 	AssertArg(PortalIsValid(portal));
 
 	/* remove portal from hash table */
@@ -262,9 +254,23 @@ PortalDrop(Portal *portalP)
 
 /*
  * Destroy all portals created in the current transaction (ie, all of them).
+ *
+ * XXX This assumes that portals can be deleted in a random order, ie,
+ * no portal has a reference to any other (at least not one that will be
+ * exercised during deletion).  I think this is okay at the moment, but
+ * we've had bugs of that ilk in the past.  Keep a close eye on cursor
+ * references...
  */
 void
 AtEOXact_portals(void)
 {
-	HashTableWalk(PortalHashTable, (HashtFunc) PortalDrop, 0);
+	HASH_SEQ_STATUS status;
+	PortalHashEnt *hentry;
+
+	hash_seq_init(&status, PortalHashTable);
+
+	while ((hentry = (PortalHashEnt *) hash_seq_search(&status)) != NULL)
+	{
+		PortalDrop(hentry->portal);
+	}
 }

src/include/lib/hasht.h

-/*-------------------------------------------------------------------------
- *
- * hasht.h
- *	  hash table related functions that are not directly supported
- *	  under utils/hash.
- *
- *
- * Portions Copyright (c) 1996-2001, PostgreSQL Global Development Group
- * Portions Copyright (c) 1994, Regents of the University of California
- *
- * $Id: hasht.h,v 1.12 2001/01/24 19:43:24 momjian Exp $
- *
- *-------------------------------------------------------------------------
- */
-#ifndef HASHT_H
-#define HASHT_H
-
-#include "utils/hsearch.h"
-
-typedef void (*HashtFunc) (void *hashitem, Datum arg);
-
-extern void HashTableWalk(HTAB *hashtable, HashtFunc function, Datum arg);
-
-#endif	 /* HASHT_H */

src/include/storage/shmem.h

@@ -7,7 +7,7 @@
  * Portions Copyright (c) 1996-2001, PostgreSQL Global Development Group
  * Portions Copyright (c) 1994, Regents of the University of California
  *
- * $Id: shmem.h,v 1.32 2001/10/01 05:36:17 tgl Exp $
+ * $Id: shmem.h,v 1.33 2001/10/05 17:28:13 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -66,9 +66,9 @@ extern void InitShmemAllocation(void *seghdr);
 extern void *ShmemAlloc(Size size);
 extern bool ShmemIsValid(unsigned long addr);
 extern void InitShmemIndex(void);
-extern HTAB *ShmemInitHash(char *name, long init_size, long max_size,
+extern HTAB *ShmemInitHash(const char *name, long init_size, long max_size,
 			  HASHCTL *infoP, int hash_flags);
-extern void *ShmemInitStruct(char *name, Size size, bool *foundPtr);
+extern void *ShmemInitStruct(const char *name, Size size, bool *foundPtr);
 
 
 /* size constants for the shmem index table */

src/include/utils/hsearch.h

@@ -7,7 +7,7 @@
  * Portions Copyright (c) 1996-2001, PostgreSQL Global Development Group
  * Portions Copyright (c) 1994, Regents of the University of California
  *
- * $Id: hsearch.h,v 1.21 2001/10/01 05:36:17 tgl Exp $
+ * $Id: hsearch.h,v 1.22 2001/10/05 17:28:13 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -42,7 +42,7 @@
 /*
  * HASHELEMENT is the private part of a hashtable entry.  The caller's data
  * follows the HASHELEMENT structure (on a MAXALIGN'd boundary).  The hash key
- * is expected to be at the start of the caller's hash entry structure.
+ * is expected to be at the start of the caller's hash entry data structure.
  */
 typedef struct HASHELEMENT
 {
@@ -85,10 +85,12 @@ typedef struct HASHHDR
 typedef struct HTAB
 {
 	HASHHDR	   *hctl;			/* shared control information */
-	long		(*hash) (void *key, int keysize); /* Hash Function */
 	HASHSEGMENT *dir;			/* directory of segment starts */
+	long		(*hash) (void *key, int keysize); /* Hash Function */
 	void	   *(*alloc) (Size);/* memory allocator */
 	MemoryContext hcxt;			/* memory context if default allocator used */
+	char	   *tabname;		/* table name (for error messages) */
+	bool		isshared;		/* true if table is in shared memory */
 } HTAB;
 
 /* Parameter data structure for hash_create */
@@ -147,9 +149,10 @@ typedef struct
 /*
  * prototypes for functions in dynahash.c
  */
-extern HTAB *hash_create(long nelem, HASHCTL *info, int flags);
+extern HTAB *hash_create(const char *tabname, long nelem,
+						 HASHCTL *info, int flags);
 extern void hash_destroy(HTAB *hashp);
-extern void hash_stats(char *where, HTAB *hashp);
+extern void hash_stats(const char *where, HTAB *hashp);
 extern void *hash_search(HTAB *hashp, void *keyPtr, HASHACTION action,
 			bool *foundPtr);
 extern void hash_seq_init(HASH_SEQ_STATUS *status, HTAB *hashp);

src/include/utils/portal.h

@@ -7,7 +7,7 @@
  * Portions Copyright (c) 1996-2001, PostgreSQL Global Development Group
  * Portions Copyright (c) 1994, Regents of the University of California
  *
- * $Id: portal.h,v 1.28 2001/05/21 14:22:18 wieck Exp $
+ * $Id: portal.h,v 1.29 2001/10/05 17:28:13 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -61,7 +61,7 @@ typedef struct PortalData
 extern void EnablePortalManager(void);
 extern void AtEOXact_portals(void);
 extern Portal CreatePortal(char *name);
-extern void PortalDrop(Portal *portalP);
+extern void PortalDrop(Portal portal);
 extern Portal GetPortalByName(char *name);
 extern void PortalSetQuery(Portal portal, QueryDesc *queryDesc,
 			   TupleDesc attinfo, EState *state,