#include "postgres.h"
#include "access/genam.h"
#include "access/heaptoast.h"
#include "access/relscan.h"
#include "access/table.h"
#include "access/xact.h"
#include "catalog/catalog.h"
#include "catalog/pg_collation.h"
#include "catalog/pg_type.h"
#include "common/hashfn.h"
#include "common/pg_prng.h"
#include "miscadmin.h"
#include "port/pg_bitutils.h"
#include "storage/lmgr.h"
#include "utils/builtins.h"
#include "utils/catcache.h"
#include "utils/datum.h"
#include "utils/fmgroids.h"
#include "utils/inval.h"
#include "utils/memutils.h"
#include "utils/rel.h"
#include "utils/resowner.h"
#include "utils/syscache.h"

Include dependency graph for catcache.c:

Macros
#define	HASH_INDEX(h, sz) ((Index) ((h) & ((sz) - 1)))

#define	CACHE_elog(...)

#define	InitCatCache_DEBUG2

#define	CatalogCacheInitializeCache_DEBUG1

#define	CatalogCacheInitializeCache_DEBUG2

Functions
static HeapTuple	SearchCatCacheInternal (CatCache *cache, int nkeys, Datum v1, Datum v2, Datum v3, Datum v4)

static pg_noinline HeapTuple	SearchCatCacheMiss (CatCache *cache, int nkeys, uint32 hashValue, Index hashIndex, Datum v1, Datum v2, Datum v3, Datum v4)

static uint32	CatalogCacheComputeHashValue (CatCache *cache, int nkeys, Datum v1, Datum v2, Datum v3, Datum v4)

static uint32	CatalogCacheComputeTupleHashValue (CatCache *cache, int nkeys, HeapTuple tuple)

static bool	CatalogCacheCompareTuple (const CatCache cache, int nkeys, const Datum cachekeys, const Datum *searchkeys)

static void	CatCacheRemoveCTup (CatCache cache, CatCTup ct)

static void	CatCacheRemoveCList (CatCache cache, CatCList cl)

static void	RehashCatCache (CatCache *cp)

static void	RehashCatCacheLists (CatCache *cp)

static void	CatalogCacheInitializeCache (CatCache *cache)

static CatCTup *	CatalogCacheCreateEntry (CatCache cache, HeapTuple ntp, SysScanDesc scandesc, Datum arguments, uint32 hashValue, Index hashIndex)

static void	ReleaseCatCacheWithOwner (HeapTuple tuple, ResourceOwner resowner)

static void	ReleaseCatCacheListWithOwner (CatCList *list, ResourceOwner resowner)

static void	CatCacheFreeKeys (TupleDesc tupdesc, int nkeys, int attnos, Datum keys)

static void	CatCacheCopyKeys (TupleDesc tupdesc, int nkeys, int attnos, Datum srckeys, Datum *dstkeys)

static void	ResOwnerReleaseCatCache (Datum res)

static char *	ResOwnerPrintCatCache (Datum res)

static void	ResOwnerReleaseCatCacheList (Datum res)

static char *	ResOwnerPrintCatCacheList (Datum res)

static void	ResourceOwnerRememberCatCacheRef (ResourceOwner owner, HeapTuple tuple)

static void	ResourceOwnerForgetCatCacheRef (ResourceOwner owner, HeapTuple tuple)

static void	ResourceOwnerRememberCatCacheListRef (ResourceOwner owner, CatCList *list)

static void	ResourceOwnerForgetCatCacheListRef (ResourceOwner owner, CatCList *list)

static bool	chareqfast (Datum a, Datum b)

static uint32	charhashfast (Datum datum)

static bool	nameeqfast (Datum a, Datum b)

static uint32	namehashfast (Datum datum)

static bool	int2eqfast (Datum a, Datum b)

static uint32	int2hashfast (Datum datum)

static bool	int4eqfast (Datum a, Datum b)

static uint32	int4hashfast (Datum datum)

static bool	texteqfast (Datum a, Datum b)

static uint32	texthashfast (Datum datum)

static bool	oidvectoreqfast (Datum a, Datum b)

static uint32	oidvectorhashfast (Datum datum)

static void	GetCCHashEqFuncs (Oid keytype, CCHashFN hashfunc, RegProcedure eqfunc, CCFastEqualFN *fasteqfunc)

void	CatCacheInvalidate (CatCache *cache, uint32 hashValue)

void	CreateCacheMemoryContext (void)

static void	ResetCatalogCache (CatCache *cache)

void	ResetCatalogCaches (void)

void	CatalogCacheFlushCatalog (Oid catId)

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

void	InitCatCachePhase2 (CatCache *cache, bool touch_index)

static bool	IndexScanOK (CatCache *cache, ScanKey cur_skey)

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)

static bool	equalTuple (HeapTuple a, HeapTuple b)

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

Variables
static CatCacheHeader *	CacheHdr = NULL

static const ResourceOwnerDesc	catcache_resowner_desc

static const ResourceOwnerDesc	catlistref_resowner_desc

Macro Definition Documentation

◆ CACHE_elog

#define CACHE_elog ( ... )

Definition at line 61 of file catcache.c.

◆ CatalogCacheInitializeCache_DEBUG1

#define CatalogCacheInitializeCache_DEBUG1

Definition at line 1031 of file catcache.c.

◆ CatalogCacheInitializeCache_DEBUG2

#define CatalogCacheInitializeCache_DEBUG2

Definition at line 1032 of file catcache.c.

◆ HASH_INDEX

#define HASH_INDEX	(	h,
		sz
	)	((Index) ((h) & ((sz) - 1)))

Definition at line 51 of file catcache.c.

◆ InitCatCache_DEBUG2

#define InitCatCache_DEBUG2

Definition at line 824 of file catcache.c.

Function Documentation

◆ CatalogCacheCompareTuple()

static bool CatalogCacheCompareTuple	(	const CatCache *	cache,
		int	nkeys,
		const Datum *	cachekeys,
		const Datum *	searchkeys
	)

inlinestatic

Definition at line 423 of file catcache.c.

 {
     const CCFastEqualFN *cc_fastequal = cache->cc_fastequal;
     int         i;
  
     for (i = 0; i < nkeys; i++)
     {
         if (!(cc_fastequal[i]) (cachekeys[i], searchkeys[i]))
             return false;
     }
     return true;
 }

References catcache::cc_fastequal, and i.

Referenced by SearchCatCacheInternal(), and SearchCatCacheList().

◆ CatalogCacheComputeHashValue()

static uint32 CatalogCacheComputeHashValue	(	CatCache *	cache,
		int	nkeys,
		Datum	v1,
		Datum	v2,
		Datum	v3,
		Datum	v4
	)

static

Definition at line 326 of file catcache.c.

 {
     uint32      hashValue = 0;
     uint32      oneHash;
     CCHashFN   *cc_hashfunc = cache->cc_hashfunc;
  
     CACHE_elog(DEBUG2, "CatalogCacheComputeHashValue %s %d %p",
                cache->cc_relname, nkeys, cache);
  
     switch (nkeys)
     {
         case 4:
             oneHash = (cc_hashfunc[3]) (v4);
             hashValue ^= pg_rotate_left32(oneHash, 24);
             /* FALLTHROUGH */
         case 3:
             oneHash = (cc_hashfunc[2]) (v3);
             hashValue ^= pg_rotate_left32(oneHash, 16);
             /* FALLTHROUGH */
         case 2:
             oneHash = (cc_hashfunc[1]) (v2);
             hashValue ^= pg_rotate_left32(oneHash, 8);
             /* FALLTHROUGH */
         case 1:
             oneHash = (cc_hashfunc[0]) (v1);
             hashValue ^= oneHash;
             break;
         default:
             elog(FATAL, "wrong number of hash keys: %d", nkeys);
             break;
     }
  
     return hashValue;
 }

References CACHE_elog, catcache::cc_hashfunc, catcache::cc_relname, DEBUG2, elog, FATAL, and pg_rotate_left32().

Referenced by CatalogCacheComputeTupleHashValue(), GetCatCacheHashValue(), SearchCatCacheInternal(), and SearchCatCacheList().

◆ CatalogCacheComputeTupleHashValue()

static uint32 CatalogCacheComputeTupleHashValue	(	CatCache *	cache,
		int	nkeys,
		HeapTuple	tuple
	)

static

