36#include "utils/fmgroids.h"
70#define HASH_INDEX(h, sz) ((Index) ((h) & ((sz) - 1)))
78#define CACHE_elog(...) elog(__VA_ARGS__)
80#define CACHE_elog(...)
103 const Datum *cachekeys,
104 const Datum *searchkeys);
107static void CatCachePrintStats(
int code,
Datum arg);
140 .
name =
"catcache reference",
150 .
name =
"catcache list reference",
310 case REGPROCEDUREOID:
315 case REGCOLLATIONOID:
317 case REGDICTIONARYOID:
319 case REGNAMESPACEOID:
327 *eqfunc = F_OIDVECTOREQ;
330 elog(
FATAL,
"type %u not supported as catcache key", keytype);
357 oneHash = (cc_hashfunc[3]) (v4);
361 oneHash = (cc_hashfunc[2]) (v3);
365 oneHash = (cc_hashfunc[1]) (v2);
369 oneHash = (cc_hashfunc[0]) (v1);
370 hashValue ^= oneHash;
373 elog(
FATAL,
"wrong number of hash keys: %d", nkeys);
428 elog(
FATAL,
"wrong number of hash keys: %d", nkeys);
442 const Datum *cachekeys,
443 const Datum *searchkeys)
448 for (
i = 0;
i < nkeys;
i++)
450 if (!(cc_fastequal[
i]) (cachekeys[
i], searchkeys[
i]))
460CatCachePrintStats(
int code,
Datum arg)
463 long cc_searches = 0;
465 long cc_neg_hits = 0;
466 long cc_newloads = 0;
469 long cc_lsearches = 0;
478 elog(
DEBUG2,
"catcache %s/%u: %d tup, %ld srch, %ld+%ld=%ld hits, %ld+%ld=%ld loads, %ld invals, %d lists, %ld lsrch, %ld lhits",
493 cc_searches +=
cache->cc_searches;
494 cc_hits +=
cache->cc_hits;
495 cc_neg_hits +=
cache->cc_neg_hits;
496 cc_newloads +=
cache->cc_newloads;
497 cc_invals +=
cache->cc_invals;
499 cc_lsearches +=
cache->cc_lsearches;
500 cc_lhits +=
cache->cc_lhits;
502 elog(
DEBUG2,
"catcache totals: %d tup, %ld srch, %ld+%ld=%ld hits, %ld+%ld=%ld loads, %ld invals, %ld lists, %ld lsrch, %ld lhits",
507 cc_hits + cc_neg_hits,
509 cc_searches - cc_hits - cc_neg_hits - cc_newloads,
510 cc_searches - cc_hits - cc_neg_hits,
586#ifndef CATCACHE_FORCE_RELEASE
688 if (
e->list ||
e->hash_value == hashValue)
716 "CacheMemoryContext",
867#define InitCatCache_DEBUG2 \
869 elog(DEBUG2, "InitCatCache: rel=%u ind=%u id=%d nkeys=%d size=%d", \
870 cp->cc_reloid, cp->cc_indexoid, cp->id, \
871 cp->cc_nkeys, cp->cc_nbuckets); \
874#define InitCatCache_DEBUG2
900 Assert(nbuckets > 0 && (nbuckets & -nbuckets) == nbuckets);
956 for (
i = 0;
i < nkeys; ++
i)
991 elog(
DEBUG1,
"rehashing catalog cache id %d for %s; %d tups, %d buckets",
1029 elog(
DEBUG1,
"rehashing catalog cache id %d for %s; %d lists, %d buckets",
1065#define CatalogCacheInitializeCache_DEBUG1 \
1066 elog(DEBUG2, "CatalogCacheInitializeCache: cache @%p rel=%u", cache, \
1069#define CatalogCacheInitializeCache_DEBUG2 \
1071 if (cache->cc_keyno[i] > 0) { \
1072 elog(DEBUG2, "CatalogCacheInitializeCache: load %d/%d w/%d, %u", \
1073 i+1, cache->cc_nkeys, cache->cc_keyno[i], \
1074 TupleDescAttr(tupdesc, cache->cc_keyno[i] - 1)->atttypid); \
1076 elog(DEBUG2, "CatalogCacheInitializeCache: load %d/%d w/%d", \
1077 i+1, cache->cc_nkeys, cache->cc_keyno[i]); \
1081#define CatalogCacheInitializeCache_DEBUG1
1082#define CatalogCacheInitializeCache_DEBUG2
1142 keytype = attr->atttypid;
1144 Assert(attr->attnotnull);
1149 elog(
FATAL,
"sys attributes are not supported in caches");
1276 case AUTHMEMMEMROLE:
1388#ifdef CATCACHE_STATS
1389 cache->cc_searches++;
1445#ifdef CATCACHE_STATS
1456#ifdef CATCACHE_STATS
1457 cache->cc_neg_hits++;
1546 hashValue, hashIndex);
1581 hashValue, hashIndex);
1604#ifdef CATCACHE_STATS
1605 cache->cc_newloads++;
1643#ifndef CATCACHE_FORCE_RELEASE
1710 List *
volatile ctlist;
1726 Assert(nkeys > 0 && nkeys < cache->cc_nkeys);
1728#ifdef CATCACHE_STATS
1729 cache->cc_lsearches++;
1790 if (cl->
nkeys != nkeys)
1813#ifdef CATCACHE_STATS
1845 in_progress_ent.
list =
true;
1846 in_progress_ent.
dead =
false;
1854 bool first_iter =
true;
1883 foreach(ctlist_item, ctlist)
1892 in_progress_ent.
dead =
false;
1902 ordered = (scandesc->
irel != NULL);
1912 !in_progress_ent.
dead)
1955 hashValue, hashIndex);
1960 in_progress_ent.
dead =
true;
1972 }
while (in_progress_ent.
dead);
2003 foreach(ctlist_item, ctlist)
2010#ifndef CATCACHE_FORCE_RELEASE
2034 foreach(ctlist_item, ctlist)
2087#ifndef CATCACHE_FORCE_RELEASE
2090 list->refcount == 0)
2130#ifdef USE_ASSERT_CHECKING
2156 in_progress_ent.
list =
false;
2157 in_progress_ent.
dead =
false;
2171 if (in_progress_ent.
dead)
2184 MAXIMUM_ALIGNOF + dtp->
t_len);
2192 (
const char *) dtp->
t_data,
2263 for (
i = 0;
i < nkeys;
i++)
2294 for (
i = 0;
i < nkeys;
i++)
2307 if (att->atttypid == NAMEOID)
2399 (*function) (ccp->
id, hashvalue, dbid, context);
2407 if (newhashvalue != hashvalue)
2408 (*function) (ccp->
id, newhashvalue, dbid, context);
2431 return psprintf(
"cache %s (%d), tuple %u/%u has count %d",
2449 return psprintf(
"cache %s (%d), list %p has count %d",
2450 list->my_cache->cc_relname,
list->my_cache->id,
#define AttributeNumberIsValid(attributeNumber)
#define Assert(condition)
#define PointerIsValid(pointer)
struct CatCInProgress CatCInProgress
static bool chareqfast(Datum a, Datum b)
CatCache * InitCatCache(int id, Oid reloid, Oid indexoid, int nkeys, const int *key, int nbuckets)
HeapTuple SearchCatCache2(CatCache *cache, Datum v1, Datum v2)
static bool int4eqfast(Datum a, Datum b)
HeapTuple SearchCatCache3(CatCache *cache, Datum v1, Datum v2, Datum v3)
void ReleaseCatCacheList(CatCList *list)
static void CatalogCacheInitializeCache(CatCache *cache)
static pg_noinline HeapTuple SearchCatCacheMiss(CatCache *cache, int nkeys, uint32 hashValue, Index hashIndex, Datum v1, Datum v2, Datum v3, Datum v4)
static bool int2eqfast(Datum a, Datum b)
static void ReleaseCatCacheWithOwner(HeapTuple tuple, ResourceOwner resowner)
static uint32 int4hashfast(Datum datum)
void InitCatCachePhase2(CatCache *cache, bool touch_index)
void ResetCatalogCaches(void)
CatCList * SearchCatCacheList(CatCache *cache, int nkeys, Datum v1, Datum v2, Datum v3)
static void ResOwnerReleaseCatCache(Datum res)
uint32 GetCatCacheHashValue(CatCache *cache, Datum v1, Datum v2, Datum v3, Datum v4)
static CatCInProgress * catcache_in_progress_stack
static void CatCacheRemoveCTup(CatCache *cache, CatCTup *ct)
static char * ResOwnerPrintCatCache(Datum res)
static void RehashCatCache(CatCache *cp)
static void ResetCatalogCache(CatCache *cache, bool debug_discard)
static CatCTup * CatalogCacheCreateEntry(CatCache *cache, HeapTuple ntp, Datum *arguments, uint32 hashValue, Index hashIndex)
static uint32 CatalogCacheComputeTupleHashValue(CatCache *cache, int nkeys, HeapTuple tuple)
HeapTuple SearchCatCache4(CatCache *cache, Datum v1, Datum v2, Datum v3, Datum v4)
static void ResourceOwnerForgetCatCacheListRef(ResourceOwner owner, CatCList *list)
static const ResourceOwnerDesc catcache_resowner_desc
static void ResOwnerReleaseCatCacheList(Datum res)
static void ResourceOwnerRememberCatCacheRef(ResourceOwner owner, HeapTuple tuple)
void PrepareToInvalidateCacheTuple(Relation relation, HeapTuple tuple, HeapTuple newtuple, void(*function)(int, uint32, Oid, void *), void *context)
#define CatalogCacheInitializeCache_DEBUG1
static void CatCacheCopyKeys(TupleDesc tupdesc, int nkeys, int *attnos, Datum *srckeys, Datum *dstkeys)
static HeapTuple SearchCatCacheInternal(CatCache *cache, int nkeys, Datum v1, Datum v2, Datum v3, Datum v4)
static char * ResOwnerPrintCatCacheList(Datum res)
static void ReleaseCatCacheListWithOwner(CatCList *list, ResourceOwner resowner)
static CatCacheHeader * CacheHdr
static uint32 namehashfast(Datum datum)
void CreateCacheMemoryContext(void)
static const ResourceOwnerDesc catlistref_resowner_desc
static bool IndexScanOK(CatCache *cache)
static void GetCCHashEqFuncs(Oid keytype, CCHashFN *hashfunc, RegProcedure *eqfunc, CCFastEqualFN *fasteqfunc)
static uint32 CatalogCacheComputeHashValue(CatCache *cache, int nkeys, Datum v1, Datum v2, Datum v3, Datum v4)
static bool CatalogCacheCompareTuple(const CatCache *cache, int nkeys, const Datum *cachekeys, const Datum *searchkeys)
void CatCacheInvalidate(CatCache *cache, uint32 hashValue)
static void ResourceOwnerForgetCatCacheRef(ResourceOwner owner, HeapTuple tuple)
static bool nameeqfast(Datum a, Datum b)
static uint32 charhashfast(Datum datum)
static void RehashCatCacheLists(CatCache *cp)
HeapTuple SearchCatCache1(CatCache *cache, Datum v1)
#define InitCatCache_DEBUG2
static uint32 oidvectorhashfast(Datum datum)
static void ResourceOwnerRememberCatCacheListRef(ResourceOwner owner, CatCList *list)
static bool texteqfast(Datum a, Datum b)
static bool oidvectoreqfast(Datum a, Datum b)
void CatalogCacheFlushCatalog(Oid catId)
static uint32 int2hashfast(Datum datum)
#define CatalogCacheInitializeCache_DEBUG2
static void CatCacheFreeKeys(TupleDesc tupdesc, int nkeys, int *attnos, Datum *keys)
static void CatCacheRemoveCList(CatCache *cache, CatCList *cl)
#define HASH_INDEX(h, sz)
static uint32 texthashfast(Datum datum)
void ReleaseCatCache(HeapTuple tuple)
HeapTuple SearchCatCache(CatCache *cache, Datum v1, Datum v2, Datum v3, Datum v4)
void ResetCatalogCachesExt(bool debug_discard)
uint32(* CCHashFN)(Datum datum)
bool(* CCFastEqualFN)(Datum a, Datum b)
Datum datumCopy(Datum value, bool typByVal, int typLen)
static void PGresult * res
Datum DirectFunctionCall2Coll(PGFunction func, Oid collation, Datum arg1, Datum arg2)
void fmgr_info_cxt(Oid functionId, FmgrInfo *finfo, MemoryContext mcxt)
Datum DirectFunctionCall1Coll(PGFunction func, Oid collation, Datum arg1)
#define DirectFunctionCall2(func, arg1, arg2)
#define DirectFunctionCall1(func, arg1)
void systable_endscan(SysScanDesc sysscan)
HeapTuple systable_getnext(SysScanDesc sysscan)
SysScanDesc systable_beginscan(Relation heapRelation, Oid indexId, bool indexOK, Snapshot snapshot, int nkeys, ScanKey key)
static uint32 murmurhash32(uint32 data)
static Datum hash_any(const unsigned char *k, int keylen)
Datum hashoidvector(PG_FUNCTION_ARGS)
Datum hashtext(PG_FUNCTION_ARGS)
HeapTuple toast_flatten_tuple(HeapTuple tup, TupleDesc tupleDesc)
void heap_freetuple(HeapTuple htup)
HeapTupleData * HeapTuple
HeapTupleHeaderData * HeapTupleHeader
#define HeapTupleIsValid(tuple)
static Datum heap_getattr(HeapTuple tup, int attnum, TupleDesc tupleDesc, bool *isnull)
static bool HeapTupleHasExternal(const HeapTupleData *tuple)
static Datum fastgetattr(HeapTuple tup, int attnum, TupleDesc tupleDesc, bool *isnull)
#define dlist_foreach(iter, lhead)
static void dlist_delete(dlist_node *node)
static void slist_init(slist_head *head)
static void dlist_push_head(dlist_head *head, dlist_node *node)
#define dlist_foreach_modify(iter, lhead)
static void slist_push_head(slist_head *head, slist_node *node)
#define slist_container(type, membername, ptr)
static void dlist_move_head(dlist_head *head, dlist_node *node)
#define slist_foreach(iter, lhead)
#define dlist_container(type, membername, ptr)
void index_close(Relation relation, LOCKMODE lockmode)
Relation index_open(Oid relationId, LOCKMODE lockmode)
#define INJECTION_POINT(name)
void CallSyscacheCallbacks(int cacheid, uint32 hashvalue)
void on_proc_exit(pg_on_exit_callback function, Datum arg)
bool ItemPointerEquals(ItemPointer pointer1, ItemPointer pointer2)
static OffsetNumber ItemPointerGetOffsetNumber(const ItemPointerData *pointer)
static BlockNumber ItemPointerGetBlockNumber(const ItemPointerData *pointer)
List * lappend(List *list, void *datum)
void UnlockRelationOid(Oid relid, LOCKMODE lockmode)
void LockRelationOid(Oid relid, LOCKMODE lockmode)
void * MemoryContextAllocZero(MemoryContext context, Size size)
char * pstrdup(const char *in)
void pfree(void *pointer)
void * palloc0(Size size)
MemoryContext TopMemoryContext
MemoryContext CacheMemoryContext
void * palloc_aligned(Size size, Size alignto, int flags)
#define AllocSetContextCreate
#define ALLOCSET_DEFAULT_SIZES
#define IsBootstrapProcessingMode()
void namestrcpy(Name name, const char *str)
Datum oidvectoreq(PG_FUNCTION_ARGS)
static MemoryContext MemoryContextSwitchTo(MemoryContext context)
FormData_pg_attribute * Form_pg_attribute
on_exit_nicely_callback function
static uint32 pg_rotate_left32(uint32 word, int n)
#define PG_CACHE_LINE_SIZE
static int list_length(const List *l)
uint32 pg_prng_uint32(pg_prng_state *state)
pg_prng_state pg_global_prng_state
static bool DatumGetBool(Datum X)
static Datum PointerGetDatum(const void *X)
static Name DatumGetName(Datum X)
static char * DatumGetCString(Datum X)
static Datum NameGetDatum(const NameData *X)
static Pointer DatumGetPointer(Datum X)
static char DatumGetChar(Datum X)
static int16 DatumGetInt16(Datum X)
static int32 DatumGetInt32(Datum X)
char * psprintf(const char *fmt,...)
#define RelationGetForm(relation)
#define RelationGetRelid(relation)
#define RelationGetDescr(relation)
#define RelationGetRelationName(relation)
#define RelationIsValid(relation)
bool criticalRelcachesBuilt
bool criticalSharedRelcachesBuilt
ResourceOwner CurrentResourceOwner
void ResourceOwnerForget(ResourceOwner owner, Datum value, const ResourceOwnerDesc *kind)
void ResourceOwnerRemember(ResourceOwner owner, Datum value, const ResourceOwnerDesc *kind)
void ResourceOwnerEnlarge(ResourceOwner owner)
#define RELEASE_PRIO_CATCACHE_LIST_REFS
@ RESOURCE_RELEASE_AFTER_LOCKS
#define RELEASE_PRIO_CATCACHE_REFS
#define BTEqualStrategyNumber
struct CatCInProgress * next
StrategyNumber sk_strategy
CCHashFN cc_hashfunc[CATCACHE_MAXKEYS]
int cc_keyno[CATCACHE_MAXKEYS]
CCFastEqualFN cc_fastequal[CATCACHE_MAXKEYS]
ScanKeyData cc_skey[CATCACHE_MAXKEYS]
Datum keys[CATCACHE_MAXKEYS]
CatCTup * members[FLEXIBLE_ARRAY_MEMBER]
Datum keys[CATCACHE_MAXKEYS]
void table_close(Relation relation, LOCKMODE lockmode)
Relation table_open(Oid relationId, LOCKMODE lockmode)
TupleDesc CreateTupleDescCopyConstr(TupleDesc tupdesc)
static FormData_pg_attribute * TupleDescAttr(TupleDesc tupdesc, int i)
struct TupleDescData * TupleDesc
Datum texteq(PG_FUNCTION_ARGS)
bool IsTransactionState(void)