hsearch.h File Reference

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Data Structures
struct	HASHELEMENT
struct	HASHCTL
struct	HASH_SEQ_STATUS

Macros
#define	HASH_PARTITION   0x0001 /* Hashtable is used w/partitioned locking */
#define	HASH_SEGMENT   0x0002 /* Set segment size */
#define	HASH_DIRSIZE   0x0004 /* Set directory size (initial and max) */
#define	HASH_ELEM   0x0008 /* Set keysize and entrysize (now required!) */
#define	HASH_STRINGS   0x0010 /* Select support functions for string keys */
#define	HASH_BLOBS   0x0020 /* Select support functions for binary keys */
#define	HASH_FUNCTION   0x0040 /* Set user defined hash function */
#define	HASH_COMPARE   0x0080 /* Set user defined comparison function */
#define	HASH_KEYCOPY   0x0100 /* Set user defined key-copying function */
#define	HASH_ALLOC   0x0200 /* Set memory allocator */
#define	HASH_CONTEXT   0x0400 /* Set memory allocation context */
#define	HASH_SHARED_MEM   0x0800 /* Hashtable is in shared memory */
#define	HASH_ATTACH   0x1000 /* Do not initialize hctl */
#define	HASH_FIXED_SIZE   0x2000 /* Initial size is a hard limit */
#define	NO_MAX_DSIZE   (-1)

Typedefs
typedef uint32(*	HashValueFunc) (const void *key, Size keysize)
typedef int(*	HashCompareFunc) (const void *key1, const void *key2, Size keysize)
typedef void *(*	HashCopyFunc) (void *dest, const void *src, Size keysize)
typedef void *(*	HashAllocFunc) (Size request)
typedef struct HASHELEMENT	HASHELEMENT
typedef struct HASHHDR	HASHHDR
typedef struct HTAB	HTAB
typedef struct HASHCTL	HASHCTL

Enumerations
enum	HASHACTION { HASH_FIND , HASH_ENTER , HASH_REMOVE , HASH_ENTER_NULL }

Functions
HTAB *	hash_create (const char *tabname, int64 nelem, const HASHCTL *info, int flags)
void	hash_destroy (HTAB *hashp)
void	hash_stats (const char *caller, HTAB *hashp)
void *	hash_search (HTAB *hashp, const void *keyPtr, HASHACTION action, bool *foundPtr)
uint32	get_hash_value (HTAB *hashp, const void *keyPtr)
void *	hash_search_with_hash_value (HTAB *hashp, const void *keyPtr, uint32 hashvalue, HASHACTION action, bool *foundPtr)
bool	hash_update_hash_key (HTAB *hashp, void *existingEntry, const void *newKeyPtr)
int64	hash_get_num_entries (HTAB *hashp)
void	hash_seq_init (HASH_SEQ_STATUS *status, HTAB *hashp)
void	hash_seq_init_with_hash_value (HASH_SEQ_STATUS *status, HTAB *hashp, uint32 hashvalue)
void *	hash_seq_search (HASH_SEQ_STATUS *status)
void	hash_seq_term (HASH_SEQ_STATUS *status)
void	hash_freeze (HTAB *hashp)
Size	hash_estimate_size (int64 num_entries, Size entrysize)
int64	hash_select_dirsize (int64 num_entries)
Size	hash_get_shared_size (HASHCTL *info, int flags)
void	AtEOXact_HashTables (bool isCommit)
void	AtEOSubXact_HashTables (bool isCommit, int nestDepth)

Macro Definition Documentation

HASH_ALLOC

#define HASH_ALLOC   0x0200 /* Set memory allocator */

Definition at line 101 of file hsearch.h.

HASH_ATTACH

#define HASH_ATTACH   0x1000 /* Do not initialize hctl */

Definition at line 104 of file hsearch.h.

HASH_BLOBS

#define HASH_BLOBS   0x0020 /* Select support functions for binary keys */

Definition at line 97 of file hsearch.h.

HASH_COMPARE

#define HASH_COMPARE   0x0080 /* Set user defined comparison function */

Definition at line 99 of file hsearch.h.

HASH_CONTEXT

#define HASH_CONTEXT   0x0400 /* Set memory allocation context */

Definition at line 102 of file hsearch.h.

HASH_DIRSIZE

#define HASH_DIRSIZE   0x0004 /* Set directory size (initial and max) */

Definition at line 94 of file hsearch.h.

HASH_ELEM

#define HASH_ELEM   0x0008 /* Set keysize and entrysize (now required!) */

Definition at line 95 of file hsearch.h.

HASH_FIXED_SIZE

#define HASH_FIXED_SIZE   0x2000 /* Initial size is a hard limit */

Definition at line 105 of file hsearch.h.

HASH_FUNCTION

#define HASH_FUNCTION   0x0040 /* Set user defined hash function */

Definition at line 98 of file hsearch.h.

HASH_KEYCOPY

#define HASH_KEYCOPY   0x0100 /* Set user defined key-copying function */

Definition at line 100 of file hsearch.h.

HASH_PARTITION

#define HASH_PARTITION   0x0001 /* Hashtable is used w/partitioned locking */

Definition at line 92 of file hsearch.h.

HASH_SEGMENT

#define HASH_SEGMENT   0x0002 /* Set segment size */

Definition at line 93 of file hsearch.h.

HASH_SHARED_MEM

#define HASH_SHARED_MEM   0x0800 /* Hashtable is in shared memory */

Definition at line 103 of file hsearch.h.

HASH_STRINGS

#define HASH_STRINGS   0x0010 /* Select support functions for string keys */

Definition at line 96 of file hsearch.h.

NO_MAX_DSIZE

#define NO_MAX_DSIZE   (-1)

Definition at line 108 of file hsearch.h.

Typedef Documentation

HashAllocFunc

typedef void *(* HashAllocFunc) (Size request)

Definition at line 44 of file hsearch.h.

HashCompareFunc

typedef int(* HashCompareFunc) (const void *key1, const void *key2, Size keysize)

Definition at line 29 of file hsearch.h.

HashCopyFunc

typedef void *(* HashCopyFunc) (void *dest, const void *src, Size keysize)

Definition at line 37 of file hsearch.h.

HASHCTL

typedef struct HASHCTL HASHCTL

HASHELEMENT

typedef struct HASHELEMENT HASHELEMENT

HASHHDR

typedef struct HASHHDR HASHHDR

Definition at line 58 of file hsearch.h.

HashValueFunc

typedef uint32(* HashValueFunc) (const void *key, Size keysize)

Definition at line 21 of file hsearch.h.

HTAB

typedef struct HTAB HTAB

Definition at line 61 of file hsearch.h.

Enumeration Type Documentation

HASHACTION

enum HASHACTION

Enumerator
HASH_FIND
HASH_ENTER
HASH_REMOVE
HASH_ENTER_NULL

Definition at line 111 of file hsearch.h.

{
    HASH_FIND,
    HASH_ENTER,
    HASH_REMOVE,
    HASH_ENTER_NULL,
} HASHACTION;

Function Documentation

AtEOSubXact_HashTables()

void AtEOSubXact_HashTables	(	bool	isCommit,
		int	nestDepth
	)

Definition at line 1957 of file dynahash.c.

