catcache.h File Reference

#include "access/htup.h"
#include "access/skey.h"
#include "lib/ilist.h"
#include "utils/relcache.h"

Include dependency graph for catcache.h:

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

Go to the source code of this file.

Data Structures
struct	catcache
struct	catctup
struct	catclist
struct	catcacheheader

Macros
#define	CATCACHE_MAXKEYS   4
#define	CT_MAGIC   0x57261502
#define	CL_MAGIC   0x52765103

Typedefs
typedef uint32(*	CCHashFN) (Datum datum)
typedef bool(*	CCFastEqualFN) (Datum a, Datum b)
typedef struct catcache	CatCache
typedef struct catctup	CatCTup
typedef struct catclist	CatCList
typedef struct catcacheheader	CatCacheHeader

Functions
void	CreateCacheMemoryContext (void)
CatCache *	InitCatCache (int id, Oid reloid, Oid indexoid, int nkeys, const int *key, int nbuckets)
void	InitCatCachePhase2 (CatCache *cache, bool touch_index)
HeapTuple	SearchCatCache (CatCache *cache, Datum v1, Datum v2, Datum v3, Datum v4)
HeapTuple	SearchCatCache1 (CatCache *cache, Datum v1)
HeapTuple	SearchCatCache2 (CatCache *cache, Datum v1, Datum v2)
HeapTuple	SearchCatCache3 (CatCache *cache, Datum v1, Datum v2, Datum v3)
HeapTuple	SearchCatCache4 (CatCache *cache, Datum v1, Datum v2, Datum v3, Datum v4)
void	ReleaseCatCache (HeapTuple tuple)
uint32	GetCatCacheHashValue (CatCache *cache, Datum v1, Datum v2, Datum v3, Datum v4)
CatCList *	SearchCatCacheList (CatCache *cache, int nkeys, Datum v1, Datum v2, Datum v3)
void	ReleaseCatCacheList (CatCList *list)
void	ResetCatalogCaches (void)
void	ResetCatalogCachesExt (bool debug_discard)
void	CatalogCacheFlushCatalog (Oid catId)
void	CatCacheInvalidate (CatCache *cache, uint32 hashValue)
void	PrepareToInvalidateCacheTuple (Relation relation, HeapTuple tuple, HeapTuple newtuple, void(*function)(int, uint32, Oid, void *), void *context)

Variables
PGDLLIMPORT MemoryContext	CacheMemoryContext

Macro Definition Documentation

CATCACHE_MAXKEYS

#define CATCACHE_MAXKEYS   4

Definition at line 35 of file catcache.h.

CL_MAGIC

#define CL_MAGIC   0x52765103

Definition at line 166 of file catcache.h.

CT_MAGIC

#define CT_MAGIC   0x57261502

Definition at line 99 of file catcache.h.

Typedef Documentation

CatCache

typedef struct catcache CatCache

CatCacheHeader

typedef struct catcacheheader CatCacheHeader

CatCList

typedef struct catclist CatCList

CatCTup

typedef struct catctup CatCTup

CCFastEqualFN

typedef bool(* CCFastEqualFN) (Datum a, Datum b)

Definition at line 42 of file catcache.h.

CCHashFN

typedef uint32(* CCHashFN) (Datum datum)

Definition at line 39 of file catcache.h.

Function Documentation

CatalogCacheFlushCatalog()

void CatalogCacheFlushCatalog

(

Oid

catId

)

Definition at line 841 of file catcache.c.

{
    slist_iter  iter;
 
    CACHE_elog(DEBUG2, "CatalogCacheFlushCatalog called for %u", catId);
 
    slist_foreach(iter, &CacheHdr->ch_caches)
    {
        CatCache   *cache = slist_container(CatCache, cc_next, iter.cur);
 
        /* Does this cache store tuples of the target catalog? */
        if (cache->cc_reloid == catId)
        {
            /* Yes, so flush all its contents */
            ResetCatalogCache(cache, false);
 
            /* Tell inval.c to call syscache callbacks for this cache */
            CallSyscacheCallbacks(cache->id, 0);
        }
    }
 
    CACHE_elog(DEBUG2, "end of CatalogCacheFlushCatalog call");
}

References CatCInProgress::cache, CACHE_elog, CacheHdr, CallSyscacheCallbacks(), catcache::cc_reloid, catcacheheader::ch_caches, slist_iter::cur, DEBUG2, catcache::id, ResetCatalogCache(), slist_container, and slist_foreach.

Referenced by LocalExecuteInvalidationMessage().