Definition at line 368 of file catcache.c.

 {
     Datum       v1 = 0,
                 v2 = 0,
                 v3 = 0,
                 v4 = 0;
     bool        isNull = false;
     int        *cc_keyno = cache->cc_keyno;
     TupleDesc   cc_tupdesc = cache->cc_tupdesc;
  
     /* Now extract key fields from tuple, insert into scankey */
     switch (nkeys)
     {
         case 4:
             v4 = fastgetattr(tuple,
                              cc_keyno[3],
                              cc_tupdesc,
                              &isNull);
             Assert(!isNull);
             /* FALLTHROUGH */
         case 3:
             v3 = fastgetattr(tuple,
                              cc_keyno[2],
                              cc_tupdesc,
                              &isNull);
             Assert(!isNull);
             /* FALLTHROUGH */
         case 2:
             v2 = fastgetattr(tuple,
                              cc_keyno[1],
                              cc_tupdesc,
                              &isNull);
             Assert(!isNull);
             /* FALLTHROUGH */
         case 1:
             v1 = fastgetattr(tuple,
                              cc_keyno[0],
                              cc_tupdesc,
                              &isNull);
             Assert(!isNull);
             break;
         default:
             elog(FATAL, "wrong number of hash keys: %d", nkeys);
             break;
     }
  
     return CatalogCacheComputeHashValue(cache, nkeys, v1, v2, v3, v4);
 }

References Assert, CatalogCacheComputeHashValue(), catcache::cc_keyno, catcache::cc_tupdesc, elog, fastgetattr(), and FATAL.

Referenced by PrepareToInvalidateCacheTuple(), and SearchCatCacheList().

◆ CatalogCacheCreateEntry()

static CatCTup * CatalogCacheCreateEntry	(	CatCache *	cache,
		HeapTuple	ntp,
		SysScanDesc	scandesc,
		Datum *	arguments,
		uint32	hashValue,
		Index	hashIndex
	)

static

Definition at line 2044 of file catcache.c.

 {
     CatCTup    *ct;
     HeapTuple   dtp;
     MemoryContext oldcxt;
  
     if (ntp)
     {
         int         i;
  
         /*
          * The visibility recheck below essentially never fails during our
          * regression tests, and there's no easy way to force it to fail for
          * testing purposes.  To ensure we have test coverage for the retry
          * paths in our callers, make debug builds randomly fail about 0.1% of
          * the times through this code path, even when there's no toasted
          * fields.
          */
 #ifdef USE_ASSERT_CHECKING
         if (pg_prng_uint32(&pg_global_prng_state) <= (PG_UINT32_MAX / 1000))
             return NULL;
 #endif
  
         /*
          * If there are any out-of-line toasted fields in the tuple, expand
          * them in-line.  This saves cycles during later use of the catcache
          * entry, and also protects us against the possibility of the toast
          * tuples being freed before we attempt to fetch them, in case of
          * something using a slightly stale catcache entry.
          */
         if (HeapTupleHasExternal(ntp))
         {
             bool        need_cmp = IsInplaceUpdateOid(cache->cc_reloid);
             HeapTuple   before = NULL;
             bool        matches = true;
  
             if (need_cmp)
                 before = heap_copytuple(ntp);
             dtp = toast_flatten_tuple(ntp, cache->cc_tupdesc);
  
             /*
              * The tuple could become stale while we are doing toast table
              * access (since AcceptInvalidationMessages can run then).
              * equalTuple() detects staleness from inplace updates, while
              * systable_recheck_tuple() detects staleness from normal updates.
              *
              * While this equalTuple() follows the usual rule of reading with
              * a pin and no buffer lock, it warrants suspicion since an
              * inplace update could appear at any moment.  It's safe because
              * the inplace update sends an invalidation that can't reorder
              * before the inplace heap change.  If the heap change reaches
              * this process just after equalTuple() looks, we've not missed
              * its inval.
              */
             if (need_cmp)
             {
                 matches = equalTuple(before, ntp);
                 heap_freetuple(before);
             }
             if (!matches || !systable_recheck_tuple(scandesc, ntp))
             {
                 heap_freetuple(dtp);
                 return NULL;
             }
         }
         else
             dtp = ntp;
  
         /* Allocate memory for CatCTup and the cached tuple in one go */
         oldcxt = MemoryContextSwitchTo(CacheMemoryContext);
  
         ct = (CatCTup *) palloc(sizeof(CatCTup) +
                                 MAXIMUM_ALIGNOF + dtp->t_len);
         ct->tuple.t_len = dtp->t_len;
         ct->tuple.t_self = dtp->t_self;
         ct->tuple.t_tableOid = dtp->t_tableOid;
         ct->tuple.t_data = (HeapTupleHeader)
             MAXALIGN(((char *) ct) + sizeof(CatCTup));
         /* copy tuple contents */
         memcpy((char *) ct->tuple.t_data,
                (const char *) dtp->t_data,
                dtp->t_len);
         MemoryContextSwitchTo(oldcxt);
  
         if (dtp != ntp)
             heap_freetuple(dtp);
  
         /* extract keys - they'll point into the tuple if not by-value */
         for (i = 0; i < cache->cc_nkeys; i++)
         {
             Datum       atp;
             bool        isnull;
  
             atp = heap_getattr(&ct->tuple,
                                cache->cc_keyno[i],
                                cache->cc_tupdesc,
                                &isnull);
             Assert(!isnull);
             ct->keys[i] = atp;
         }
     }
     else
     {
         /* Set up keys for a negative cache entry */
         oldcxt = MemoryContextSwitchTo(CacheMemoryContext);
         ct = (CatCTup *) palloc(sizeof(CatCTup));
  
         /*
          * Store keys - they'll point into separately allocated memory if not
          * by-value.
          */
         CatCacheCopyKeys(cache->cc_tupdesc, cache->cc_nkeys, cache->cc_keyno,
                          arguments, ct->keys);
         MemoryContextSwitchTo(oldcxt);
     }
  
     /*
      * Finish initializing the CatCTup header, and add it to the cache's
      * linked list and counts.
      */
     ct->ct_magic = CT_MAGIC;
     ct->my_cache = cache;
     ct->c_list = NULL;
     ct->refcount = 0;           /* for the moment */
     ct->dead = false;
     ct->negative = (ntp == NULL);
     ct->hash_value = hashValue;
  
     dlist_push_head(&cache->cc_bucket[hashIndex], &ct->cache_elem);
  
     cache->cc_ntup++;
     CacheHdr->ch_ntup++;
  
     /*
      * If the hash table has become too full, enlarge the buckets array. Quite
      * arbitrarily, we enlarge when fill factor > 2.
      */
     if (cache->cc_ntup > cache->cc_nbuckets * 2)
         RehashCatCache(cache);
  
     return ct;
 }

References Assert, before(), catctup::c_list, catctup::cache_elem, CacheHdr, CacheMemoryContext, CatCacheCopyKeys(), catcache::cc_bucket, catcache::cc_keyno, catcache::cc_nbuckets, catcache::cc_nkeys, catcache::cc_ntup, catcache::cc_reloid, catcache::cc_tupdesc, catcacheheader::ch_ntup, catctup::ct_magic, CT_MAGIC, catctup::dead, dlist_push_head(), equalTuple(), catctup::hash_value, heap_copytuple(), heap_freetuple(), heap_getattr(), HeapTupleHasExternal, i, IsInplaceUpdateOid(), catctup::keys, MAXALIGN, MemoryContextSwitchTo(), catctup::my_cache, catctup::negative, palloc(), pg_global_prng_state, pg_prng_uint32(), PG_UINT32_MAX, catctup::refcount, RehashCatCache(), systable_recheck_tuple(), HeapTupleData::t_data, HeapTupleData::t_len, HeapTupleData::t_self, HeapTupleData::t_tableOid, toast_flatten_tuple(), and catctup::tuple.

Referenced by SearchCatCacheList(), and SearchCatCacheMiss().

◆ CatalogCacheFlushCatalog()

void CatalogCacheFlushCatalog ( Oid catId )

Definition at line 784 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);
  
             /* Tell inval.c to call syscache callbacks for this cache */
             CallSyscacheCallbacks(cache->id, 0);
         }
     }
  
     CACHE_elog(DEBUG2, "end of CatalogCacheFlushCatalog call");
 }

References 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().

◆ CatalogCacheInitializeCache()

static void CatalogCacheInitializeCache ( CatCache * cache )

static