{
    int         i;
 
    /*
     * Search backward to make cleanup easy.  Note we must check all entries,
     * not only those at the end of the array, because deletion technique
     * doesn't keep them in order.
     */
    for (i = num_seq_scans - 1; i >= 0; i--)
    {
        if (seq_scan_level[i] >= nestDepth)
        {
            if (isCommit)
                elog(WARNING, "leaked hash_seq_search scan for hash table %p",
                     seq_scan_tables[i]);
            seq_scan_tables[i] = seq_scan_tables[num_seq_scans - 1];
            seq_scan_level[i] = seq_scan_level[num_seq_scans - 1];
            num_seq_scans--;
        }
    }
}

References elog, i, num_seq_scans, seq_scan_level, seq_scan_tables, and WARNING.

Referenced by AbortSubTransaction(), and CommitSubTransaction().

AtEOXact_HashTables()

void AtEOXact_HashTables

(

bool

isCommit

)

Definition at line 1931 of file dynahash.c.

{
    /*
     * During abort cleanup, open scans are expected; just silently clean 'em
     * out.  An open scan at commit means someone forgot a hash_seq_term()
     * call, so complain.
     *
     * Note: it's tempting to try to print the tabname here, but refrain for
     * fear of touching deallocated memory.  This isn't a user-facing message
     * anyway, so it needn't be pretty.
     */
    if (isCommit)
    {
        int         i;
 
        for (i = 0; i < num_seq_scans; i++)
        {
            elog(WARNING, "leaked hash_seq_search scan for hash table %p",
                 seq_scan_tables[i]);
        }
    }
    num_seq_scans = 0;
}

References elog, i, num_seq_scans, seq_scan_tables, and WARNING.

Referenced by AbortTransaction(), AutoVacLauncherMain(), BackgroundWriterMain(), CheckpointerMain(), CommitTransaction(), pgarch_archiveXlog(), PrepareTransaction(), WalSummarizerMain(), and WalWriterMain().

get_hash_value()

uint32 get_hash_value	(	HTAB *	hashp,
		const void *	keyPtr
	)

Definition at line 908 of file dynahash.c.

{
    return hashp->hash(keyPtr, hashp->keysize);
}

References HTAB::hash, and HTAB::keysize.

Referenced by BufTableHashCode(), LockTagHashCode(), and lookup_type_cache().

hash_create()

HTAB * hash_create	(	const char *	tabname,
		int64	nelem,
		const HASHCTL *	info,
		int	flags
	)

Definition at line 358 of file dynahash.c.

{
    HTAB       *hashp;
    HASHHDR    *hctl;
 
    /*
     * Hash tables now allocate space for key and data, but you have to say
     * how much space to allocate.
     */
    Assert(flags & HASH_ELEM);
    Assert(info->keysize > 0);
    Assert(info->entrysize >= info->keysize);
 
    /*
     * For shared hash tables, we have a local hash header (HTAB struct) that
     * we allocate in TopMemoryContext; all else is in shared memory.
     *
     * For non-shared hash tables, everything including the hash header is in
     * a memory context created specially for the hash table --- this makes
     * hash_destroy very simple.  The memory context is made a child of either
     * a context specified by the caller, or TopMemoryContext if nothing is
     * specified.
     */
    if (flags & HASH_SHARED_MEM)
    {
        /* Set up to allocate the hash header */
        CurrentDynaHashCxt = TopMemoryContext;
    }
    else
    {
        /* Create the hash table's private memory context */
        if (flags & HASH_CONTEXT)
            CurrentDynaHashCxt = info->hcxt;
        else
            CurrentDynaHashCxt = TopMemoryContext;
        CurrentDynaHashCxt = AllocSetContextCreate(CurrentDynaHashCxt,
                                                   "dynahash",
                                                   ALLOCSET_DEFAULT_SIZES);
    }
 
    /* Initialize the hash header, plus a copy of the table name */
    hashp = (HTAB *) MemoryContextAlloc(CurrentDynaHashCxt,
                                        sizeof(HTAB) + strlen(tabname) + 1);
    MemSet(hashp, 0, sizeof(HTAB));
 
    hashp->tabname = (char *) (hashp + 1);
    strcpy(hashp->tabname, tabname);
 
    /* If we have a private context, label it with hashtable's name */
    if (!(flags & HASH_SHARED_MEM))
        MemoryContextSetIdentifier(CurrentDynaHashCxt, hashp->tabname);
 
    /*
     * Select the appropriate hash function (see comments at head of file).
     */
    if (flags & HASH_FUNCTION)
    {
        Assert(!(flags & (HASH_BLOBS | HASH_STRINGS)));
        hashp->hash = info->hash;
    }
    else if (flags & HASH_BLOBS)
    {
        Assert(!(flags & HASH_STRINGS));
        /* We can optimize hashing for common key sizes */
        if (info->keysize == sizeof(uint32))
            hashp->hash = uint32_hash;
        else
            hashp->hash = tag_hash;
    }
    else
    {
        /*
         * string_hash used to be considered the default hash method, and in a
         * non-assert build it effectively still is.  But we now consider it
         * an assertion error to not say HASH_STRINGS explicitly.  To help
         * catch mistaken usage of HASH_STRINGS, we also insist on a
         * reasonably long string length: if the keysize is only 4 or 8 bytes,
         * it's almost certainly an integer or pointer not a string.
         */
        Assert(flags & HASH_STRINGS);
        Assert(info->keysize > 8);
 
        hashp->hash = string_hash;
    }
 
    /*
     * If you don't specify a match function, it defaults to string_compare if
     * you used string_hash, and to memcmp otherwise.
     *
     * Note: explicitly specifying string_hash is deprecated, because this
     * might not work for callers in loadable modules on some platforms due to
     * referencing a trampoline instead of the string_hash function proper.
     * Specify HASH_STRINGS instead.
     */
    if (flags & HASH_COMPARE)
        hashp->match = info->match;
    else if (hashp->hash == string_hash)
        hashp->match = (HashCompareFunc) string_compare;
    else
        hashp->match = memcmp;
 
    /*
     * Similarly, the key-copying function defaults to strlcpy or memcpy.
     */
    if (flags & HASH_KEYCOPY)
        hashp->keycopy = info->keycopy;
    else if (hashp->hash == string_hash)
    {
        /*
         * The signature of keycopy is meant for memcpy(), which returns
         * void*, but strlcpy() returns size_t.  Since we never use the return
         * value of keycopy, and size_t is pretty much always the same size as
         * void *, this should be safe.  The extra cast in the middle is to
         * avoid warnings from -Wcast-function-type.
         */
        hashp->keycopy = (HashCopyFunc) (pg_funcptr_t) strlcpy;
    }
    else
        hashp->keycopy = memcpy;
 
    /* And select the entry allocation function, too. */
    if (flags & HASH_ALLOC)
        hashp->alloc = info->alloc;
    else
        hashp->alloc = DynaHashAlloc;
 
    if (flags & HASH_SHARED_MEM)
    {
        /*
         * ctl structure and directory are preallocated for shared memory
         * tables.  Note that HASH_DIRSIZE and HASH_ALLOC had better be set as
         * well.
         */
        hashp->hctl = info->hctl;
        hashp->dir = (HASHSEGMENT *) (((char *) info->hctl) + sizeof(HASHHDR));
        hashp->hcxt = NULL;
        hashp->isshared = true;
 
        /* hash table already exists, we're just attaching to it */
        if (flags & HASH_ATTACH)
        {
            /* make local copies of some heavily-used values */
            hctl = hashp->hctl;
            hashp->keysize = hctl->keysize;
            hashp->ssize = hctl->ssize;
            hashp->sshift = hctl->sshift;
 
            return hashp;
        }
    }
    else
    {
        /* setup hash table defaults */
        hashp->hctl = NULL;
        hashp->dir = NULL;
        hashp->hcxt = CurrentDynaHashCxt;
        hashp->isshared = false;
    }
 
    if (!hashp->hctl)
    {
        hashp->hctl = (HASHHDR *) hashp->alloc(sizeof(HASHHDR));
        if (!hashp->hctl)
            ereport(ERROR,
                    (errcode(ERRCODE_OUT_OF_MEMORY),
                     errmsg("out of memory")));
    }
 
    hashp->frozen = false;
 
    hdefault(hashp);
 
    hctl = hashp->hctl;
 
    if (flags & HASH_PARTITION)
    {
        /* Doesn't make sense to partition a local hash table */
        Assert(flags & HASH_SHARED_MEM);
 
        /*
         * The number of partitions had better be a power of 2. Also, it must
         * be less than INT_MAX (see init_htab()), so call the int version of
         * next_pow2.
         */
        Assert(info->num_partitions == next_pow2_int(info->num_partitions));
 
        hctl->num_partitions = info->num_partitions;
    }
 
    if (flags & HASH_SEGMENT)
    {
        hctl->ssize = info->ssize;
        hctl->sshift = my_log2(info->ssize);
        /* ssize had better be a power of 2 */
        Assert(hctl->ssize == (1L << hctl->sshift));
    }
 
    /*
     * SHM hash tables have fixed directory size passed by the caller.
     */
    if (flags & HASH_DIRSIZE)
    {
        hctl->max_dsize = info->max_dsize;
        hctl->dsize = info->dsize;
    }
 
    /* remember the entry sizes, too */
    hctl->keysize = info->keysize;
    hctl->entrysize = info->entrysize;
 
    /* make local copies of heavily-used constant fields */
    hashp->keysize = hctl->keysize;
    hashp->ssize = hctl->ssize;
    hashp->sshift = hctl->sshift;
 
    /* Build the hash directory structure */
    if (!init_htab(hashp, nelem))
        elog(ERROR, "failed to initialize hash table \"%s\"", hashp->tabname);
 
    /*
     * For a shared hash table, preallocate the requested number of elements.
     * This reduces problems with run-time out-of-shared-memory conditions.
     *
     * For a non-shared hash table, preallocate the requested number of
     * elements if it's less than our chosen nelem_alloc.  This avoids wasting
     * space if the caller correctly estimates a small table size.
     */
    if ((flags & HASH_SHARED_MEM) ||
        nelem < hctl->nelem_alloc)
    {
        int         i,
                    freelist_partitions,
                    nelem_alloc,
                    nelem_alloc_first;
 
        /*
         * If hash table is partitioned, give each freelist an equal share of
         * the initial allocation.  Otherwise only freeList[0] is used.
         */
        if (IS_PARTITIONED(hashp->hctl))
            freelist_partitions = NUM_FREELISTS;
        else
            freelist_partitions = 1;
 
        nelem_alloc = nelem / freelist_partitions;
        if (nelem_alloc <= 0)
            nelem_alloc = 1;
 
        /*
         * Make sure we'll allocate all the requested elements; freeList[0]
         * gets the excess if the request isn't divisible by NUM_FREELISTS.
         */
        if (nelem_alloc * freelist_partitions < nelem)
            nelem_alloc_first =
                nelem - nelem_alloc * (freelist_partitions - 1);
        else
            nelem_alloc_first = nelem_alloc;
 
        for (i = 0; i < freelist_partitions; i++)
        {
            int         temp = (i == 0) ? nelem_alloc_first : nelem_alloc;
 
            if (!element_alloc(hashp, temp, i))
                ereport(ERROR,
                        (errcode(ERRCODE_OUT_OF_MEMORY),
                         errmsg("out of memory")));
        }
    }
 
    /* Set isfixed if requested, but not till after we build initial entries */
    if (flags & HASH_FIXED_SIZE)
        hctl->isfixed = true;
 
    return hashp;
}