CatCacheInvalidate()

void CatCacheInvalidate	(	CatCache *	cache,
		uint32	hashValue
	)

Definition at line 632 of file catcache.c.

{
    Index       hashIndex;
    dlist_mutable_iter iter;
 
    CACHE_elog(DEBUG2, "CatCacheInvalidate: called");
 
    /*
     * We don't bother to check whether the cache has finished initialization
     * yet; if not, there will be no entries in it so no problem.
     */
 
    /*
     * Invalidate *all* CatCLists in this cache; it's too hard to tell which
     * searches might still be correct, so just zap 'em all.
     */
    for (int i = 0; i < cache->cc_nlbuckets; i++)
    {
        dlist_head *bucket = &cache->cc_lbucket[i];
 
        dlist_foreach_modify(iter, bucket)
        {
            CatCList   *cl = dlist_container(CatCList, cache_elem, iter.cur);
 
            if (cl->refcount > 0)
                cl->dead = true;
            else
                CatCacheRemoveCList(cache, cl);
        }
    }
 
    /*
     * inspect the proper hash bucket for tuple matches
     */
    hashIndex = HASH_INDEX(hashValue, cache->cc_nbuckets);
    dlist_foreach_modify(iter, &cache->cc_bucket[hashIndex])
    {
        CatCTup    *ct = dlist_container(CatCTup, cache_elem, iter.cur);
 
        if (hashValue == ct->hash_value)
        {
            if (ct->refcount > 0 ||
                (ct->c_list && ct->c_list->refcount > 0))
            {
                ct->dead = true;
                /* list, if any, was marked dead above */
                Assert(ct->c_list == NULL || ct->c_list->dead);
            }
            else
                CatCacheRemoveCTup(cache, ct);
            CACHE_elog(DEBUG2, "CatCacheInvalidate: invalidated");
#ifdef CATCACHE_STATS
            cache->cc_invals++;
#endif
            /* could be multiple matches, so keep looking! */
        }
    }
 
    /* Also invalidate any entries that are being built */
    for (CatCInProgress *e = catcache_in_progress_stack; e != NULL; e = e->next)
    {
        if (e->cache == cache)
        {
            if (e->list || e->hash_value == hashValue)
                e->dead = true;
        }
    }
}

References Assert(), catctup::c_list, CatCInProgress::cache, CACHE_elog, catcache_in_progress_stack, CatCacheRemoveCList(), CatCacheRemoveCTup(), catcache::cc_bucket, catcache::cc_lbucket, catcache::cc_nbuckets, catcache::cc_nlbuckets, dlist_mutable_iter::cur, catctup::dead, catclist::dead, DEBUG2, dlist_container, dlist_foreach_modify, HASH_INDEX, catctup::hash_value, i, CatCInProgress::next, catctup::refcount, and catclist::refcount.

Referenced by SysCacheInvalidate().

CreateCacheMemoryContext()

void CreateCacheMemoryContext

(

void

)

Definition at line 715 of file catcache.c.

{
    /*
     * Purely for paranoia, check that context doesn't exist; caller probably
     * did so already.
     */
    if (!CacheMemoryContext)
        CacheMemoryContext = AllocSetContextCreate(TopMemoryContext,
                                                   "CacheMemoryContext",
                                                   ALLOCSET_DEFAULT_SIZES);
}

References ALLOCSET_DEFAULT_SIZES, AllocSetContextCreate, CacheMemoryContext, and TopMemoryContext.

Referenced by assign_record_type_typmod(), BuildEventTriggerCache(), init_ts_config_cache(), InitCatCache(), InitializeAttoptCache(), InitializeRelfilenumberMap(), InitializeTableSpaceCache(), lookup_ts_dictionary_cache(), lookup_ts_parser_cache(), lookup_type_cache(), LookupOpclassInfo(), RelationBuildLocalRelation(), and RelationCacheInitialize().

GetCatCacheHashValue()

uint32 GetCatCacheHashValue	(	CatCache *	cache,
		Datum	v1,
		Datum	v2,
		Datum	v3,
		Datum	v4
	)

Definition at line 1707 of file catcache.c.

{
    /*
     * one-time startup overhead for each cache
     */
    ConditionalCatalogCacheInitializeCache(cache);
 
    /*
     * calculate the hash value
     */
    return CatalogCacheComputeHashValue(cache, cache->cc_nkeys, v1, v2, v3, v4);
}

References CatCInProgress::cache, CatalogCacheComputeHashValue(), catcache::cc_nkeys, and ConditionalCatalogCacheInitializeCache().