Definition at line 1036 of file catcache.c.

 {
     Relation    relation;
     MemoryContext oldcxt;
     TupleDesc   tupdesc;
     int         i;
  
     CatalogCacheInitializeCache_DEBUG1;
  
     relation = table_open(cache->cc_reloid, AccessShareLock);
  
     /*
      * switch to the cache context so our allocations do not vanish at the end
      * of a transaction
      */
     Assert(CacheMemoryContext != NULL);
  
     oldcxt = MemoryContextSwitchTo(CacheMemoryContext);
  
     /*
      * copy the relcache's tuple descriptor to permanent cache storage
      */
     tupdesc = CreateTupleDescCopyConstr(RelationGetDescr(relation));
  
     /*
      * save the relation's name and relisshared flag, too (cc_relname is used
      * only for debugging purposes)
      */
     cache->cc_relname = pstrdup(RelationGetRelationName(relation));
     cache->cc_relisshared = RelationGetForm(relation)->relisshared;
  
     /*
      * return to the caller's memory context and close the rel
      */
     MemoryContextSwitchTo(oldcxt);
  
     table_close(relation, AccessShareLock);
  
     CACHE_elog(DEBUG2, "CatalogCacheInitializeCache: %s, %d keys",
                cache->cc_relname, cache->cc_nkeys);
  
     /*
      * initialize cache's key information
      */
     for (i = 0; i < cache->cc_nkeys; ++i)
     {
         Oid         keytype;
         RegProcedure eqfunc;
  
         CatalogCacheInitializeCache_DEBUG2;
  
         if (cache->cc_keyno[i] > 0)
         {
             Form_pg_attribute attr = TupleDescAttr(tupdesc,
                                                    cache->cc_keyno[i] - 1);
  
             keytype = attr->atttypid;
             /* cache key columns should always be NOT NULL */
             Assert(attr->attnotnull);
         }
         else
         {
             if (cache->cc_keyno[i] < 0)
                 elog(FATAL, "sys attributes are not supported in caches");
             keytype = OIDOID;
         }
  
         GetCCHashEqFuncs(keytype,
                          &cache->cc_hashfunc[i],
                          &eqfunc,
                          &cache->cc_fastequal[i]);
  
         /*
          * Do equality-function lookup (we assume this won't need a catalog
          * lookup for any supported type)
          */
         fmgr_info_cxt(eqfunc,
                       &cache->cc_skey[i].sk_func,
                       CacheMemoryContext);
  
         /* Initialize sk_attno suitably for HeapKeyTest() and heap scans */
         cache->cc_skey[i].sk_attno = cache->cc_keyno[i];
  
         /* Fill in sk_strategy as well --- always standard equality */
         cache->cc_skey[i].sk_strategy = BTEqualStrategyNumber;
         cache->cc_skey[i].sk_subtype = InvalidOid;
         /* If a catcache key requires a collation, it must be C collation */
         cache->cc_skey[i].sk_collation = C_COLLATION_OID;
  
         CACHE_elog(DEBUG2, "CatalogCacheInitializeCache %s %d %p",
                    cache->cc_relname, i, cache);
     }
  
     /*
      * mark this cache fully initialized
      */
     cache->cc_tupdesc = tupdesc;
 }

References AccessShareLock, Assert, BTEqualStrategyNumber, CACHE_elog, CacheMemoryContext, CatalogCacheInitializeCache_DEBUG1, CatalogCacheInitializeCache_DEBUG2, catcache::cc_fastequal, catcache::cc_hashfunc, catcache::cc_keyno, catcache::cc_nkeys, catcache::cc_relisshared, catcache::cc_relname, catcache::cc_reloid, catcache::cc_skey, catcache::cc_tupdesc, CreateTupleDescCopyConstr(), DEBUG2, elog, FATAL, fmgr_info_cxt(), GetCCHashEqFuncs(), i, InvalidOid, MemoryContextSwitchTo(), pstrdup(), RelationGetDescr, RelationGetForm, RelationGetRelationName, ScanKeyData::sk_attno, ScanKeyData::sk_collation, ScanKeyData::sk_func, ScanKeyData::sk_strategy, ScanKeyData::sk_subtype, table_close(), table_open(), and TupleDescAttr.

Referenced by GetCatCacheHashValue(), InitCatCachePhase2(), PrepareToInvalidateCacheTuple(), SearchCatCacheInternal(), and SearchCatCacheList().

◆ CatCacheCopyKeys()

static void CatCacheCopyKeys	(	TupleDesc	tupdesc,
		int	nkeys,
		int *	attnos,
		Datum *	srckeys,
		Datum *	dstkeys
	)

static

Definition at line 2218 of file catcache.c.

 {
     int         i;
  
     /*
      * XXX: memory and lookup performance could possibly be improved by
      * storing all keys in one allocation.
      */
  
     for (i = 0; i < nkeys; i++)
     {
         int         attnum = attnos[i];
         Form_pg_attribute att = TupleDescAttr(tupdesc, attnum - 1);
         Datum       src = srckeys[i];
         NameData    srcname;
  
         /*
          * Must be careful in case the caller passed a C string where a NAME
          * is wanted: convert the given argument to a correctly padded NAME.
          * Otherwise the memcpy() done by datumCopy() could fall off the end
          * of memory.
          */
         if (att->atttypid == NAMEOID)
         {
             namestrcpy(&srcname, DatumGetCString(src));
             src = NameGetDatum(&srcname);
         }
  
         dstkeys[i] = datumCopy(src,
                                att->attbyval,
                                att->attlen);
     }
 }

References attnum, datumCopy(), DatumGetCString(), i, NameGetDatum(), namestrcpy(), and TupleDescAttr.

Referenced by CatalogCacheCreateEntry(), and SearchCatCacheList().

◆ CatCacheFreeKeys()

static void CatCacheFreeKeys	(	TupleDesc	tupdesc,
		int	nkeys,
		int *	attnos,
		Datum *	keys
	)

static

Definition at line 2193 of file catcache.c.

 {
     int         i;
  
     for (i = 0; i < nkeys; i++)
     {
         int         attnum = attnos[i];
         Form_pg_attribute att;
  
         /* system attribute are not supported in caches */
         Assert(attnum > 0);
  
         att = TupleDescAttr(tupdesc, attnum - 1);
  
         if (!att->attbyval)
             pfree(DatumGetPointer(keys[i]));
     }
 }

References Assert, attnum, DatumGetPointer(), i, pfree(), and TupleDescAttr.

Referenced by CatCacheRemoveCList(), and CatCacheRemoveCTup().

◆ CatCacheInvalidate()

void CatCacheInvalidate	(	CatCache *	cache,
		uint32	hashValue
	)

Definition at line 607 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! */
         }
     }
 }

References Assert, catctup::c_list, CACHE_elog, 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, catctup::refcount, and catclist::refcount.

Referenced by SysCacheInvalidate().

◆ CatCacheRemoveCList()

static void CatCacheRemoveCList	(	CatCache *	cache,
		CatCList *	cl
	)

static

Definition at line 552 of file catcache.c.

 {
     int         i;
  
     Assert(cl->refcount == 0);
     Assert(cl->my_cache == cache);
  
     /* delink from member tuples */
     for (i = cl->n_members; --i >= 0;)
     {
         CatCTup    *ct = cl->members[i];
  
         Assert(ct->c_list == cl);
         ct->c_list = NULL;
         /* if the member is dead and now has no references, remove it */
         if (
 #ifndef CATCACHE_FORCE_RELEASE
             ct->dead &&
 #endif
             ct->refcount == 0)
             CatCacheRemoveCTup(cache, ct);
     }
  
     /* delink from linked list */
     dlist_delete(&cl->cache_elem);
  
     /* free associated column data */
     CatCacheFreeKeys(cache->cc_tupdesc, cl->nkeys,
                      cache->cc_keyno, cl->keys);
  
     pfree(cl);
  
     --cache->cc_nlist;
 }

References Assert, catctup::c_list, catclist::cache_elem, CatCacheFreeKeys(), CatCacheRemoveCTup(), catcache::cc_keyno, catcache::cc_nlist, catcache::cc_tupdesc, catctup::dead, dlist_delete(), i, catclist::keys, catclist::members, catclist::my_cache, catclist::n_members, catclist::nkeys, pfree(), catctup::refcount, and catclist::refcount.

Referenced by CatCacheInvalidate(), CatCacheRemoveCTup(), ReleaseCatCacheListWithOwner(), and ResetCatalogCache().

◆ CatCacheRemoveCTup()

static void CatCacheRemoveCTup	(	CatCache *	cache,
		CatCTup *	ct
	)

static