References HTAB::alloc, HASHCTL::alloc, ALLOCSET_DEFAULT_SIZES, AllocSetContextCreate, Assert(), CurrentDynaHashCxt, HTAB::dir, HASHHDR::dsize, HASHCTL::dsize, DynaHashAlloc(), element_alloc(), elog, HASHHDR::entrysize, HASHCTL::entrysize, ereport, errcode(), errmsg(), ERROR, HTAB::frozen, HTAB::hash, HASHCTL::hash, HASH_ALLOC, HASH_ATTACH, HASH_BLOBS, HASH_COMPARE, HASH_CONTEXT, HASH_DIRSIZE, HASH_ELEM, HASH_FIXED_SIZE, HASH_FUNCTION, HASH_KEYCOPY, HASH_PARTITION, HASH_SEGMENT, HASH_SHARED_MEM, HASH_STRINGS, HTAB::hctl, HASHCTL::hctl, HTAB::hcxt, HASHCTL::hcxt, hdefault(), i, init_htab(), IS_PARTITIONED, HASHHDR::isfixed, HTAB::isshared, HTAB::keycopy, HASHCTL::keycopy, HASHHDR::keysize, HTAB::keysize, HASHCTL::keysize, HTAB::match, HASHCTL::match, HASHHDR::max_dsize, HASHCTL::max_dsize, MemoryContextAlloc(), MemoryContextSetIdentifier(), MemSet, my_log2(), next_pow2_int(), NUM_FREELISTS, HASHHDR::num_partitions, HASHCTL::num_partitions, HASHHDR::sshift, HTAB::sshift, HASHHDR::ssize, HTAB::ssize, HASHCTL::ssize, string_compare(), string_hash(), strlcpy(), HTAB::tabname, tag_hash(), TopMemoryContext, and uint32_hash().

Referenced by _hash_finish_split(), _PG_init(), AddEventToPendingNotifies(), AddPendingSync(), assign_record_type_typmod(), begin_heap_rewrite(), build_colinfo_names_hash(), build_guc_variables(), build_join_rel_hash(), BuildEventTriggerCache(), cfunc_hashtable_init(), CheckForSessionAndXactLocks(), CompactCheckpointerRequestQueue(), compute_array_stats(), compute_tsvector_stats(), create_seq_hashtable(), createConnHash(), CreateLocalPredicateLockHash(), CreatePartitionDirectory(), do_autovacuum(), EnablePortalManager(), ExecInitModifyTable(), ExecuteTruncateGuts(), find_all_inheritors(), find_oper_cache_entry(), find_rendezvous_variable(), get_json_object_as_hash(), get_relation_notnullatts(), GetComboCommandId(), GetConnection(), gistInitBuildBuffers(), gistInitParentMap(), init_missing_cache(), init_procedure_caches(), init_rel_sync_cache(), init_timezone_hashtable(), init_ts_config_cache(), init_uncommitted_enum_types(), init_uncommitted_enum_values(), InitBufferManagerAccess(), InitializeAttoptCache(), InitializeRelfilenumberMap(), InitializeShippableCache(), InitializeTableSpaceCache(), InitLocalBuffers(), InitLockManagerAccess(), InitQueryHashTable(), InitRecoveryTransactionEnvironment(), InitSync(), json_unique_check_init(), load_categories_hash(), log_invalid_page(), logical_begin_heap_rewrite(), logicalrep_partmap_init(), logicalrep_relmap_init(), lookup_proof_cache(), lookup_ts_dictionary_cache(), lookup_ts_parser_cache(), lookup_type_cache(), LookupOpclassInfo(), pa_allocate_worker(), pg_get_backend_memory_contexts(), plpgsql_estate_setup(), PLy_add_exceptions(), populate_recordset_object_start(), process_syncing_tables_for_apply(), rebuild_database_list(), record_C_func(), RegisterExtensibleNodeEntry(), RelationCacheInitialize(), ReorderBufferAllocate(), ReorderBufferBuildTupleCidHash(), ReorderBufferToastInitHash(), ResetUnloggedRelationsInDbspaceDir(), ri_InitHashTables(), select_perl_context(), SerializePendingSyncs(), set_rtable_names(), ShmemInitHash(), smgropen(), transformGraph(), and XLogPrefetcherAllocate().