Referenced by GetSysCacheHashValue().

InitCatCache()

CatCache * InitCatCache	(	int	id,
		Oid	reloid,
		Oid	indexoid,
		int	nkeys,
		const int *	key,
		int	nbuckets
	)

Definition at line 885 of file catcache.c.

{
    CatCache   *cp;
    MemoryContext oldcxt;
    int         i;
 
    /*
     * nbuckets is the initial number of hash buckets to use in this catcache.
     * It will be enlarged later if it becomes too full.
     *
     * nbuckets must be a power of two.  We check this via Assert rather than
     * a full runtime check because the values will be coming from constant
     * tables.
     *
     * If you're confused by the power-of-two check, see comments in
     * bitmapset.c for an explanation.
     */
    Assert(nbuckets > 0 && (nbuckets & -nbuckets) == nbuckets);
 
    /*
     * first switch to the cache context so our allocations do not vanish at
     * the end of a transaction
     */
    if (!CacheMemoryContext)
        CreateCacheMemoryContext();
 
    oldcxt = MemoryContextSwitchTo(CacheMemoryContext);
 
    /*
     * if first time through, initialize the cache group header
     */
    if (CacheHdr == NULL)
    {
        CacheHdr = palloc_object(CatCacheHeader);
        slist_init(&CacheHdr->ch_caches);
        CacheHdr->ch_ntup = 0;
#ifdef CATCACHE_STATS
        /* set up to dump stats at backend exit */
        on_proc_exit(CatCachePrintStats, 0);
#endif
    }
 
    /*
     * Allocate a new cache structure, aligning to a cacheline boundary
     *
     * Note: we rely on zeroing to initialize all the dlist headers correctly
     */
    cp = (CatCache *) palloc_aligned(sizeof(CatCache), PG_CACHE_LINE_SIZE,
                                     MCXT_ALLOC_ZERO);
    cp->cc_bucket = palloc0(nbuckets * sizeof(dlist_head));
 
    /*
     * Many catcaches never receive any list searches.  Therefore, we don't
     * allocate the cc_lbuckets till we get a list search.
     */
    cp->cc_lbucket = NULL;
 
    /*
     * initialize the cache's relation information for the relation
     * corresponding to this cache, and initialize some of the new cache's
     * other internal fields.  But don't open the relation yet.
     */
    cp->id = id;
    cp->cc_relname = "(not known yet)";
    cp->cc_reloid = reloid;
    cp->cc_indexoid = indexoid;
    cp->cc_relisshared = false; /* temporary */
    cp->cc_tupdesc = (TupleDesc) NULL;
    cp->cc_ntup = 0;
    cp->cc_nlist = 0;
    cp->cc_nbuckets = nbuckets;
    cp->cc_nlbuckets = 0;
    cp->cc_nkeys = nkeys;
    for (i = 0; i < nkeys; ++i)
    {
        Assert(AttributeNumberIsValid(key[i]));
        cp->cc_keyno[i] = key[i];
    }
 
    /*
     * new cache is initialized as far as we can go for now. print some
     * debugging information, if appropriate.
     */
    InitCatCache_DEBUG2;
 
    /*
     * add completed cache to top of group header's list
     */
    slist_push_head(&CacheHdr->ch_caches, &cp->cc_next);
 
    /*
     * back to the old context before we return...
     */
    MemoryContextSwitchTo(oldcxt);
 
    return cp;
}

References Assert(), AttributeNumberIsValid, CacheHdr, CacheMemoryContext, catcache::cc_bucket, catcache::cc_indexoid, catcache::cc_keyno, catcache::cc_lbucket, catcache::cc_nbuckets, catcache::cc_next, catcache::cc_nkeys, catcache::cc_nlbuckets, catcache::cc_nlist, catcache::cc_ntup, catcache::cc_relisshared, catcache::cc_relname, catcache::cc_reloid, catcache::cc_tupdesc, catcacheheader::ch_caches, catcacheheader::ch_ntup, CreateCacheMemoryContext(), i, catcache::id, InitCatCache_DEBUG2, sort-test::key, MCXT_ALLOC_ZERO, MemoryContextSwitchTo(), on_proc_exit(), palloc0(), palloc_aligned(), palloc_object, PG_CACHE_LINE_SIZE, slist_init(), and slist_push_head().

Referenced by InitCatalogCache().

InitCatCachePhase2()

void InitCatCachePhase2	(	CatCache *	cache,
		bool	touch_index
	)

Definition at line 1245 of file catcache.c.