Definition at line 510 of file catcache.c.

 {
     Assert(ct->refcount == 0);
     Assert(ct->my_cache == cache);
  
     if (ct->c_list)
     {
         /*
          * The cleanest way to handle this is to call CatCacheRemoveCList,
          * which will recurse back to me, and the recursive call will do the
          * work.  Set the "dead" flag to make sure it does recurse.
          */
         ct->dead = true;
         CatCacheRemoveCList(cache, ct->c_list);
         return;                 /* nothing left to do */
     }
  
     /* delink from linked list */
     dlist_delete(&ct->cache_elem);
  
     /*
      * Free keys when we're dealing with a negative entry, normal entries just
      * point into tuple, allocated together with the CatCTup.
      */
     if (ct->negative)
         CatCacheFreeKeys(cache->cc_tupdesc, cache->cc_nkeys,
                          cache->cc_keyno, ct->keys);
  
     pfree(ct);
  
     --cache->cc_ntup;
     --CacheHdr->ch_ntup;
 }

References Assert, catctup::c_list, catctup::cache_elem, CacheHdr, CatCacheFreeKeys(), CatCacheRemoveCList(), catcache::cc_keyno, catcache::cc_nkeys, catcache::cc_ntup, catcache::cc_tupdesc, catcacheheader::ch_ntup, catctup::dead, dlist_delete(), catctup::keys, catctup::my_cache, catctup::negative, pfree(), and catctup::refcount.

Referenced by CatCacheInvalidate(), CatCacheRemoveCList(), ReleaseCatCacheWithOwner(), ResetCatalogCache(), and SearchCatCacheList().

◆ chareqfast()

static bool chareqfast	(	Datum	a,
		Datum	b
	)

static

Definition at line 173 of file catcache.c.

 {
     return DatumGetChar(a) == DatumGetChar(b);
 }

References a, b, and DatumGetChar().

Referenced by GetCCHashEqFuncs().

◆ charhashfast()

static uint32 charhashfast ( Datum datum )

static

Definition at line 179 of file catcache.c.

 {
     return murmurhash32((int32) DatumGetChar(datum));
 }

References DatumGetChar(), and murmurhash32().

Referenced by GetCCHashEqFuncs().

◆ CreateCacheMemoryContext()

void CreateCacheMemoryContext ( void )

Definition at line 680 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().

◆ equalTuple()

static bool equalTuple	(	HeapTuple	a,
		HeapTuple	b
	)

static

Definition at line 2016 of file catcache.c.

 {
     uint32      alen;
     uint32      blen;
  
     alen = a->t_len;
     blen = b->t_len;
     return (alen == blen &&
             memcmp((char *) a->t_data,
                    (char *) b->t_data, blen) == 0);
 }

References a, and b.

Referenced by CatalogCacheCreateEntry().

◆ GetCatCacheHashValue()

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

Definition at line 1613 of file catcache.c.

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

References CatalogCacheComputeHashValue(), CatalogCacheInitializeCache(), catcache::cc_nkeys, and catcache::cc_tupdesc.

Referenced by GetSysCacheHashValue().

◆ GetCCHashEqFuncs()

static void GetCCHashEqFuncs	(	Oid	keytype,
		CCHashFN *	hashfunc,
		RegProcedure *	eqfunc,
		CCFastEqualFN *	fasteqfunc
	)

static

Definition at line 256 of file catcache.c.

 {
     switch (keytype)
     {
         case BOOLOID:
             *hashfunc = charhashfast;
             *fasteqfunc = chareqfast;
             *eqfunc = F_BOOLEQ;
             break;
         case CHAROID:
             *hashfunc = charhashfast;
             *fasteqfunc = chareqfast;
             *eqfunc = F_CHAREQ;
             break;
         case NAMEOID:
             *hashfunc = namehashfast;
             *fasteqfunc = nameeqfast;
             *eqfunc = F_NAMEEQ;
             break;
         case INT2OID:
             *hashfunc = int2hashfast;
             *fasteqfunc = int2eqfast;
             *eqfunc = F_INT2EQ;
             break;
         case INT4OID:
             *hashfunc = int4hashfast;
             *fasteqfunc = int4eqfast;
             *eqfunc = F_INT4EQ;
             break;
         case TEXTOID:
             *hashfunc = texthashfast;
             *fasteqfunc = texteqfast;
             *eqfunc = F_TEXTEQ;
             break;
         case OIDOID:
         case REGPROCOID:
         case REGPROCEDUREOID:
         case REGOPEROID:
         case REGOPERATOROID:
         case REGCLASSOID:
         case REGTYPEOID:
         case REGCOLLATIONOID:
         case REGCONFIGOID:
         case REGDICTIONARYOID:
         case REGROLEOID:
         case REGNAMESPACEOID:
             *hashfunc = int4hashfast;
             *fasteqfunc = int4eqfast;
             *eqfunc = F_OIDEQ;
             break;
         case OIDVECTOROID:
             *hashfunc = oidvectorhashfast;
             *fasteqfunc = oidvectoreqfast;
             *eqfunc = F_OIDVECTOREQ;
             break;
         default:
             elog(FATAL, "type %u not supported as catcache key", keytype);
             *hashfunc = NULL;   /* keep compiler quiet */
  
             *eqfunc = InvalidOid;
             break;
     }
 }

References chareqfast(), charhashfast(), elog, FATAL, int2eqfast(), int2hashfast(), int4eqfast(), int4hashfast(), InvalidOid, nameeqfast(), namehashfast(), oidvectoreqfast(), oidvectorhashfast(), texteqfast(), and texthashfast().

Referenced by CatalogCacheInitializeCache().

◆ IndexScanOK()

static bool IndexScanOK	(	CatCache *	cache,
		ScanKey	cur_skey
	)

static

Definition at line 1197 of file catcache.c.

 {
     switch (cache->id)
     {
         case INDEXRELID:
  
             /*
              * Rather than tracking exactly which indexes have to be loaded
              * before we can use indexscans (which changes from time to time),
              * just force all pg_index searches to be heap scans until we've
              * built the critical relcaches.
              */
             if (!criticalRelcachesBuilt)
                 return false;
             break;
  
         case AMOID:
         case AMNAME:
  
             /*
              * Always do heap scans in pg_am, because it's so small there's
              * not much point in an indexscan anyway.  We *must* do this when
              * initially building critical relcache entries, but we might as
              * well just always do it.
              */
             return false;
  
         case AUTHNAME:
         case AUTHOID:
         case AUTHMEMMEMROLE:
         case DATABASEOID:
  
             /*
              * Protect authentication lookups occurring before relcache has
              * collected entries for shared indexes.
              */
             if (!criticalSharedRelcachesBuilt)
                 return false;
             break;
  
         default:
             break;
     }
  
     /* Normal case, allow index scan */
     return true;
 }

References criticalRelcachesBuilt, criticalSharedRelcachesBuilt, and catcache::id.

Referenced by SearchCatCacheList(), and SearchCatCacheMiss().

◆ InitCatCache()

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