hash_destroy()

void hash_destroy

(

HTAB *

hashp

)

Definition at line 865 of file dynahash.c.

{
    if (hashp != NULL)
    {
        /* allocation method must be one we know how to free, too */
        Assert(hashp->alloc == DynaHashAlloc);
        /* so this hashtable must have its own context */
        Assert(hashp->hcxt != NULL);
 
        hash_stats(__func__, hashp);
 
        /*
         * Free everything by destroying the hash table's memory context.
         */
        MemoryContextDelete(hashp->hcxt);
    }
}

References HTAB::alloc, Assert(), DynaHashAlloc(), hash_stats(), HTAB::hcxt, and MemoryContextDelete().

Referenced by _hash_finish_split(), CheckForSessionAndXactLocks(), CompactCheckpointerRequestQueue(), destroy_colinfo_names_hash(), do_autovacuum(), ExecuteTruncateGuts(), find_all_inheritors(), get_json_object_as_hash(), pg_get_backend_memory_contexts(), pgoutput_shutdown(), populate_recordset_object_end(), PostPrepare_PredicateLocks(), process_syncing_tables_for_apply(), ReleasePredicateLocksLocal(), ReorderBufferFreeTXN(), ReorderBufferToastReset(), ReorderBufferTruncateTXN(), ResetSequenceCaches(), ResetUnloggedRelationsInDbspaceDir(), SerializePendingSyncs(), set_rtable_names(), ShutdownRecoveryTransactionEnvironment(), XLogCheckInvalidPages(), and XLogPrefetcherFree().

hash_estimate_size()

Size hash_estimate_size	(	int64	num_entries,
		Size	entrysize
	)

Definition at line 783 of file dynahash.c.

{
    Size        size;
    int64       nBuckets,
                nSegments,
                nDirEntries,
                nElementAllocs,
                elementSize,
                elementAllocCnt;
 
    /* estimate number of buckets wanted */
    nBuckets = next_pow2_int64(num_entries);
    /* # of segments needed for nBuckets */
    nSegments = next_pow2_int64((nBuckets - 1) / DEF_SEGSIZE + 1);
    /* directory entries */
    nDirEntries = DEF_DIRSIZE;
    while (nDirEntries < nSegments)
        nDirEntries <<= 1;      /* dir_alloc doubles dsize at each call */
 
    /* fixed control info */
    size = MAXALIGN(sizeof(HASHHDR));   /* but not HTAB, per above */
    /* directory */
    size = add_size(size, mul_size(nDirEntries, sizeof(HASHSEGMENT)));
    /* segments */
    size = add_size(size, mul_size(nSegments,
                                   MAXALIGN(DEF_SEGSIZE * sizeof(HASHBUCKET))));
    /* elements --- allocated in groups of choose_nelem_alloc() entries */
    elementAllocCnt = choose_nelem_alloc(entrysize);
    nElementAllocs = (num_entries - 1) / elementAllocCnt + 1;
    elementSize = MAXALIGN(sizeof(HASHELEMENT)) + MAXALIGN(entrysize);
    size = add_size(size,
                    mul_size(nElementAllocs,
                             mul_size(elementAllocCnt, elementSize)));
 
    return size;
}

References add_size(), choose_nelem_alloc(), DEF_DIRSIZE, DEF_SEGSIZE, MAXALIGN, mul_size(), and next_pow2_int64().

Referenced by BufTableShmemSize(), CalculateShmemSize(), LockManagerShmemSize(), pgss_memsize(), PredicateLockShmemSize(), and WaitEventCustomShmemSize().

hash_freeze()

void hash_freeze

(

HTAB *

hashp

)

Definition at line 1529 of file dynahash.c.

{
    if (hashp->isshared)
        elog(ERROR, "cannot freeze shared hashtable \"%s\"", hashp->tabname);
    if (!hashp->frozen && has_seq_scans(hashp))
        elog(ERROR, "cannot freeze hashtable \"%s\" because it has active scans",
             hashp->tabname);
    hashp->frozen = true;
}

References elog, ERROR, HTAB::frozen, has_seq_scans(), HTAB::isshared, and HTAB::tabname.

hash_get_num_entries()

int64 hash_get_num_entries

(

HTAB *

hashp

)

Definition at line 1336 of file dynahash.c.

{
    int         i;
    int64       sum = hashp->hctl->freeList[0].nentries;
 
    /*
     * We currently don't bother with acquiring the mutexes; it's only
     * sensible to call this function if you've got lock on all partitions of
     * the table.
     */
    if (IS_PARTITIONED(hashp->hctl))
    {
        for (i = 1; i < NUM_FREELISTS; i++)
            sum += hashp->hctl->freeList[i].nentries;
    }
 
    return sum;
}

References HASHHDR::freeList, HTAB::hctl, i, IS_PARTITIONED, FreeListData::nentries, and NUM_FREELISTS.

Referenced by build_guc_variables(), compute_array_stats(), compute_tsvector_stats(), entry_alloc(), entry_dealloc(), entry_reset(), EstimatePendingSyncsSpace(), EstimateUncommittedEnumsSpace(), get_crosstab_tuplestore(), get_explain_guc_options(), get_guc_variables(), GetLockStatusData(), GetPredicateLockStatusData(), GetRunningTransactionLocks(), GetWaitEventCustomNames(), hash_stats(), pgss_shmem_shutdown(), ResetUnloggedRelationsInDbspaceDir(), SerializePendingSyncs(), transformGraph(), and XLogHaveInvalidPages().

hash_get_shared_size()

Size hash_get_shared_size	(	HASHCTL *	info,
		int	flags
	)

Definition at line 854 of file dynahash.c.

{
    Assert(flags & HASH_DIRSIZE);
    Assert(info->dsize == info->max_dsize);
    return sizeof(HASHHDR) + info->dsize * sizeof(HASHSEGMENT);
}

References Assert(), HASHCTL::dsize, HASH_DIRSIZE, and HASHCTL::max_dsize.

Referenced by ShmemInitHash().

hash_search()

void * hash_search	(	HTAB *	hashp,
		const void *	keyPtr,
		HASHACTION	action,
		bool *	foundPtr
	)

Definition at line 952 of file dynahash.c.

{
    return hash_search_with_hash_value(hashp,
                                       keyPtr,
                                       hashp->hash(keyPtr, hashp->keysize),
                                       action,
                                       foundPtr);
}

References generate_unaccent_rules::action, HTAB::hash, hash_search_with_hash_value(), and HTAB::keysize.