{
    ConditionalCatalogCacheInitializeCache(cache);
 
    if (touch_index &&
        cache->id != AMOID &&
        cache->id != AMNAME)
    {
        Relation    idesc;
 
        /*
         * We must lock the underlying catalog before opening the index to
         * avoid deadlock, since index_open could possibly result in reading
         * this same catalog, and if anyone else is exclusive-locking this
         * catalog and index they'll be doing it in that order.
         */
        LockRelationOid(cache->cc_reloid, AccessShareLock);
        idesc = index_open(cache->cc_indexoid, AccessShareLock);
 
        /*
         * While we've got the index open, let's check that it's unique (and
         * not just deferrable-unique, thank you very much).  This is just to
         * catch thinkos in definitions of new catcaches, so we don't worry
         * about the pg_am indexes not getting tested.
         */
        Assert(idesc->rd_index->indisunique &&
               idesc->rd_index->indimmediate);
 
        index_close(idesc, AccessShareLock);
        UnlockRelationOid(cache->cc_reloid, AccessShareLock);
    }
}

References AccessShareLock, Assert(), CatCInProgress::cache, catcache::cc_indexoid, catcache::cc_reloid, ConditionalCatalogCacheInitializeCache(), catcache::id, index_close(), index_open(), LockRelationOid(), RelationData::rd_index, and UnlockRelationOid().

Referenced by InitCatalogCachePhase2(), and SysCacheGetAttr().

PrepareToInvalidateCacheTuple()

void PrepareToInvalidateCacheTuple	(	Relation	relation,
		HeapTuple	tuple,
		HeapTuple	newtuple,
		void(*)(int, uint32, Oid, void *)	function,
		void *	context
	)

Definition at line 2394 of file catcache.c.

{
    slist_iter  iter;
    Oid         reloid;
 
    CACHE_elog(DEBUG2, "PrepareToInvalidateCacheTuple: called");
 
    /*
     * sanity checks
     */
    Assert(RelationIsValid(relation));
    Assert(HeapTupleIsValid(tuple));
    Assert(function);
    Assert(CacheHdr != NULL);
 
    reloid = RelationGetRelid(relation);
 
    /* ----------------
     *  for each cache
     *     if the cache contains tuples from the specified relation
     *         compute the tuple's hash value(s) in this cache,
     *         and call the passed function to register the information.
     * ----------------
     */
 
    slist_foreach(iter, &CacheHdr->ch_caches)
    {
        CatCache   *ccp = slist_container(CatCache, cc_next, iter.cur);
        uint32      hashvalue;
        Oid         dbid;
 
        if (ccp->cc_reloid != reloid)
            continue;
 
        /* Just in case cache hasn't finished initialization yet... */
        ConditionalCatalogCacheInitializeCache(ccp);
 
        hashvalue = CatalogCacheComputeTupleHashValue(ccp, ccp->cc_nkeys, tuple);
        dbid = ccp->cc_relisshared ? (Oid) 0 : MyDatabaseId;
 
        (*function) (ccp->id, hashvalue, dbid, context);
 
        if (newtuple)
        {
            uint32      newhashvalue;
 
            newhashvalue = CatalogCacheComputeTupleHashValue(ccp, ccp->cc_nkeys, newtuple);
 
            if (newhashvalue != hashvalue)
                (*function) (ccp->id, newhashvalue, dbid, context);
        }
    }
}

References Assert(), CACHE_elog, CacheHdr, CatalogCacheComputeTupleHashValue(), catcache::cc_nkeys, catcache::cc_relisshared, catcache::cc_reloid, catcacheheader::ch_caches, ConditionalCatalogCacheInitializeCache(), slist_iter::cur, DEBUG2, function, HeapTupleIsValid, catcache::id, MyDatabaseId, RelationGetRelid, RelationIsValid, slist_container, and slist_foreach.

Referenced by CacheInvalidateHeapTupleCommon().

ReleaseCatCache()

void ReleaseCatCache

(

HeapTuple

tuple

)

Definition at line 1668 of file catcache.c.

{
    ReleaseCatCacheWithOwner(tuple, CurrentResourceOwner);
}

References CurrentResourceOwner, and ReleaseCatCacheWithOwner().

Referenced by ReleaseSysCache().

ReleaseCatCacheList()

void ReleaseCatCacheList

(

CatCList *

list

)

Definition at line 2114 of file catcache.c.

{
    ReleaseCatCacheListWithOwner(list, CurrentResourceOwner);
}

References CurrentResourceOwner, sort-test::list, and ReleaseCatCacheListWithOwner().

