attoptcache.c File Reference

#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"

Include dependency graph for attoptcache.c:

Go to the source code of this file.

Data Structures
struct	AttoptCacheKey
struct	AttoptCacheEntry

Functions
static void	InvalidateAttoptCacheCallback (Datum arg, SysCacheIdentifier cacheid, uint32 hashvalue)
static uint32	relatt_cache_syshash (const void *key, Size keysize)
static void	InitializeAttoptCache (void)
AttributeOpts *	get_attribute_options (Oid attrelid, int attnum)

Variables
static HTAB *	AttoptCacheHash = NULL

Function Documentation

get_attribute_options()

AttributeOpts * get_attribute_options	(	Oid	attrelid,
		int	attnum
	)

Definition at line 132 of file attoptcache.c.

{
    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;
}

References attnum, AttoptCacheHash, attribute_reloptions(), CacheMemoryContext, fb(), HASH_ENTER, HASH_FIND, hash_search(), HeapTupleIsValid, InitializeAttoptCache(), Int16GetDatum(), MemoryContextAlloc(), ObjectIdGetDatum(), opts, palloc(), ReleaseSysCache(), SearchSysCache2(), SysCacheGetAttr(), and VARSIZE().

Referenced by compute_expr_stats(), and do_analyze_rel().

InitializeAttoptCache()

static void InitializeAttoptCache ( void  )

static

Definition at line 98 of file attoptcache.c.

{
    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);
}

References AttoptCacheHash, CacheMemoryContext, CacheRegisterSyscacheCallback(), CreateCacheMemoryContext(), ctl, fb(), hash_create(), HASH_ELEM, HASH_FUNCTION, InvalidateAttoptCacheCallback(), HASHCTL::keysize, and relatt_cache_syshash().

Referenced by get_attribute_options().

InvalidateAttoptCacheCallback()

static void InvalidateAttoptCacheCallback ( Datum  arg, SysCacheIdentifier  cacheid, uint32  hashvalue  )

static

Definition at line 53 of file attoptcache.c.

{
    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");
    }
}

References AttoptCacheHash, elog, ERROR, fb(), HASH_REMOVE, hash_search(), hash_seq_init(), hash_seq_init_with_hash_value(), hash_seq_search(), and pfree().

Referenced by InitializeAttoptCache().

relatt_cache_syshash()

static uint32 relatt_cache_syshash ( const void *  key, Size  keysize  )

static

Definition at line 85 of file attoptcache.c.

{
    const AttoptCacheKey *ckey = key;
 
    Assert(keysize == sizeof(*ckey));
    return GetSysCacheHashValue2(ATTNUM, ObjectIdGetDatum(ckey->attrelid), Int32GetDatum(ckey->attnum));
}

References Assert, fb(), GetSysCacheHashValue2, Int32GetDatum(), and ObjectIdGetDatum().

Referenced by InitializeAttoptCache().

Variable Documentation

AttoptCacheHash

HTAB* AttoptCacheHash = NULL

static

Definition at line 29 of file attoptcache.c.

Referenced by get_attribute_options(), InitializeAttoptCache(), and InvalidateAttoptCacheCallback().