Referenced by _hash_finish_split(), _hash_splitbucket(), add_guc_variable(), add_join_rel(), add_to_names_hash(), AddEnumLabel(), AddEventToPendingNotifies(), AddPendingSync(), ApplyLogicalMappingFile(), assign_record_type_typmod(), AsyncExistsPendingNotify(), AtEOSubXact_RelationCache(), AtEOXact_RelationCache(), build_guc_variables(), build_join_rel_hash(), BuildEventTriggerCache(), cfunc_hashtable_delete(), cfunc_hashtable_insert(), cfunc_hashtable_lookup(), CheckAndPromotePredicateLockRequest(), CheckForSerializableConflictOut(), CheckForSessionAndXactLocks(), colname_is_unique(), CompactCheckpointerRequestQueue(), compile_plperl_function(), compile_pltcl_function(), compute_array_stats(), compute_tsvector_stats(), createNewConnection(), define_custom_variable(), delete_rel_type_cache_if_needed(), deleteConnection(), do_autovacuum(), DropAllPredicateLocksFromTable(), DropAllPreparedStatements(), DropPreparedStatement(), entry_alloc(), entry_dealloc(), entry_reset(), EnumTypeUncommitted(), EnumUncommitted(), EnumValuesCreate(), EventCacheLookup(), ExecInitModifyTable(), ExecLookupResultRelByOid(), ExecuteTruncateGuts(), ExtendBufferedRelLocal(), FetchPreparedStatement(), finalize_in_progress_typentries(), find_all_inheritors(), find_join_rel(), find_oper_cache_entry(), find_option(), find_relation_notnullatts(), find_rendezvous_variable(), forget_invalid_pages(), forget_invalid_pages_db(), ForgetPrivateRefCountEntry(), get_attribute_options(), get_cast_hashentry(), get_rel_sync_entry(), get_relation_notnullatts(), get_tablespace(), GetComboCommandId(), GetConnection(), getConnectionByName(), GetExtensibleNodeEntry(), getmissingattr(), GetPrivateRefCountEntry(), getState(), GetWaitEventCustomIdentifier(), gistGetNodeBuffer(), gistGetParent(), gistMemorizeParent(), gistRelocateBuildBuffersOnSplit(), hash_object_field_end(), init_sequence(), insert_rel_type_cache_if_needed(), InvalidateAttoptCacheCallback(), InvalidateLocalBuffer(), InvalidateOprCacheCallBack(), InvalidateShippableCacheCallback(), InvalidateTableSpaceCacheCallback(), is_shippable(), JsObjectGetField(), json_unique_check_key(), LocalBufferAlloc(), LockAcquireExtended(), LockHasWaiters(), LockHeldByMe(), LockRelease(), log_invalid_page(), logical_rewrite_log_mapping(), logicalrep_partition_open(), logicalrep_rel_open(), logicalrep_relmap_update(), lookup_C_func(), lookup_proof_cache(), lookup_ts_config_cache(), lookup_ts_dictionary_cache(), lookup_ts_parser_cache(), lookup_type_cache(), LookupOpclassInfo(), make_oper_cache_entry(), MarkGUCPrefixReserved(), pa_allocate_worker(), pa_find_worker(), pa_free_worker(), PartitionDirectoryLookup(), pg_get_backend_memory_contexts(), pg_tzset(), pgss_store(), plperl_spi_exec_prepared(), plperl_spi_freeplan(), plperl_spi_prepare(), plperl_spi_query_prepared(), pltcl_fetch_interp(), PLy_commit(), PLy_generate_spi_exceptions(), PLy_procedure_get(), PLy_rollback(), PLy_spi_subtransaction_abort(), populate_recordset_object_field_end(), predicatelock_twophase_recover(), PredicateLockExists(), PredicateLockShmemInit(), PredicateLockTwoPhaseFinish(), PrefetchLocalBuffer(), process_syncing_tables_for_apply(), ProcessSyncRequests(), prune_element_hashtable(), prune_lexemes_hashtable(), PutMemoryContextsStatsTupleStore(), rebuild_database_list(), record_C_func(), RegisterExtensibleNodeEntry(), RegisterPredicateLockingXid(), rel_sync_cache_relation_cb(), RelationPreTruncate(), ReleaseOneSerializableXact(), RelFileLocatorSkippingWAL(), RelfilenumberMapInvalidateCallback(), RelidByRelfilenumber(), RememberSyncRequest(), RemoveLocalLock(), ReorderBufferBuildTupleCidHash(), ReorderBufferCleanupTXN(), ReorderBufferToastAppendChunk(), ReorderBufferToastReplace(), ReorderBufferTXNByXid(), ReservePrivateRefCountEntry(), ResetUnloggedRelationsInDbspaceDir(), ResolveCminCmaxDuringDecoding(), RestoreUncommittedEnums(), rewrite_heap_dead_tuple(), rewrite_heap_tuple(), ri_FetchPreparedPlan(), ri_HashCompareOp(), ri_HashPreparedPlan(), ri_LoadConstraintInfo(), select_perl_context(), SerializePendingSyncs(), set_rtable_names(), ShmemInitStruct(), smgrdestroy(), smgrDoPendingSyncs(), smgropen(), smgrreleaserellocator(), StandbyAcquireAccessExclusiveLock(), StandbyReleaseAllLocks(), StandbyReleaseLocks(), StandbyReleaseOldLocks(), StandbyReleaseXidEntryLocks(), StorePreparedStatement(), table_recheck_autovac(), TypeCacheRelCallback(), WaitEventCustomNew(), XLogPrefetcherAddFilter(), XLogPrefetcherCompleteFilters(), and XLogPrefetcherIsFiltered().

hash_search_with_hash_value()

void * hash_search_with_hash_value	(	HTAB *	hashp,
		const void *	keyPtr,
		uint32	hashvalue,
		HASHACTION	action,
		bool *	foundPtr
	)

Definition at line 965 of file dynahash.c.