Referenced by AddEnumLabel(), blvalidate(), brinvalidate(), btvalidate(), ginvalidate(), gistvalidate(), hashvalidate(), opclass_for_family_datatype(), RenameEnumLabel(), sepgsql_relation_drop(), spgvalidate(), and transformFrameOffset().

ResetCatalogCaches()

void ResetCatalogCaches

(

void

)

Definition at line 805 of file catcache.c.

{
    ResetCatalogCachesExt(false);
}

References ResetCatalogCachesExt().

ResetCatalogCachesExt()

void ResetCatalogCachesExt

(

bool

debug_discard

)

Definition at line 811 of file catcache.c.

{
    slist_iter  iter;
 
    CACHE_elog(DEBUG2, "ResetCatalogCaches called");
 
    slist_foreach(iter, &CacheHdr->ch_caches)
    {
        CatCache   *cache = slist_container(CatCache, cc_next, iter.cur);
 
        ResetCatalogCache(cache, debug_discard);
    }
 
    CACHE_elog(DEBUG2, "end of ResetCatalogCaches call");
}

References CatCInProgress::cache, CACHE_elog, CacheHdr, catcacheheader::ch_caches, slist_iter::cur, DEBUG2, ResetCatalogCache(), slist_container, and slist_foreach.

Referenced by InvalidateSystemCachesExtended(), and ResetCatalogCaches().

SearchCatCache()

HeapTuple SearchCatCache	(	CatCache *	cache,
		Datum	v1,
		Datum	v2,
		Datum	v3,
		Datum	v4
	)

Definition at line 1361 of file catcache.c.

{
    return SearchCatCacheInternal(cache, cache->cc_nkeys, v1, v2, v3, v4);
}

References CatCInProgress::cache, catcache::cc_nkeys, and SearchCatCacheInternal().

Referenced by SearchSysCache().

SearchCatCache1()

HeapTuple SearchCatCache1	(	CatCache *	cache,
		Datum	v1
	)

Definition at line 1378 of file catcache.c.

{
    return SearchCatCacheInternal(cache, 1, v1, 0, 0, 0);
}

References CatCInProgress::cache, and SearchCatCacheInternal().

Referenced by SearchSysCache1().

SearchCatCache2()

HeapTuple SearchCatCache2	(	CatCache *	cache,
		Datum	v1,
		Datum	v2
	)

Definition at line 1386 of file catcache.c.

{
    return SearchCatCacheInternal(cache, 2, v1, v2, 0, 0);
}

References CatCInProgress::cache, and SearchCatCacheInternal().

Referenced by SearchSysCache2().

SearchCatCache3()

HeapTuple SearchCatCache3	(	CatCache *	cache,
		Datum	v1,
		Datum	v2,
		Datum	v3
	)

Definition at line 1394 of file catcache.c.

{
    return SearchCatCacheInternal(cache, 3, v1, v2, v3, 0);
}

References CatCInProgress::cache, and SearchCatCacheInternal().

Referenced by SearchSysCache3().

SearchCatCache4()

HeapTuple SearchCatCache4	(	CatCache *	cache,
		Datum	v1,
		Datum	v2,
		Datum	v3,
		Datum	v4
	)

Definition at line 1402 of file catcache.c.

{
    return SearchCatCacheInternal(cache, 4, v1, v2, v3, v4);
}

References CatCInProgress::cache, and SearchCatCacheInternal().

Referenced by SearchSysCache4().

SearchCatCacheList()

CatCList * SearchCatCacheList	(	CatCache *	cache,
		int	nkeys,
		Datum	v1,
		Datum	v2,
		Datum	v3
	)

Definition at line 1740 of file catcache.c.

