attoptcache.c

Go to the documentation of this file.

/*-------------------------------------------------------------------------
 *
 * attoptcache.c
 *    Attribute options cache management.
 *
 * Attribute options are cached separately from the fixed-size portion of
 * pg_attribute entries, which are handled by the relcache.
 *
 * Portions Copyright (c) 1996-2026, PostgreSQL Global Development Group
 * Portions Copyright (c) 1994, Regents of the University of California
 *
 * IDENTIFICATION
 *    src/backend/utils/cache/attoptcache.c
 *
 *-------------------------------------------------------------------------
 */
#include "postgres.h"
 
#include "access/reloptions.h"
#include "utils/attoptcache.h"
#include "utils/catcache.h"
#include "utils/hsearch.h"
#include "utils/inval.h"
#include "utils/syscache.h"
#include "varatt.h"
 
 
/* Hash table for information about each attribute's options */
static HTAB *AttoptCacheHash = NULL;
 
/* attrelid and attnum form the lookup key, and must appear first */
typedef struct
{
    Oid         attrelid;
    int         attnum;
} AttoptCacheKey;
 
typedef struct
{
    AttoptCacheKey key;         /* lookup key - must be first */
    AttributeOpts *opts;        /* options, or NULL if none */
} AttoptCacheEntry;
 
 
/*
 * InvalidateAttoptCacheCallback
 *      Flush cache entry (or entries) when pg_attribute is updated.
 *
 * When pg_attribute is updated, we must flush the cache entry at least
 * for that attribute.
 */
static void
InvalidateAttoptCacheCallback(Datum arg, SysCacheIdentifier cacheid,
                              uint32 hashvalue)
{
    HASH_SEQ_STATUS status;
    AttoptCacheEntry *attopt;
 
    /*
     * By convention, zero hash value is passed to the callback as a sign that
     * it's time to invalidate the whole cache. See sinval.c, inval.c and
     * InvalidateSystemCachesExtended().
     */
    if (hashvalue == 0)
        hash_seq_init(&status, AttoptCacheHash);
    else
        hash_seq_init_with_hash_value(&status, AttoptCacheHash, hashvalue);
 
    while ((attopt = (AttoptCacheEntry *) hash_seq_search(&status)) != NULL)
    {
        if (attopt->opts)
            pfree(attopt->opts);
        if (hash_search(AttoptCacheHash,
                        &attopt->key,
                        HASH_REMOVE,
                        NULL) == NULL)
            elog(ERROR, "hash table corrupted");
    }
}
 
/*
 * Hash function compatible with two-arg system cache hash function.
 */
static uint32
relatt_cache_syshash(const void *key, Size keysize)
{
    const AttoptCacheKey *ckey = key;
 
    Assert(keysize == sizeof(*ckey));
    return GetSysCacheHashValue2(ATTNUM, ObjectIdGetDatum(ckey->attrelid), Int32GetDatum(ckey->attnum));
}
 
/*
 * InitializeAttoptCache
 *      Initialize the attribute options cache.
 */
static void
InitializeAttoptCache(void)
{
    HASHCTL     ctl;
 
    /* Initialize the hash table. */
    ctl.keysize = sizeof(AttoptCacheKey);
    ctl.entrysize = sizeof(AttoptCacheEntry);
 
    /*
     * AttoptCacheEntry takes hash value from the system cache. For
     * AttoptCacheHash we use the same hash in order to speedup search by hash
     * value. This is used by hash_seq_init_with_hash_value().
     */
    ctl.hash = relatt_cache_syshash;
 
    AttoptCacheHash =
        hash_create("Attopt cache", 256, &ctl,
                    HASH_ELEM | HASH_FUNCTION);
 
    /* Make sure we've initialized CacheMemoryContext. */
    if (!CacheMemoryContext)
        CreateCacheMemoryContext();
 
    /* Watch for invalidation events. */
    CacheRegisterSyscacheCallback(ATTNUM,
                                  InvalidateAttoptCacheCallback,
                                  (Datum) 0);
}
 
/*
 * get_attribute_options
 *      Fetch attribute options for a specified table OID.
 */
AttributeOpts *
get_attribute_options(Oid attrelid, int attnum)
{
    AttoptCacheKey key;
    AttoptCacheEntry *attopt;
    AttributeOpts *result;
    HeapTuple   tp;
 
    /* Find existing cache entry, if any. */
    if (!AttoptCacheHash)
        InitializeAttoptCache();
    memset(&key, 0, sizeof(key));   /* make sure any padding bits are unset */
    key.attrelid = attrelid;
    key.attnum = attnum;
    attopt =
        (AttoptCacheEntry *) hash_search(AttoptCacheHash,
                                         &key,
                                         HASH_FIND,
                                         NULL);
 
    /* Not found in Attopt cache.  Construct new cache entry. */
    if (!attopt)
    {
        AttributeOpts *opts;
 
        tp = SearchSysCache2(ATTNUM,
                             ObjectIdGetDatum(attrelid),
                             Int16GetDatum(attnum));
 
        /*
         * If we don't find a valid HeapTuple, it must mean someone has
         * managed to request attribute details for a non-existent attribute.
         * We treat that case as if no options were specified.
         */
        if (!HeapTupleIsValid(tp))
            opts = NULL;
        else
        {
            Datum       datum;
            bool        isNull;
 
            datum = SysCacheGetAttr(ATTNUM,
                                    tp,
                                    Anum_pg_attribute_attoptions,
                                    &isNull);
            if (isNull)
                opts = NULL;
            else
            {
                bytea      *bytea_opts = attribute_reloptions(datum, false);
 
                opts = MemoryContextAlloc(CacheMemoryContext,
                                          VARSIZE(bytea_opts));
                memcpy(opts, bytea_opts, VARSIZE(bytea_opts));
            }
            ReleaseSysCache(tp);
        }
 
        /*
         * It's important to create the actual cache entry only after reading
         * pg_attribute, since the read could cause a cache flush.
         */
        attopt = (AttoptCacheEntry *) hash_search(AttoptCacheHash,
                                                  &key,
                                                  HASH_ENTER,
                                                  NULL);
        attopt->opts = opts;
    }
 
    /* Return results in caller's memory context. */
    if (attopt->opts == NULL)
        return NULL;
    result = palloc(VARSIZE(attopt->opts));
    memcpy(result, attopt->opts, VARSIZE(attopt->opts));
    return result;
}