{
    HASHHDR    *hctl = hashp->hctl;
    int         freelist_idx = FREELIST_IDX(hctl, hashvalue);
    Size        keysize;
    HASHBUCKET  currBucket;
    HASHBUCKET *prevBucketPtr;
    HashCompareFunc match;
 
#ifdef HASH_STATISTICS
    hctl->accesses++;
#endif
 
    /*
     * If inserting, check if it is time to split a bucket.
     *
     * NOTE: failure to expand table is not a fatal error, it just means we
     * have to run at higher fill factor than we wanted.  However, if we're
     * using the palloc allocator then it will throw error anyway on
     * out-of-memory, so we must do this before modifying the table.
     */
    if (action == HASH_ENTER || action == HASH_ENTER_NULL)
    {
        /*
         * Can't split if running in partitioned mode, nor if frozen, nor if
         * table is the subject of any active hash_seq_search scans.
         */
        if (hctl->freeList[0].nentries > (int64) hctl->max_bucket &&
            !IS_PARTITIONED(hctl) && !hashp->frozen &&
            !has_seq_scans(hashp))
            (void) expand_table(hashp);
    }
 
    /*
     * Do the initial lookup
     */
    (void) hash_initial_lookup(hashp, hashvalue, &prevBucketPtr);
    currBucket = *prevBucketPtr;
 
    /*
     * Follow collision chain looking for matching key
     */
    match = hashp->match;       /* save one fetch in inner loop */
    keysize = hashp->keysize;   /* ditto */
 
    while (currBucket != NULL)
    {
        if (currBucket->hashvalue == hashvalue &&
            match(ELEMENTKEY(currBucket), keyPtr, keysize) == 0)
            break;
        prevBucketPtr = &(currBucket->link);
        currBucket = *prevBucketPtr;
#ifdef HASH_STATISTICS
        hctl->collisions++;
#endif
    }
 
    if (foundPtr)
        *foundPtr = (bool) (currBucket != NULL);
 
    /*
     * OK, now what?
     */
    switch (action)
    {
        case HASH_FIND:
            if (currBucket != NULL)
                return ELEMENTKEY(currBucket);
            return NULL;
 
        case HASH_REMOVE:
            if (currBucket != NULL)
            {
                /* if partitioned, must lock to touch nentries and freeList */
                if (IS_PARTITIONED(hctl))
                    SpinLockAcquire(&(hctl->freeList[freelist_idx].mutex));
 
                /* delete the record from the appropriate nentries counter. */
                Assert(hctl->freeList[freelist_idx].nentries > 0);
                hctl->freeList[freelist_idx].nentries--;
 
                /* remove record from hash bucket's chain. */
                *prevBucketPtr = currBucket->link;
 
                /* add the record to the appropriate freelist. */
                currBucket->link = hctl->freeList[freelist_idx].freeList;
                hctl->freeList[freelist_idx].freeList = currBucket;
 
                if (IS_PARTITIONED(hctl))
                    SpinLockRelease(&hctl->freeList[freelist_idx].mutex);
 
                /*
                 * better hope the caller is synchronizing access to this
                 * element, because someone else is going to reuse it the next
                 * time something is added to the table
                 */
                return ELEMENTKEY(currBucket);
            }
            return NULL;
 
        case HASH_ENTER:
        case HASH_ENTER_NULL:
            /* Return existing element if found, else create one */
            if (currBucket != NULL)
                return ELEMENTKEY(currBucket);
 
            /* disallow inserts if frozen */
            if (hashp->frozen)
                elog(ERROR, "cannot insert into frozen hashtable \"%s\"",
                     hashp->tabname);
 
            currBucket = get_hash_entry(hashp, freelist_idx);
            if (currBucket == NULL)
            {
                /* out of memory */
                if (action == HASH_ENTER_NULL)
                    return NULL;
                /* report a generic message */
                if (hashp->isshared)
                    ereport(ERROR,
                            (errcode(ERRCODE_OUT_OF_MEMORY),
                             errmsg("out of shared memory")));
                else
                    ereport(ERROR,
                            (errcode(ERRCODE_OUT_OF_MEMORY),
                             errmsg("out of memory")));
            }
 
            /* link into hashbucket chain */
            *prevBucketPtr = currBucket;
            currBucket->link = NULL;
 
            /* copy key into record */
            currBucket->hashvalue = hashvalue;
            hashp->keycopy(ELEMENTKEY(currBucket), keyPtr, keysize);
 
            /*
             * Caller is expected to fill the data field on return.  DO NOT
             * insert any code that could possibly throw error here, as doing
             * so would leave the table entry incomplete and hence corrupt the
             * caller's data structure.
             */
 
            return ELEMENTKEY(currBucket);
    }
 
    elog(ERROR, "unrecognized hash action code: %d", (int) action);
 
    return NULL;                /* keep compiler quiet */
}

References generate_unaccent_rules::action, Assert(), ELEMENTKEY, elog, ereport, errcode(), errmsg(), ERROR, expand_table(), FreeListData::freeList, HASHHDR::freeList, FREELIST_IDX, HTAB::frozen, get_hash_entry(), has_seq_scans(), HASH_ENTER, HASH_ENTER_NULL, HASH_FIND, hash_initial_lookup(), HASH_REMOVE, HASHELEMENT::hashvalue, HTAB::hctl, IS_PARTITIONED, HTAB::isshared, HTAB::keycopy, HTAB::keysize, HASHELEMENT::link, HTAB::match, HASHHDR::max_bucket, FreeListData::mutex, FreeListData::nentries, SpinLockAcquire, SpinLockRelease, and HTAB::tabname.

Referenced by BufTableDelete(), BufTableInsert(), BufTableLookup(), CheckTargetForConflictsIn(), CleanUpLock(), ClearOldPredicateLocks(), CreatePredicateLock(), DecrementParentLocks(), DeleteChildTargetLocks(), DeleteLockTarget(), DropAllPredicateLocksFromTable(), FastPathGetRelationLockEntry(), GetLockConflicts(), hash_search(), lock_twophase_recover(), LockAcquireExtended(), LockRefindAndRelease(), LockRelease(), LockWaiterCount(), PageIsPredicateLocked(), PredicateLockAcquire(), ReleaseOneSerializableXact(), RemoveScratchTarget(), RemoveTargetIfNoLongerUsed(), RestoreScratchTarget(), SetupLockInTable(), and TransferPredicateLocksToNewTarget().

hash_select_dirsize()

int64 hash_select_dirsize

(

int64

num_entries

)

Definition at line 830 of file dynahash.c.

{
    int64       nBuckets,
                nSegments,
                nDirEntries;
 
    /* estimate number of buckets wanted */
    nBuckets = next_pow2_int64(num_entries);
    /* # of segments needed for nBuckets */
    nSegments = next_pow2_int64((nBuckets - 1) / DEF_SEGSIZE + 1);
    /* directory entries */
    nDirEntries = DEF_DIRSIZE;
    while (nDirEntries < nSegments)
        nDirEntries <<= 1;      /* dir_alloc doubles dsize at each call */
 
    return nDirEntries;
}

References DEF_DIRSIZE, DEF_SEGSIZE, and next_pow2_int64().

Referenced by ShmemInitHash().

hash_seq_init()

void hash_seq_init	(	HASH_SEQ_STATUS *	status,
		HTAB *	hashp
	)

Definition at line 1380 of file dynahash.c.

{
    status->hashp = hashp;
    status->curBucket = 0;
    status->curEntry = NULL;
    status->hasHashvalue = false;
    if (!hashp->frozen)
        register_seq_scan(hashp);
}

References HASH_SEQ_STATUS::curBucket, HASH_SEQ_STATUS::curEntry, HTAB::frozen, HASH_SEQ_STATUS::hasHashvalue, HASH_SEQ_STATUS::hashp, and register_seq_scan().