{
    Datum       v4 = 0;         /* dummy last-column value */
    Datum       arguments[CATCACHE_MAXKEYS];
    uint32      lHashValue;
    Index       lHashIndex;
    dlist_iter  iter;
    dlist_head *lbucket;
    CatCList   *cl;
    CatCTup    *ct;
    List       *volatile ctlist;
    ListCell   *ctlist_item;
    int         nmembers;
    bool        ordered;
    HeapTuple   ntp;
    MemoryContext oldcxt;
    int         i;
    CatCInProgress *save_in_progress;
    CatCInProgress in_progress_ent;
 
    /*
     * one-time startup overhead for each cache
     */
    ConditionalCatalogCacheInitializeCache(cache);
 
    Assert(nkeys > 0 && nkeys < cache->cc_nkeys);
 
#ifdef CATCACHE_STATS
    cache->cc_lsearches++;
#endif
 
    /* Initialize local parameter array */
    arguments[0] = v1;
    arguments[1] = v2;
    arguments[2] = v3;
    arguments[3] = v4;
 
    /*
     * If we haven't previously done a list search in this cache, create the
     * bucket header array; otherwise, consider whether it's time to enlarge
     * it.
     */
    if (cache->cc_lbucket == NULL)
    {
        /* Arbitrary initial size --- must be a power of 2 */
        int         nbuckets = 16;
 
        cache->cc_lbucket = (dlist_head *)
            MemoryContextAllocZero(CacheMemoryContext,
                                   nbuckets * sizeof(dlist_head));
        /* Don't set cc_nlbuckets if we get OOM allocating cc_lbucket */
        cache->cc_nlbuckets = nbuckets;
    }
    else
    {
        /*
         * If the hash table has become too full, enlarge the buckets array.
         * Quite arbitrarily, we enlarge when fill factor > 2.
         */
        if (cache->cc_nlist > cache->cc_nlbuckets * 2)
            RehashCatCacheLists(cache);
    }
 
    /*
     * Find the hash bucket in which to look for the CatCList.
     */
    lHashValue = CatalogCacheComputeHashValue(cache, nkeys, v1, v2, v3, v4);
    lHashIndex = HASH_INDEX(lHashValue, cache->cc_nlbuckets);
 
    /*
     * scan the items until we find a match or exhaust our list
     *
     * Note: it's okay to use dlist_foreach here, even though we modify the
     * dlist within the loop, because we don't continue the loop afterwards.
     */
    lbucket = &cache->cc_lbucket[lHashIndex];
    dlist_foreach(iter, lbucket)
    {
        cl = dlist_container(CatCList, cache_elem, iter.cur);
 
        if (cl->dead)
            continue;           /* ignore dead entries */
 
        if (cl->hash_value != lHashValue)
            continue;           /* quickly skip entry if wrong hash val */
 
        /*
         * see if the cached list matches our key.
         */
        if (cl->nkeys != nkeys)
            continue;
 
        if (!CatalogCacheCompareTuple(cache, nkeys, cl->keys, arguments))
            continue;
 
        /*
         * We found a matching list.  Move the list to the front of the list
         * for its hashbucket, so as to speed subsequent searches.  (We do not
         * move the members to the fronts of their hashbucket lists, however,
         * since there's no point in that unless they are searched for
         * individually.)
         */
        dlist_move_head(lbucket, &cl->cache_elem);
 
        /* Bump the list's refcount and return it */
        ResourceOwnerEnlarge(CurrentResourceOwner);
        cl->refcount++;
        ResourceOwnerRememberCatCacheListRef(CurrentResourceOwner, cl);
 
        CACHE_elog(DEBUG2, "SearchCatCacheList(%s): found list",
                   cache->cc_relname);
 
#ifdef CATCACHE_STATS
        cache->cc_lhits++;
#endif
 
        return cl;
    }
 
    /*
     * List was not found in cache, so we have to build it by reading the
     * relation.  For each matching tuple found in the relation, use an
     * existing cache entry if possible, else build a new one.
     *
     * We have to bump the member refcounts temporarily to ensure they won't
     * get dropped from the cache while loading other members. We use a PG_TRY
     * block to ensure we can undo those refcounts if we get an error before
     * we finish constructing the CatCList.  ctlist must be valid throughout
     * the PG_TRY block.
     */
    ctlist = NIL;
 
    /*
     * Cache invalidation can happen while we're building the list.
     * CatalogCacheCreateEntry() handles concurrent invalidation of individual
     * tuples, but it's also possible that a new entry is concurrently added
     * that should be part of the list we're building.  Register an
     * "in-progress" entry that will receive the invalidation, until we have
     * built the final list entry.
     */
    save_in_progress = catcache_in_progress_stack;
    in_progress_ent.next = catcache_in_progress_stack;
    in_progress_ent.cache = cache;
    in_progress_ent.hash_value = lHashValue;
    in_progress_ent.list = true;
    in_progress_ent.dead = false;
    catcache_in_progress_stack = &in_progress_ent;
 
    PG_TRY();
    {
        ScanKeyData cur_skey[CATCACHE_MAXKEYS];
        Relation    relation;
        SysScanDesc scandesc;
        bool        first_iter = true;
 
        relation = table_open(cache->cc_reloid, AccessShareLock);
 
        /*
         * Ok, need to make a lookup in the relation, copy the scankey and
         * fill out any per-call fields.
         */
        memcpy(cur_skey, cache->cc_skey, sizeof(ScanKeyData) * cache->cc_nkeys);
        cur_skey[0].sk_argument = v1;
        cur_skey[1].sk_argument = v2;
        cur_skey[2].sk_argument = v3;
        cur_skey[3].sk_argument = v4;
 
        /*
         * Scan the table for matching entries.  If an invalidation arrives
         * mid-build, we will loop back here to retry.
         */
        do
        {
            /*
             * If we are retrying, release refcounts on any items created on
             * the previous iteration.  We dare not try to free them if
             * they're now unreferenced, since an error while doing that would
             * result in the PG_CATCH below doing extra refcount decrements.
             * Besides, we'll likely re-adopt those items in the next
             * iteration, so it's not worth complicating matters to try to get
             * rid of them.
             */
            foreach(ctlist_item, ctlist)
            {
                ct = (CatCTup *) lfirst(ctlist_item);
                Assert(ct->c_list == NULL);
                Assert(ct->refcount > 0);
                ct->refcount--;
            }
            /* Reset ctlist in preparation for new try */
            ctlist = NIL;
            in_progress_ent.dead = false;
 
            scandesc = systable_beginscan(relation,
                                          cache->cc_indexoid,
                                          IndexScanOK(cache),
                                          NULL,
                                          nkeys,
                                          cur_skey);
 
            /* The list will be ordered iff we are doing an index scan */
            ordered = (scandesc->irel != NULL);
 
            /* Injection point to help testing the recursive invalidation case */
            if (first_iter)
            {
                INJECTION_POINT("catcache-list-miss-systable-scan-started", NULL);
                first_iter = false;
            }
 
            while (HeapTupleIsValid(ntp = systable_getnext(scandesc)) &&
                   !in_progress_ent.dead)
            {
                uint32      hashValue;
                Index       hashIndex;
                bool        found = false;
                dlist_head *bucket;
 
                /*
                 * See if there's an entry for this tuple already.
                 */
                ct = NULL;
                hashValue = CatalogCacheComputeTupleHashValue(cache, cache->cc_nkeys, ntp);
                hashIndex = HASH_INDEX(hashValue, cache->cc_nbuckets);
 
                bucket = &cache->cc_bucket[hashIndex];
                dlist_foreach(iter, bucket)
                {
                    ct = dlist_container(CatCTup, cache_elem, iter.cur);
 
                    if (ct->dead || ct->negative)
                        continue;   /* ignore dead and negative entries */
 
                    if (ct->hash_value != hashValue)
                        continue;   /* quickly skip entry if wrong hash val */
 
                    if (!ItemPointerEquals(&(ct->tuple.t_self), &(ntp->t_self)))
                        continue;   /* not same tuple */
 
                    /*
                     * Found a match, but can't use it if it belongs to
                     * another list already
                     */
                    if (ct->c_list)
                        continue;
 
                    found = true;
                    break;      /* A-OK */
                }
 
                if (!found)
                {
                    /* We didn't find a usable entry, so make a new one */
                    ct = CatalogCacheCreateEntry(cache, ntp, NULL,
                                                 hashValue, hashIndex);
 
                    /* upon failure, we must start the scan over */
                    if (ct == NULL)
                    {
                        in_progress_ent.dead = true;
                        break;
                    }
                }
 
                /* Careful here: add entry to ctlist, then bump its refcount */
                /* This way leaves state correct if lappend runs out of memory */
                ctlist = lappend(ctlist, ct);
                ct->refcount++;
            }
 
            systable_endscan(scandesc);
        } while (in_progress_ent.dead);
 
        table_close(relation, AccessShareLock);
 
        /* Make sure the resource owner has room to remember this entry. */
        ResourceOwnerEnlarge(CurrentResourceOwner);
 
        /* Now we can build the CatCList entry. */
        oldcxt = MemoryContextSwitchTo(CacheMemoryContext);
        nmembers = list_length(ctlist);
        cl = (CatCList *)
            palloc(offsetof(CatCList, members) + nmembers * sizeof(CatCTup *));
 
        /* Extract key values */
        CatCacheCopyKeys(cache->cc_tupdesc, nkeys, cache->cc_keyno,
                         arguments, cl->keys);
        MemoryContextSwitchTo(oldcxt);
 
        /*
         * We are now past the last thing that could trigger an elog before we
         * have finished building the CatCList and remembering it in the
         * resource owner.  So it's OK to fall out of the PG_TRY, and indeed
         * we'd better do so before we start marking the members as belonging
         * to the list.
         */
    }
    PG_CATCH();
    {
        Assert(catcache_in_progress_stack == &in_progress_ent);
        catcache_in_progress_stack = save_in_progress;
 
        foreach(ctlist_item, ctlist)
        {
            ct = (CatCTup *) lfirst(ctlist_item);
            Assert(ct->c_list == NULL);
            Assert(ct->refcount > 0);
            ct->refcount--;
            if (
#ifndef CATCACHE_FORCE_RELEASE
                ct->dead &&
#endif
                ct->refcount == 0 &&
                (ct->c_list == NULL || ct->c_list->refcount == 0))
                CatCacheRemoveCTup(cache, ct);
        }
 
        PG_RE_THROW();
    }
    PG_END_TRY();
    Assert(catcache_in_progress_stack == &in_progress_ent);
    catcache_in_progress_stack = save_in_progress;
 
    cl->cl_magic = CL_MAGIC;
    cl->my_cache = cache;
    cl->refcount = 0;           /* for the moment */
    cl->dead = false;
    cl->ordered = ordered;
    cl->nkeys = nkeys;
    cl->hash_value = lHashValue;
    cl->n_members = nmembers;
 
    i = 0;
    foreach(ctlist_item, ctlist)
    {
        cl->members[i++] = ct = (CatCTup *) lfirst(ctlist_item);
        Assert(ct->c_list == NULL);
        ct->c_list = cl;
        /* release the temporary refcount on the member */
        Assert(ct->refcount > 0);
        ct->refcount--;
        /* mark list dead if any members already dead */
        if (ct->dead)
            cl->dead = true;
    }
    Assert(i == nmembers);
 
    /*
     * Add the CatCList to the appropriate bucket, and count it.
     */
    dlist_push_head(lbucket, &cl->cache_elem);
 
    cache->cc_nlist++;
 
    /* Finally, bump the list's refcount and return it */
    cl->refcount++;
    ResourceOwnerRememberCatCacheListRef(CurrentResourceOwner, cl);
 
    CACHE_elog(DEBUG2, "SearchCatCacheList(%s): made list of %d members",
               cache->cc_relname, nmembers);
 
    return cl;
}