Definition at line 828 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 = (CatCacheHeader *) palloc(sizeof(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(), palloc(), palloc0(), palloc_aligned(), PG_CACHE_LINE_SIZE, slist_init(), and slist_push_head().

Referenced by InitCatalogCache().

◆ InitCatCachePhase2()

void InitCatCachePhase2	(	CatCache *	cache,
		bool	touch_index
	)

Definition at line 1145 of file catcache.c.

 {
     if (cache->cc_tupdesc == NULL)
         CatalogCacheInitializeCache(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, CatalogCacheInitializeCache(), catcache::cc_indexoid, catcache::cc_reloid, catcache::cc_tupdesc, catcache::id, index_close(), index_open(), LockRelationOid(), RelationData::rd_index, and UnlockRelationOid().

Referenced by InitCatalogCachePhase2(), and SysCacheGetAttr().

◆ int2eqfast()

static bool int2eqfast	(	Datum	a,
		Datum	b
	)

static

Definition at line 202 of file catcache.c.

 {
     return DatumGetInt16(a) == DatumGetInt16(b);
 }

References a, b, and DatumGetInt16().

Referenced by GetCCHashEqFuncs().

◆ int2hashfast()

static uint32 int2hashfast ( Datum datum )

static

Definition at line 208 of file catcache.c.

 {
     return murmurhash32((int32) DatumGetInt16(datum));
 }

References DatumGetInt16(), and murmurhash32().

Referenced by GetCCHashEqFuncs().

◆ int4eqfast()

static bool int4eqfast	(	Datum	a,
		Datum	b
	)

static

Definition at line 214 of file catcache.c.

 {
     return DatumGetInt32(a) == DatumGetInt32(b);
 }

References a, b, and DatumGetInt32().

Referenced by GetCCHashEqFuncs().

◆ int4hashfast()

static uint32 int4hashfast ( Datum datum )

static

Definition at line 220 of file catcache.c.

 {
     return murmurhash32((int32) DatumGetInt32(datum));
 }

References DatumGetInt32(), and murmurhash32().

Referenced by GetCCHashEqFuncs().

◆ nameeqfast()

static bool nameeqfast	(	Datum	a,
		Datum	b
	)

static

Definition at line 185 of file catcache.c.

 {
     char       *ca = NameStr(*DatumGetName(a));
     char       *cb = NameStr(*DatumGetName(b));
  
     return strncmp(ca, cb, NAMEDATALEN) == 0;
 }

References a, b, DatumGetName(), NAMEDATALEN, and NameStr.

Referenced by GetCCHashEqFuncs().

◆ namehashfast()

static uint32 namehashfast ( Datum datum )

static

Definition at line 194 of file catcache.c.

 {
     char       *key = NameStr(*DatumGetName(datum));
  
     return hash_any((unsigned char *) key, strlen(key));
 }

References DatumGetName(), hash_any(), sort-test::key, and NameStr.

Referenced by GetCCHashEqFuncs().

◆ oidvectoreqfast()

static bool oidvectoreqfast	(	Datum	a,
		Datum	b
	)

static

Definition at line 243 of file catcache.c.

 {
     return DatumGetBool(DirectFunctionCall2(oidvectoreq, a, b));
 }

References a, b, DatumGetBool(), DirectFunctionCall2, and oidvectoreq().

Referenced by GetCCHashEqFuncs().

◆ oidvectorhashfast()

static uint32 oidvectorhashfast ( Datum datum )

static

Definition at line 249 of file catcache.c.

 {
     return DatumGetInt32(DirectFunctionCall1(hashoidvector, datum));
 }

References DatumGetInt32(), DirectFunctionCall1, and hashoidvector().

Referenced by GetCCHashEqFuncs().

◆ PrepareToInvalidateCacheTuple()

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

Definition at line 2288 of file catcache.c.

 {
     slist_iter  iter;
     Oid         reloid;
  
     CACHE_elog(DEBUG2, "PrepareToInvalidateCacheTuple: called");
  
     /*
      * sanity checks
      */
     Assert(RelationIsValid(relation));
     Assert(HeapTupleIsValid(tuple));
     Assert(PointerIsValid(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... */
         if (ccp->cc_tupdesc == NULL)
             CatalogCacheInitializeCache(ccp);
  
         hashvalue = CatalogCacheComputeTupleHashValue(ccp, ccp->cc_nkeys, tuple);
         dbid = ccp->cc_relisshared ? (Oid) 0 : MyDatabaseId;
  
         (*function) (ccp->id, hashvalue, dbid);
  
         if (newtuple)
         {
             uint32      newhashvalue;
  
             newhashvalue = CatalogCacheComputeTupleHashValue(ccp, ccp->cc_nkeys, newtuple);
  
             if (newhashvalue != hashvalue)
                 (*function) (ccp->id, newhashvalue, dbid);
         }
     }
 }

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

Referenced by CacheInvalidateHeapTuple().

◆ RehashCatCache()

static void RehashCatCache ( CatCache * cp )

static

Definition at line 935 of file catcache.c.

 {
     dlist_head *newbucket;
     int         newnbuckets;
     int         i;
  
     elog(DEBUG1, "rehashing catalog cache id %d for %s; %d tups, %d buckets",
          cp->id, cp->cc_relname, cp->cc_ntup, cp->cc_nbuckets);
  
     /* Allocate a new, larger, hash table. */
     newnbuckets = cp->cc_nbuckets * 2;
     newbucket = (dlist_head *) MemoryContextAllocZero(CacheMemoryContext, newnbuckets * sizeof(dlist_head));
  
     /* Move all entries from old hash table to new. */
     for (i = 0; i < cp->cc_nbuckets; i++)
     {
         dlist_mutable_iter iter;
  
         dlist_foreach_modify(iter, &cp->cc_bucket[i])
         {
             CatCTup    *ct = dlist_container(CatCTup, cache_elem, iter.cur);
             int         hashIndex = HASH_INDEX(ct->hash_value, newnbuckets);
  
             dlist_delete(iter.cur);
             dlist_push_head(&newbucket[hashIndex], &ct->cache_elem);
         }
     }
  
     /* Switch to the new array. */
     pfree(cp->cc_bucket);
     cp->cc_nbuckets = newnbuckets;
     cp->cc_bucket = newbucket;
 }

References catctup::cache_elem, CacheMemoryContext, catcache::cc_bucket, catcache::cc_nbuckets, catcache::cc_ntup, catcache::cc_relname, dlist_mutable_iter::cur, DEBUG1, dlist_container, dlist_delete(), dlist_foreach_modify, dlist_push_head(), elog, HASH_INDEX, catctup::hash_value, i, catcache::id, MemoryContextAllocZero(), and pfree().

Referenced by CatalogCacheCreateEntry().

◆ RehashCatCacheLists()

static void RehashCatCacheLists ( CatCache * cp )

static

Definition at line 973 of file catcache.c.

 {
     dlist_head *newbucket;
     int         newnbuckets;
     int         i;
  
     elog(DEBUG1, "rehashing catalog cache id %d for %s; %d lists, %d buckets",
          cp->id, cp->cc_relname, cp->cc_nlist, cp->cc_nlbuckets);
  
     /* Allocate a new, larger, hash table. */
     newnbuckets = cp->cc_nlbuckets * 2;
     newbucket = (dlist_head *) MemoryContextAllocZero(CacheMemoryContext, newnbuckets * sizeof(dlist_head));
  
     /* Move all entries from old hash table to new. */
     for (i = 0; i < cp->cc_nlbuckets; i++)
     {
         dlist_mutable_iter iter;
  
         dlist_foreach_modify(iter, &cp->cc_lbucket[i])
         {
             CatCList   *cl = dlist_container(CatCList, cache_elem, iter.cur);
             int         hashIndex = HASH_INDEX(cl->hash_value, newnbuckets);
  
             dlist_delete(iter.cur);
             dlist_push_head(&newbucket[hashIndex], &cl->cache_elem);
         }
     }
  
     /* Switch to the new array. */
     pfree(cp->cc_lbucket);
     cp->cc_nlbuckets = newnbuckets;
     cp->cc_lbucket = newbucket;
 }

References catclist::cache_elem, CacheMemoryContext, catcache::cc_lbucket, catcache::cc_nlbuckets, catcache::cc_nlist, catcache::cc_relname, dlist_mutable_iter::cur, DEBUG1, dlist_container, dlist_delete(), dlist_foreach_modify, dlist_push_head(), elog, HASH_INDEX, catclist::hash_value, i, catcache::id, MemoryContextAllocZero(), and pfree().

Referenced by SearchCatCacheList().

◆ ReleaseCatCache()

void ReleaseCatCache ( HeapTuple tuple )

Definition at line 1574 of file catcache.c.

 {
     ReleaseCatCacheWithOwner(tuple, CurrentResourceOwner);
 }

References CurrentResourceOwner, and ReleaseCatCacheWithOwner().

Referenced by ReleaseSysCache().

◆ ReleaseCatCacheList()

void ReleaseCatCacheList ( CatCList * list )

Definition at line 1987 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().

◆ ReleaseCatCacheListWithOwner()

static void ReleaseCatCacheListWithOwner	(	CatCList *	list,
		ResourceOwner	resowner
	)

static

Definition at line 1993 of file catcache.c.

 {
     /* Safety checks to ensure we were handed a cache entry */
     Assert(list->cl_magic == CL_MAGIC);
     Assert(list->refcount > 0);
     list->refcount--;
     if (resowner)
         ResourceOwnerForgetCatCacheListRef(CurrentResourceOwner, list);
  
     if (
 #ifndef CATCACHE_FORCE_RELEASE
         list->dead &&
 #endif
         list->refcount == 0)
         CatCacheRemoveCList(list->my_cache, list);
 }

References Assert, CatCacheRemoveCList(), CL_MAGIC, CurrentResourceOwner, sort-test::list, and ResourceOwnerForgetCatCacheListRef().

Referenced by ReleaseCatCacheList(), and ResOwnerReleaseCatCacheList().

◆ ReleaseCatCacheWithOwner()

static void ReleaseCatCacheWithOwner	(	HeapTuple	tuple,
		ResourceOwner	resowner
	)

static

Definition at line 1580 of file catcache.c.

 {
     CatCTup    *ct = (CatCTup *) (((char *) tuple) -
                                   offsetof(CatCTup, tuple));
  
     /* Safety checks to ensure we were handed a cache entry */
     Assert(ct->ct_magic == CT_MAGIC);
     Assert(ct->refcount > 0);
  
     ct->refcount--;
     if (resowner)
         ResourceOwnerForgetCatCacheRef(CurrentResourceOwner, &ct->tuple);
  
     if (
 #ifndef CATCACHE_FORCE_RELEASE
         ct->dead &&
 #endif
         ct->refcount == 0 &&
         (ct->c_list == NULL || ct->c_list->refcount == 0))
         CatCacheRemoveCTup(ct->my_cache, ct);
 }

References Assert, catctup::c_list, CatCacheRemoveCTup(), catctup::ct_magic, CT_MAGIC, CurrentResourceOwner, catctup::dead, catctup::my_cache, catctup::refcount, catclist::refcount, ResourceOwnerForgetCatCacheRef(), and catctup::tuple.

Referenced by ReleaseCatCache(), and ResOwnerReleaseCatCache().

◆ ResetCatalogCache()

static void ResetCatalogCache ( CatCache * cache )

static

Definition at line 702 of file catcache.c.

 {
     dlist_mutable_iter iter;
     int         i;
  
     /* Remove each list in this cache, or at least mark it dead */
     for (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);
         }
     }
  
     /* Remove each tuple in this cache, or at least mark it dead */
     for (i = 0; i < cache->cc_nbuckets; i++)
     {
         dlist_head *bucket = &cache->cc_bucket[i];
  
         dlist_foreach_modify(iter, bucket)
         {
             CatCTup    *ct = dlist_container(CatCTup, cache_elem, iter.cur);
  
             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);
 #ifdef CATCACHE_STATS
             cache->cc_invals++;
 #endif
         }
     }
 }

References Assert, catctup::c_list, CatCacheRemoveCList(), CatCacheRemoveCTup(), catcache::cc_bucket, catcache::cc_lbucket, catcache::cc_nbuckets, catcache::cc_nlbuckets, dlist_mutable_iter::cur, catctup::dead, catclist::dead, dlist_container, dlist_foreach_modify, i, catctup::refcount, and catclist::refcount.

Referenced by CatalogCacheFlushCatalog(), and ResetCatalogCaches().

◆ ResetCatalogCaches()

void ResetCatalogCaches ( void )

Definition at line 754 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);
     }
  
     CACHE_elog(DEBUG2, "end of ResetCatalogCaches call");
 }

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