Referenced by AtAbort_Portals(), AtCleanup_Portals(), AtEOSubXact_RelationCache(), AtEOXact_RelationCache(), AtPrepare_Locks(), AtSubAbort_Portals(), AtSubCleanup_Portals(), AtSubCommit_Portals(), BeginReportingGUCOptions(), CheckForBufferLeaks(), CheckForSessionAndXactLocks(), CheckTableForSerializableConflictIn(), cleanup_rel_sync_cache(), compute_array_stats(), compute_tsvector_stats(), dblink_get_connections(), DestroyPartitionDirectory(), disconnect_cached_connections(), DropAllPredicateLocksFromTable(), DropAllPreparedStatements(), end_heap_rewrite(), entry_dealloc(), entry_reset(), ExecuteTruncateGuts(), forget_invalid_pages(), forget_invalid_pages_db(), ForgetPortalSnapshots(), gc_qtexts(), get_guc_variables(), GetLockStatusData(), GetPredicateLockStatusData(), GetRunningTransactionLocks(), GetWaitEventCustomNames(), hash_seq_init_with_hash_value(), HoldPinnedPortals(), InitializeGUCOptions(), InvalidateAttoptCacheCallback(), InvalidateOprCacheCallBack(), InvalidateOprProofCacheCallBack(), InvalidateShippableCacheCallback(), InvalidateTableSpaceCacheCallback(), InvalidateTSCacheCallBack(), LockReassignCurrentOwner(), LockReleaseAll(), LockReleaseCurrentOwner(), LockReleaseSession(), logical_end_heap_rewrite(), logical_heap_rewrite_flush_mappings(), logicalrep_partmap_invalidate_cb(), logicalrep_partmap_reset_relmap(), logicalrep_relmap_invalidate_cb(), MarkGUCPrefixReserved(), packGraph(), pg_cursor(), pg_get_shmem_allocations(), pg_get_shmem_allocations_numa(), pg_prepared_statement(), pg_stat_statements_internal(), pgfdw_inval_callback(), pgfdw_subxact_callback(), pgfdw_xact_callback(), pgss_shmem_shutdown(), plperl_fini(), PortalErrorCleanup(), PortalHashTableDeleteAll(), postgres_fdw_get_connections_internal(), PostPrepare_Locks(), PreCommit_Portals(), ProcessConfigFileInternal(), ProcessSyncRequests(), prune_element_hashtable(), prune_lexemes_hashtable(), rebuild_database_list(), rel_sync_cache_publication_cb(), rel_sync_cache_relation_cb(), RelationCacheInitializePhase3(), RelationCacheInvalidate(), RelfilenumberMapInvalidateCallback(), RememberSyncRequest(), ReorderBufferToastReset(), selectColorTrigrams(), SerializePendingSyncs(), SerializeUncommittedEnums(), smgrDoPendingSyncs(), smgrreleaseall(), StandbyReleaseAllLocks(), StandbyReleaseOldLocks(), ThereAreNoReadyPortals(), TypeCacheOpcCallback(), TypeCacheRelCallback(), TypeCacheTypCallback(), write_relcache_init_file(), and XLogCheckInvalidPages().

hash_seq_init_with_hash_value()

void hash_seq_init_with_hash_value	(	HASH_SEQ_STATUS *	status,
		HTAB *	hashp,
		uint32	hashvalue
	)

Definition at line 1400 of file dynahash.c.

{
    HASHBUCKET *bucketPtr;
 
    hash_seq_init(status, hashp);
 
    status->hasHashvalue = true;
    status->hashvalue = hashvalue;
 
    status->curBucket = hash_initial_lookup(hashp, hashvalue, &bucketPtr);
    status->curEntry = *bucketPtr;
}

References HASH_SEQ_STATUS::curBucket, HASH_SEQ_STATUS::curEntry, hash_initial_lookup(), hash_seq_init(), HASH_SEQ_STATUS::hasHashvalue, and HASH_SEQ_STATUS::hashvalue.

Referenced by InvalidateAttoptCacheCallback(), and TypeCacheTypCallback().

hash_seq_search()

void * hash_seq_search

(

HASH_SEQ_STATUS *

status

)

Definition at line 1415 of file dynahash.c.

{
    HTAB       *hashp;
    HASHHDR    *hctl;
    uint32      max_bucket;
    int64       ssize;
    int64       segment_num;
    int64       segment_ndx;
    HASHSEGMENT segp;
    uint32      curBucket;
    HASHELEMENT *curElem;
 
    if (status->hasHashvalue)
    {
        /*
         * Scan entries only in the current bucket because only this bucket
         * can contain entries with the given hash value.
         */
        while ((curElem = status->curEntry) != NULL)
        {
            status->curEntry = curElem->link;
            if (status->hashvalue != curElem->hashvalue)
                continue;
            return (void *) ELEMENTKEY(curElem);
        }
 
        hash_seq_term(status);
        return NULL;
    }
 
    if ((curElem = status->curEntry) != NULL)
    {
        /* Continuing scan of curBucket... */
        status->curEntry = curElem->link;
        if (status->curEntry == NULL)   /* end of this bucket */
            ++status->curBucket;
        return ELEMENTKEY(curElem);
    }
 
    /*
     * Search for next nonempty bucket starting at curBucket.
     */
    curBucket = status->curBucket;
    hashp = status->hashp;
    hctl = hashp->hctl;
    ssize = hashp->ssize;
    max_bucket = hctl->max_bucket;
 
    if (curBucket > max_bucket)
    {
        hash_seq_term(status);
        return NULL;            /* search is done */
    }
 
    /*
     * first find the right segment in the table directory.
     */
    segment_num = curBucket >> hashp->sshift;
    segment_ndx = MOD(curBucket, ssize);
 
    segp = hashp->dir[segment_num];
 
    /*
     * Pick up the first item in this bucket's chain.  If chain is not empty
     * we can begin searching it.  Otherwise we have to advance to find the
     * next nonempty bucket.  We try to optimize that case since searching a
     * near-empty hashtable has to iterate this loop a lot.
     */
    while ((curElem = segp[segment_ndx]) == NULL)
    {
        /* empty bucket, advance to next */
        if (++curBucket > max_bucket)
        {
            status->curBucket = curBucket;
            hash_seq_term(status);
            return NULL;        /* search is done */
        }
        if (++segment_ndx >= ssize)
        {
            segment_num++;
            segment_ndx = 0;
            segp = hashp->dir[segment_num];
        }
    }
 
    /* Begin scan of curBucket... */
    status->curEntry = curElem->link;
    if (status->curEntry == NULL)   /* end of this bucket */
        ++curBucket;
    status->curBucket = curBucket;
    return ELEMENTKEY(curElem);
}

References HASH_SEQ_STATUS::curBucket, HASH_SEQ_STATUS::curEntry, HTAB::dir, ELEMENTKEY, hash_seq_term(), HASH_SEQ_STATUS::hasHashvalue, HASH_SEQ_STATUS::hashp, HASHELEMENT::hashvalue, HASH_SEQ_STATUS::hashvalue, HTAB::hctl, HASHELEMENT::link, HASHHDR::max_bucket, MOD, HTAB::sshift, and HTAB::ssize.