References AccessShareLock, Assert(), catctup::c_list, CatCInProgress::cache, catclist::cache_elem, CACHE_elog, CacheMemoryContext, CatalogCacheCompareTuple(), CatalogCacheComputeHashValue(), CatalogCacheComputeTupleHashValue(), CatalogCacheCreateEntry(), catcache_in_progress_stack, CATCACHE_MAXKEYS, CatCacheCopyKeys(), CatCacheRemoveCTup(), catcache::cc_bucket, catcache::cc_indexoid, catcache::cc_keyno, catcache::cc_lbucket, catcache::cc_nbuckets, catcache::cc_nkeys, catcache::cc_nlbuckets, catcache::cc_nlist, catcache::cc_relname, catcache::cc_reloid, catcache::cc_skey, catcache::cc_tupdesc, catclist::cl_magic, CL_MAGIC, ConditionalCatalogCacheInitializeCache(), dlist_iter::cur, CurrentResourceOwner, CatCInProgress::dead, catctup::dead, catclist::dead, DEBUG2, dlist_container, dlist_foreach, dlist_move_head(), dlist_push_head(), HASH_INDEX, CatCInProgress::hash_value, catctup::hash_value, catclist::hash_value, HeapTupleIsValid, i, IndexScanOK(), INJECTION_POINT, SysScanDescData::irel, ItemPointerEquals(), catclist::keys, lappend(), lfirst, CatCInProgress::list, list_length(), catclist::members, MemoryContextAllocZero(), MemoryContextSwitchTo(), catclist::my_cache, catclist::n_members, catctup::negative, CatCInProgress::next, NIL, catclist::nkeys, catclist::ordered, palloc(), PG_CATCH, PG_END_TRY, PG_RE_THROW, PG_TRY, catctup::refcount, catclist::refcount, RehashCatCacheLists(), ResourceOwnerEnlarge(), ResourceOwnerRememberCatCacheListRef(), ScanKeyData::sk_argument, systable_beginscan(), systable_endscan(), systable_getnext(), HeapTupleData::t_self, table_close(), table_open(), and catctup::tuple.

Referenced by SearchSysCacheList().

Variable Documentation

CacheMemoryContext

PGDLLIMPORT MemoryContext CacheMemoryContext

extern

Definition at line 169 of file mcxt.c.