Referenced by InvalidateSystemCachesExtended().

◆ ResourceOwnerForgetCatCacheListRef()

static void ResourceOwnerForgetCatCacheListRef	(	ResourceOwner	owner,
		CatCList *	list
	)

inlinestatic

Definition at line 156 of file catcache.c.

 {
     ResourceOwnerForget(owner, PointerGetDatum(list), &catlistref_resowner_desc);
 }

References catlistref_resowner_desc, sort-test::list, PointerGetDatum(), and ResourceOwnerForget().

Referenced by ReleaseCatCacheListWithOwner().

◆ ResourceOwnerForgetCatCacheRef()

static void ResourceOwnerForgetCatCacheRef	(	ResourceOwner	owner,
		HeapTuple	tuple
	)

inlinestatic

Definition at line 146 of file catcache.c.

 {
     ResourceOwnerForget(owner, PointerGetDatum(tuple), &catcache_resowner_desc);
 }

References catcache_resowner_desc, PointerGetDatum(), and ResourceOwnerForget().

Referenced by ReleaseCatCacheWithOwner().

◆ ResourceOwnerRememberCatCacheListRef()

static void ResourceOwnerRememberCatCacheListRef	(	ResourceOwner	owner,
		CatCList *	list
	)

inlinestatic

Definition at line 151 of file catcache.c.

 {
     ResourceOwnerRemember(owner, PointerGetDatum(list), &catlistref_resowner_desc);
 }

References catlistref_resowner_desc, sort-test::list, PointerGetDatum(), and ResourceOwnerRemember().

Referenced by SearchCatCacheList().

◆ ResourceOwnerRememberCatCacheRef()

static void ResourceOwnerRememberCatCacheRef	(	ResourceOwner	owner,
		HeapTuple	tuple
	)

inlinestatic

Definition at line 141 of file catcache.c.

 {
     ResourceOwnerRemember(owner, PointerGetDatum(tuple), &catcache_resowner_desc);
 }

References catcache_resowner_desc, PointerGetDatum(), and ResourceOwnerRemember().

Referenced by SearchCatCacheInternal(), and SearchCatCacheMiss().

◆ ResOwnerPrintCatCache()

static char * ResOwnerPrintCatCache ( Datum res )

static

Definition at line 2355 of file catcache.c.

 {
     HeapTuple   tuple = (HeapTuple) DatumGetPointer(res);
     CatCTup    *ct = (CatCTup *) (((char *) tuple) -
                                   offsetof(CatCTup, tuple));
  
     /* Safety check to ensure we were handed a cache entry */
     Assert(ct->ct_magic == CT_MAGIC);
  
     return psprintf("cache %s (%d), tuple %u/%u has count %d",
                     ct->my_cache->cc_relname, ct->my_cache->id,
                     ItemPointerGetBlockNumber(&(tuple->t_self)),
                     ItemPointerGetOffsetNumber(&(tuple->t_self)),
                     ct->refcount);
 }

References Assert, catcache::cc_relname, catctup::ct_magic, CT_MAGIC, DatumGetPointer(), catcache::id, ItemPointerGetBlockNumber(), ItemPointerGetOffsetNumber(), catctup::my_cache, psprintf(), catctup::refcount, res, and HeapTupleData::t_self.

◆ ResOwnerPrintCatCacheList()

static char * ResOwnerPrintCatCacheList ( Datum res )

static

Definition at line 2378 of file catcache.c.

 {
     CatCList   *list = (CatCList *) DatumGetPointer(res);
  
     return psprintf("cache %s (%d), list %p has count %d",
                     list->my_cache->cc_relname, list->my_cache->id,
                     list, list->refcount);
 }

References DatumGetPointer(), sort-test::list, psprintf(), and res.

◆ ResOwnerReleaseCatCache()

static void ResOwnerReleaseCatCache ( Datum res )

static

Definition at line 2349 of file catcache.c.

 {
     ReleaseCatCacheWithOwner((HeapTuple) DatumGetPointer(res), NULL);
 }

References DatumGetPointer(), ReleaseCatCacheWithOwner(), and res.

◆ ResOwnerReleaseCatCacheList()

static void ResOwnerReleaseCatCacheList ( Datum res )

static

Definition at line 2372 of file catcache.c.

 {
     ReleaseCatCacheListWithOwner((CatCList *) DatumGetPointer(res), NULL);
 }

References DatumGetPointer(), ReleaseCatCacheListWithOwner(), and res.

◆ SearchCatCache()

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

Definition at line 1262 of file catcache.c.

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

References catcache::cc_nkeys, and SearchCatCacheInternal().

Referenced by SearchSysCache().

◆ SearchCatCache1()

HeapTuple SearchCatCache1	(	CatCache *	cache,
		Datum	v1
	)

Definition at line 1279 of file catcache.c.

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

References SearchCatCacheInternal().

Referenced by SearchSysCache1().

◆ SearchCatCache2()

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

Definition at line 1287 of file catcache.c.

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

References SearchCatCacheInternal().

Referenced by SearchSysCache2().

◆ SearchCatCache3()

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

Definition at line 1295 of file catcache.c.

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

References SearchCatCacheInternal().

Referenced by SearchSysCache3().

◆ SearchCatCache4()

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

Definition at line 1303 of file catcache.c.

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

References SearchCatCacheInternal().

Referenced by SearchSysCache4().

◆ SearchCatCacheInternal()

static HeapTuple SearchCatCacheInternal	(	CatCache *	cache,
		int	nkeys,
		Datum	v1,
		Datum	v2,
		Datum	v3,
		Datum	v4
	)

inlinestatic