Referenced by AtAbort_Portals(), AtCleanup_Portals(), AtEOSubXact_RelationCache(), AtEOXact_RelationCache(), AtPrepare_Locks(), AtSubAbort_Portals(), AtSubCleanup_Portals(), AtSubCommit_Portals(), BeginReportingGUCOptions(), CheckForBufferLeaks(), CheckForSessionAndXactLocks(), CheckTableForSerializableConflictIn(), cleanup_rel_sync_cache(), compute_array_stats(), compute_tsvector_stats(), dblink_get_connections(), DestroyPartitionDirectory(), disconnect_cached_connections(), DropAllPredicateLocksFromTable(), DropAllPreparedStatements(), end_heap_rewrite(), entry_dealloc(), entry_reset(), ExecuteTruncateGuts(), forget_invalid_pages(), forget_invalid_pages_db(), ForgetPortalSnapshots(), gc_qtexts(), get_guc_variables(), GetLockStatusData(), GetPredicateLockStatusData(), GetRunningTransactionLocks(), GetWaitEventCustomNames(), HoldPinnedPortals(), InitializeGUCOptions(), InvalidateAttoptCacheCallback(), InvalidateOprCacheCallBack(), InvalidateOprProofCacheCallBack(), InvalidateShippableCacheCallback(), InvalidateTableSpaceCacheCallback(), InvalidateTSCacheCallBack(), LockReassignCurrentOwner(), LockReleaseAll(), LockReleaseCurrentOwner(), LockReleaseSession(), logical_end_heap_rewrite(), logical_heap_rewrite_flush_mappings(), logicalrep_partmap_invalidate_cb(), logicalrep_partmap_reset_relmap(), logicalrep_relmap_invalidate_cb(), MarkGUCPrefixReserved(), packGraph(), pg_cursor(), pg_get_shmem_allocations(), pg_get_shmem_allocations_numa(), pg_prepared_statement(), pg_stat_statements_internal(), pgfdw_inval_callback(), pgfdw_subxact_callback(), pgfdw_xact_callback(), pgss_shmem_shutdown(), plperl_fini(), PortalErrorCleanup(), PortalHashTableDeleteAll(), postgres_fdw_get_connections_internal(), PostPrepare_Locks(), PreCommit_Portals(), ProcessConfigFileInternal(), ProcessSyncRequests(), prune_element_hashtable(), prune_lexemes_hashtable(), rebuild_database_list(), rel_sync_cache_publication_cb(), rel_sync_cache_relation_cb(), RelationCacheInitializePhase3(), RelationCacheInvalidate(), RelfilenumberMapInvalidateCallback(), RememberSyncRequest(), ReorderBufferToastReset(), selectColorTrigrams(), SerializePendingSyncs(), SerializeUncommittedEnums(), smgrDoPendingSyncs(), smgrreleaseall(), StandbyReleaseAllLocks(), StandbyReleaseOldLocks(), ThereAreNoReadyPortals(), TypeCacheOpcCallback(), TypeCacheRelCallback(), TypeCacheTypCallback(), write_relcache_init_file(), and XLogCheckInvalidPages().

hash_seq_term()

void hash_seq_term

(

HASH_SEQ_STATUS *

status

)

Definition at line 1509 of file dynahash.c.

{
    if (!status->hashp->frozen)
        deregister_seq_scan(status->hashp);
}

References deregister_seq_scan(), HTAB::frozen, and HASH_SEQ_STATUS::hashp.

Referenced by gc_qtexts(), hash_seq_search(), logicalrep_partmap_invalidate_cb(), logicalrep_relmap_invalidate_cb(), pgss_shmem_shutdown(), PortalHashTableDeleteAll(), PreCommit_Portals(), and RelationCacheInitializePhase3().

hash_stats()

void hash_stats	(	const char *	caller,
		HTAB *	hashp
	)

Definition at line 884 of file dynahash.c.

{
#ifdef HASH_STATISTICS
    HASHHDR    *hctl = hashp->hctl;
 
    elog(DEBUG4,
         "hash_stats:  Caller: %s  Table Name: \"%s\"  Accesses: " UINT64_FORMAT "  Collisions: " UINT64_FORMAT "  Expansions: " UINT64_FORMAT "  Entries: " INT64_FORMAT "  Key Size: %zu  Max Bucket: %u  Segment Count: " INT64_FORMAT,
         caller != NULL ? caller : "(unknown)", hashp->tabname, hctl->accesses,
         hctl->collisions, hctl->expansions, hash_get_num_entries(hashp),
         hctl->keysize, hctl->max_bucket, hctl->nsegs);
#endif
}

References DEBUG4, elog, hash_get_num_entries(), HTAB::hctl, INT64_FORMAT, HASHHDR::keysize, HASHHDR::max_bucket, HASHHDR::nsegs, HTAB::tabname, and UINT64_FORMAT.

Referenced by hash_destroy().

hash_update_hash_key()

bool hash_update_hash_key	(	HTAB *	hashp,
		void *	existingEntry,
		const void *	newKeyPtr
	)

Definition at line 1140 of file dynahash.c.

{
    HASHELEMENT *existingElement = ELEMENT_FROM_KEY(existingEntry);
    uint32      newhashvalue;
    Size        keysize;
    uint32      bucket;
    uint32      newbucket;
    HASHBUCKET  currBucket;
    HASHBUCKET *prevBucketPtr;
    HASHBUCKET *oldPrevPtr;
    HashCompareFunc match;
 
#ifdef HASH_STATISTICS
    HASHHDR    *hctl = hashp->hctl;
 
    hctl->accesses++;
#endif
 
    /* disallow updates if frozen */
    if (hashp->frozen)
        elog(ERROR, "cannot update in frozen hashtable \"%s\"",
             hashp->tabname);
 
    /*
     * Lookup the existing element using its saved hash value.  We need to do
     * this to be able to unlink it from its hash chain, but as a side benefit
     * we can verify the validity of the passed existingEntry pointer.
     */
    bucket = hash_initial_lookup(hashp, existingElement->hashvalue,
                                 &prevBucketPtr);
    currBucket = *prevBucketPtr;
 
    while (currBucket != NULL)
    {
        if (currBucket == existingElement)
            break;
        prevBucketPtr = &(currBucket->link);
        currBucket = *prevBucketPtr;
    }
 
    if (currBucket == NULL)
        elog(ERROR, "hash_update_hash_key argument is not in hashtable \"%s\"",
             hashp->tabname);
 
    oldPrevPtr = prevBucketPtr;
 
    /*
     * Now perform the equivalent of a HASH_ENTER operation to locate the hash
     * chain we want to put the entry into.
     */
    newhashvalue = hashp->hash(newKeyPtr, hashp->keysize);
    newbucket = hash_initial_lookup(hashp, newhashvalue, &prevBucketPtr);
    currBucket = *prevBucketPtr;
 
    /*
     * Follow collision chain looking for matching key
     */
    match = hashp->match;       /* save one fetch in inner loop */
    keysize = hashp->keysize;   /* ditto */
 
    while (currBucket != NULL)
    {
        if (currBucket->hashvalue == newhashvalue &&
            match(ELEMENTKEY(currBucket), newKeyPtr, keysize) == 0)
            break;
        prevBucketPtr = &(currBucket->link);
        currBucket = *prevBucketPtr;
#ifdef HASH_STATISTICS
        hctl->collisions++;
#endif
    }
 
    if (currBucket != NULL)
        return false;           /* collision with an existing entry */
 
    currBucket = existingElement;
 
    /*
     * If old and new hash values belong to the same bucket, we need not
     * change any chain links, and indeed should not since this simplistic
     * update will corrupt the list if currBucket is the last element.  (We
     * cannot fall out earlier, however, since we need to scan the bucket to
     * check for duplicate keys.)
     */
    if (bucket != newbucket)
    {
        /* OK to remove record from old hash bucket's chain. */
        *oldPrevPtr = currBucket->link;
 
        /* link into new hashbucket chain */
        *prevBucketPtr = currBucket;
        currBucket->link = NULL;
    }
 
    /* copy new key into record */
    currBucket->hashvalue = newhashvalue;
    hashp->keycopy(ELEMENTKEY(currBucket), newKeyPtr, keysize);
 
    /* rest of record is untouched */
 
    return true;
}

References ELEMENT_FROM_KEY, ELEMENTKEY, elog, ERROR, HTAB::frozen, HTAB::hash, hash_initial_lookup(), HASHELEMENT::hashvalue, HTAB::hctl, HTAB::keycopy, HTAB::keysize, HASHELEMENT::link, HTAB::match, and HTAB::tabname.

Referenced by PostPrepare_Locks().