Definition at line 1313 of file catcache.c.

 {
     Datum       arguments[CATCACHE_MAXKEYS];
     uint32      hashValue;
     Index       hashIndex;
     dlist_iter  iter;
     dlist_head *bucket;
     CatCTup    *ct;
  
     /* Make sure we're in an xact, even if this ends up being a cache hit */
     Assert(IsTransactionState());
  
     Assert(cache->cc_nkeys == nkeys);
  
     /*
      * one-time startup overhead for each cache
      */
     if (unlikely(cache->cc_tupdesc == NULL))
         CatalogCacheInitializeCache(cache);
  
 #ifdef CATCACHE_STATS
     cache->cc_searches++;
 #endif
  
     /* Initialize local parameter array */
     arguments[0] = v1;
     arguments[1] = v2;
     arguments[2] = v3;
     arguments[3] = v4;
  
     /*
      * find the hash bucket in which to look for the tuple
      */
     hashValue = CatalogCacheComputeHashValue(cache, nkeys, v1, v2, v3, v4);
     hashIndex = HASH_INDEX(hashValue, cache->cc_nbuckets);
  
     /*
      * scan the hash bucket until we find a match or exhaust our tuples
      *
      * 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.
      */
     bucket = &cache->cc_bucket[hashIndex];
     dlist_foreach(iter, bucket)
     {
         ct = dlist_container(CatCTup, cache_elem, iter.cur);
  
         if (ct->dead)
             continue;           /* ignore dead entries */
  
         if (ct->hash_value != hashValue)
             continue;           /* quickly skip entry if wrong hash val */
  
         if (!CatalogCacheCompareTuple(cache, nkeys, ct->keys, arguments))
             continue;
  
         /*
          * We found a match in the cache.  Move it to the front of the list
          * for its hashbucket, in order to speed subsequent searches.  (The
          * most frequently accessed elements in any hashbucket will tend to be
          * near the front of the hashbucket's list.)
          */
         dlist_move_head(bucket, &ct->cache_elem);
  
         /*
          * If it's a positive entry, bump its refcount and return it. If it's
          * negative, we can report failure to the caller.
          */
         if (!ct->negative)
         {
             ResourceOwnerEnlarge(CurrentResourceOwner);
             ct->refcount++;
             ResourceOwnerRememberCatCacheRef(CurrentResourceOwner, &ct->tuple);
  
             CACHE_elog(DEBUG2, "SearchCatCache(%s): found in bucket %d",
                        cache->cc_relname, hashIndex);
  
 #ifdef CATCACHE_STATS
             cache->cc_hits++;
 #endif
  
             return &ct->tuple;
         }
         else
         {
             CACHE_elog(DEBUG2, "SearchCatCache(%s): found neg entry in bucket %d",
                        cache->cc_relname, hashIndex);
  
 #ifdef CATCACHE_STATS
             cache->cc_neg_hits++;
 #endif
  
             return NULL;
         }
     }
  
     return SearchCatCacheMiss(cache, nkeys, hashValue, hashIndex, v1, v2, v3, v4);
 }

References Assert, catctup::cache_elem, CACHE_elog, CatalogCacheCompareTuple(), CatalogCacheComputeHashValue(), CatalogCacheInitializeCache(), CATCACHE_MAXKEYS, catcache::cc_bucket, catcache::cc_nbuckets, catcache::cc_nkeys, catcache::cc_relname, catcache::cc_tupdesc, dlist_iter::cur, CurrentResourceOwner, catctup::dead, DEBUG2, dlist_container, dlist_foreach, dlist_move_head(), HASH_INDEX, catctup::hash_value, IsTransactionState(), catctup::keys, catctup::negative, catctup::refcount, ResourceOwnerEnlarge(), ResourceOwnerRememberCatCacheRef(), SearchCatCacheMiss(), catctup::tuple, and unlikely.

Referenced by SearchCatCache(), SearchCatCache1(), SearchCatCache2(), SearchCatCache3(), and SearchCatCache4().

◆ SearchCatCacheList()

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

Definition at line 1647 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;
  
     /*
      * one-time startup overhead for each cache
      */
     if (unlikely(cache->cc_tupdesc == NULL))
         CatalogCacheInitializeCache(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;
  
     PG_TRY();
     {
         ScanKeyData cur_skey[CATCACHE_MAXKEYS];
         Relation    relation;
         SysScanDesc scandesc;
         bool        stale;
  
         relation = table_open(cache->cc_reloid, AccessShareLock);
  
         do
         {
             /*
              * Ok, need to make a lookup in the relation, copy the scankey and
              * fill out any per-call fields.  (We must re-do this when
              * retrying, because systable_beginscan scribbles on the scankey.)
              */
             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;
  
             scandesc = systable_beginscan(relation,
                                           cache->cc_indexoid,
                                           IndexScanOK(cache, cur_skey),
                                           NULL,
                                           nkeys,
                                           cur_skey);
  
             /* The list will be ordered iff we are doing an index scan */
             ordered = (scandesc->irel != NULL);
  
             stale = false;
  
             while (HeapTupleIsValid(ntp = systable_getnext(scandesc)))
             {
                 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, scandesc, NULL,
                                                  hashValue, hashIndex);
                     /* upon failure, we must start the scan over */
                     if (ct == NULL)
                     {
                         /*
                          * Release refcounts on any items we already had.  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;
                         stale = 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 (stale);
  
         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();
     {
         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();
  
     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, catclist::cache_elem, CACHE_elog, CacheMemoryContext, CatalogCacheCompareTuple(), CatalogCacheComputeHashValue(), CatalogCacheComputeTupleHashValue(), CatalogCacheCreateEntry(), CatalogCacheInitializeCache(), 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, dlist_iter::cur, CurrentResourceOwner, catctup::dead, catclist::dead, DEBUG2, dlist_container, dlist_foreach, dlist_move_head(), dlist_push_head(), HASH_INDEX, catctup::hash_value, catclist::hash_value, HeapTupleIsValid, i, IndexScanOK(), SysScanDescData::irel, ItemPointerEquals(), catclist::keys, lappend(), lfirst, list_length(), catclist::members, MemoryContextAllocZero(), MemoryContextSwitchTo(), catclist::my_cache, catclist::n_members, catctup::negative, 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(), catctup::tuple, and unlikely.

Referenced by SearchSysCacheList().

◆ SearchCatCacheMiss()

static pg_noinline HeapTuple SearchCatCacheMiss	(	CatCache *	cache,
		int	nkeys,
		uint32	hashValue,
		Index	hashIndex,
		Datum	v1,
		Datum	v2,
		Datum	v3,
		Datum	v4
	)

static

Definition at line 1425 of file catcache.c.

 {
     ScanKeyData cur_skey[CATCACHE_MAXKEYS];
     Relation    relation;
     SysScanDesc scandesc;
     HeapTuple   ntp;
     CatCTup    *ct;
     bool        stale;
     Datum       arguments[CATCACHE_MAXKEYS];
  
     /* Initialize local parameter array */
     arguments[0] = v1;
     arguments[1] = v2;
     arguments[2] = v3;
     arguments[3] = v4;
  
     /*
      * Tuple was not found in cache, so we have to try to retrieve it directly
      * from the relation.  If found, we will add it to the cache; if not
      * found, we will add a negative cache entry instead.
      *
      * NOTE: it is possible for recursive cache lookups to occur while reading
      * the relation --- for example, due to shared-cache-inval messages being
      * processed during table_open().  This is OK.  It's even possible for one
      * of those lookups to find and enter the very same tuple we are trying to
      * fetch here.  If that happens, we will enter a second copy of the tuple
      * into the cache.  The first copy will never be referenced again, and
      * will eventually age out of the cache, so there's no functional problem.
      * This case is rare enough that it's not worth expending extra cycles to
      * detect.
      *
      * Another case, which we *must* handle, is that the tuple could become
      * outdated during CatalogCacheCreateEntry's attempt to detoast it (since
      * AcceptInvalidationMessages can run during TOAST table access).  We do
      * not want to return already-stale catcache entries, so we loop around
      * and do the table scan again if that happens.
      */
     relation = table_open(cache->cc_reloid, AccessShareLock);
  
     do
     {
         /*
          * Ok, need to make a lookup in the relation, copy the scankey and
          * fill out any per-call fields.  (We must re-do this when retrying,
          * because systable_beginscan scribbles on the scankey.)
          */
         memcpy(cur_skey, cache->cc_skey, sizeof(ScanKeyData) * 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;
  
         scandesc = systable_beginscan(relation,
                                       cache->cc_indexoid,
                                       IndexScanOK(cache, cur_skey),
                                       NULL,
                                       nkeys,
                                       cur_skey);
  
         ct = NULL;
         stale = false;
  
         while (HeapTupleIsValid(ntp = systable_getnext(scandesc)))
         {
             ct = CatalogCacheCreateEntry(cache, ntp, scandesc, NULL,
                                          hashValue, hashIndex);
             /* upon failure, we must start the scan over */
             if (ct == NULL)
             {
                 stale = true;
                 break;
             }
             /* immediately set the refcount to 1 */
             ResourceOwnerEnlarge(CurrentResourceOwner);
             ct->refcount++;
             ResourceOwnerRememberCatCacheRef(CurrentResourceOwner, &ct->tuple);
             break;              /* assume only one match */
         }
  
         systable_endscan(scandesc);
     } while (stale);
  
     table_close(relation, AccessShareLock);
  
     /*
      * If tuple was not found, we need to build a negative cache entry
      * containing a fake tuple.  The fake tuple has the correct key columns,
      * but nulls everywhere else.
      *
      * In bootstrap mode, we don't build negative entries, because the cache
      * invalidation mechanism isn't alive and can't clear them if the tuple
      * gets created later.  (Bootstrap doesn't do UPDATEs, so it doesn't need
      * cache inval for that.)
      */
     if (ct == NULL)
     {
         if (IsBootstrapProcessingMode())
             return NULL;
  
         ct = CatalogCacheCreateEntry(cache, NULL, NULL, arguments,
                                      hashValue, hashIndex);
  
         /* Creating a negative cache entry shouldn't fail */
         Assert(ct != NULL);
  
         CACHE_elog(DEBUG2, "SearchCatCache(%s): Contains %d/%d tuples",
                    cache->cc_relname, cache->cc_ntup, CacheHdr->ch_ntup);
         CACHE_elog(DEBUG2, "SearchCatCache(%s): put neg entry in bucket %d",
                    cache->cc_relname, hashIndex);
  
         /*
          * We are not returning the negative entry to the caller, so leave its
          * refcount zero.
          */
  
         return NULL;
     }
  
     CACHE_elog(DEBUG2, "SearchCatCache(%s): Contains %d/%d tuples",
                cache->cc_relname, cache->cc_ntup, CacheHdr->ch_ntup);
     CACHE_elog(DEBUG2, "SearchCatCache(%s): put in bucket %d",
                cache->cc_relname, hashIndex);
  
 #ifdef CATCACHE_STATS
     cache->cc_newloads++;
 #endif
  
     return &ct->tuple;
 }

References AccessShareLock, Assert, CACHE_elog, CacheHdr, CatalogCacheCreateEntry(), CATCACHE_MAXKEYS, catcache::cc_indexoid, catcache::cc_ntup, catcache::cc_relname, catcache::cc_reloid, catcache::cc_skey, catcacheheader::ch_ntup, CurrentResourceOwner, DEBUG2, HeapTupleIsValid, IndexScanOK(), IsBootstrapProcessingMode, catctup::refcount, ResourceOwnerEnlarge(), ResourceOwnerRememberCatCacheRef(), ScanKeyData::sk_argument, systable_beginscan(), systable_endscan(), systable_getnext(), table_close(), table_open(), and catctup::tuple.

Referenced by SearchCatCacheInternal().

◆ texteqfast()

static bool texteqfast	(	Datum	a,
		Datum	b
	)

static

Definition at line 226 of file catcache.c.

 {
     /*
      * The use of DEFAULT_COLLATION_OID is fairly arbitrary here.  We just
      * want to take the fast "deterministic" path in texteq().
      */
     return DatumGetBool(DirectFunctionCall2Coll(texteq, DEFAULT_COLLATION_OID, a, b));
 }

References a, b, DatumGetBool(), DirectFunctionCall2Coll(), and texteq().

Referenced by GetCCHashEqFuncs().

◆ texthashfast()

static uint32 texthashfast ( Datum datum )

static

Definition at line 236 of file catcache.c.

 {
     /* analogously here as in texteqfast() */
     return DatumGetInt32(DirectFunctionCall1Coll(hashtext, DEFAULT_COLLATION_OID, datum));
 }

References DatumGetInt32(), DirectFunctionCall1Coll(), and hashtext().

Referenced by GetCCHashEqFuncs().

Variable Documentation

◆ CacheHdr

CatCacheHeader* CacheHdr = NULL

static

Definition at line 65 of file catcache.c.

Referenced by CatalogCacheCreateEntry(), CatalogCacheFlushCatalog(), CatCacheRemoveCTup(), InitCatCache(), PrepareToInvalidateCacheTuple(), ResetCatalogCaches(), and SearchCatCacheMiss().

◆ catcache_resowner_desc

const ResourceOwnerDesc catcache_resowner_desc

static

Initial value:

=
{
    
    .name = "catcache reference",
    .release_phase = RESOURCE_RELEASE_AFTER_LOCKS,
    .release_priority = RELEASE_PRIO_CATCACHE_REFS,
    .ReleaseResource = ResOwnerReleaseCatCache,
    .DebugPrint = ResOwnerPrintCatCache
}

Definition at line 119 of file catcache.c.

Referenced by ResourceOwnerForgetCatCacheRef(), and ResourceOwnerRememberCatCacheRef().

◆ catlistref_resowner_desc

const ResourceOwnerDesc catlistref_resowner_desc

static

Initial value:

=
{
    
    .name = "catcache list reference",
    .release_phase = RESOURCE_RELEASE_AFTER_LOCKS,
    .release_priority = RELEASE_PRIO_CATCACHE_LIST_REFS,
    .ReleaseResource = ResOwnerReleaseCatCacheList,
    .DebugPrint = ResOwnerPrintCatCacheList
}

Definition at line 129 of file catcache.c.

Referenced by ResourceOwnerForgetCatCacheListRef(), and ResourceOwnerRememberCatCacheListRef().

Macros

Functions

Variables

Macro Definition Documentation

◆ CACHE_elog

◆ CatalogCacheInitializeCache_DEBUG1

◆ CatalogCacheInitializeCache_DEBUG2

◆ HASH_INDEX

◆ InitCatCache_DEBUG2

Function Documentation

◆ CatalogCacheCompareTuple()

◆ CatalogCacheComputeHashValue()

◆ CatalogCacheComputeTupleHashValue()

◆ CatalogCacheCreateEntry()

◆ CatalogCacheFlushCatalog()

◆ CatalogCacheInitializeCache()

◆ CatCacheCopyKeys()

◆ CatCacheFreeKeys()

◆ CatCacheInvalidate()

◆ CatCacheRemoveCList()

◆ CatCacheRemoveCTup()

◆ chareqfast()

◆ charhashfast()

◆ CreateCacheMemoryContext()

◆ equalTuple()

◆ GetCatCacheHashValue()

◆ GetCCHashEqFuncs()

◆ IndexScanOK()

◆ InitCatCache()

◆ InitCatCachePhase2()

◆ int2eqfast()

◆ int2hashfast()

◆ int4eqfast()

◆ int4hashfast()

◆ nameeqfast()

◆ namehashfast()

◆ oidvectoreqfast()

◆ oidvectorhashfast()

◆ PrepareToInvalidateCacheTuple()

◆ RehashCatCache()

◆ RehashCatCacheLists()

◆ ReleaseCatCache()

◆ ReleaseCatCacheList()

◆ ReleaseCatCacheListWithOwner()

◆ ReleaseCatCacheWithOwner()

◆ ResetCatalogCache()

◆ ResetCatalogCaches()

◆ ResourceOwnerForgetCatCacheListRef()

◆ ResourceOwnerForgetCatCacheRef()

◆ ResourceOwnerRememberCatCacheListRef()

◆ ResourceOwnerRememberCatCacheRef()

◆ ResOwnerPrintCatCache()

◆ ResOwnerPrintCatCacheList()

◆ ResOwnerReleaseCatCache()

◆ ResOwnerReleaseCatCacheList()

◆ SearchCatCache()

◆ SearchCatCache1()

◆ SearchCatCache2()

◆ SearchCatCache3()

◆ SearchCatCache4()

◆ SearchCatCacheInternal()

◆ SearchCatCacheList()

◆ SearchCatCacheMiss()

◆ texteqfast()

◆ texthashfast()

Variable Documentation

◆ CacheHdr

◆ catcache_resowner_desc

◆ catlistref_resowner_desc