diff options
Diffstat (limited to 'src/backend/utils/cache')
| -rw-r--r-- | src/backend/utils/cache/Makefile | 31 | ||||
| -rw-r--r-- | src/backend/utils/cache/catcache.c | 1768 | ||||
| -rw-r--r-- | src/backend/utils/cache/fcache.c | 53 | ||||
| -rw-r--r-- | src/backend/utils/cache/inval.c | 736 | ||||
| -rw-r--r-- | src/backend/utils/cache/lsyscache.c | 1389 | ||||
| -rw-r--r-- | src/backend/utils/cache/relcache.c | 3229 | ||||
| -rw-r--r-- | src/backend/utils/cache/syscache.c | 633 |
7 files changed, 0 insertions, 7839 deletions
diff --git a/src/backend/utils/cache/Makefile b/src/backend/utils/cache/Makefile deleted file mode 100644 index eb9d3e89c0c..00000000000 --- a/src/backend/utils/cache/Makefile +++ /dev/null @@ -1,31 +0,0 @@ -#------------------------------------------------------------------------- -# -# Makefile-- -# Makefile for utils/cache -# -# IDENTIFICATION -# $Header: /cvsroot/pgsql/src/backend/utils/cache/Makefile,v 1.16 2002/03/31 06:26:31 tgl Exp $ -# -#------------------------------------------------------------------------- - -subdir = src/backend/utils/cache -top_builddir = ../../../.. -include $(top_builddir)/src/Makefile.global - -OBJS = catcache.o inval.o relcache.o syscache.o lsyscache.o \ - fcache.o - -all: SUBSYS.o - -SUBSYS.o: $(OBJS) - $(LD) $(LDREL) $(LDOUT) SUBSYS.o $(OBJS) - -depend dep: - $(CC) -MM $(CFLAGS) *.c >depend - -clean: - rm -f SUBSYS.o $(OBJS) - -ifeq (depend,$(wildcard depend)) -include depend -endif diff --git a/src/backend/utils/cache/catcache.c b/src/backend/utils/cache/catcache.c deleted file mode 100644 index a4f05a7d117..00000000000 --- a/src/backend/utils/cache/catcache.c +++ /dev/null @@ -1,1768 +0,0 @@ -/*------------------------------------------------------------------------- - * - * catcache.c - * System catalog cache for tuples matching a key. - * - * Portions Copyright (c) 1996-2002, PostgreSQL Global Development Group - * Portions Copyright (c) 1994, Regents of the University of California - * - * - * IDENTIFICATION - * $Header: /cvsroot/pgsql/src/backend/utils/cache/catcache.c,v 1.96 2002/06/20 20:29:39 momjian Exp $ - * - *------------------------------------------------------------------------- - */ -#include "postgres.h" - -#include "access/genam.h" -#include "access/hash.h" -#include "access/heapam.h" -#include "access/valid.h" -#include "catalog/pg_opclass.h" -#include "catalog/pg_operator.h" -#include "catalog/pg_type.h" -#include "catalog/catname.h" -#include "catalog/indexing.h" -#include "miscadmin.h" -#ifdef CATCACHE_STATS -#include "storage/ipc.h" /* for on_proc_exit */ -#endif -#include "utils/builtins.h" -#include "utils/fmgroids.h" -#include "utils/catcache.h" -#include "utils/relcache.h" -#include "utils/syscache.h" - - -/* #define CACHEDEBUG */ /* turns DEBUG elogs on */ - -/* - * Constants related to size of the catcache. - * - * NCCBUCKETS must be a power of two and must be less than 64K (because - * SharedInvalCatcacheMsg crams hash indexes into a uint16 field). In - * practice it should be a lot less, anyway, to avoid chewing up too much - * space on hash bucket headers. - * - * MAXCCTUPLES could be as small as a few hundred, if per-backend memory - * consumption is at a premium. - */ -#define NCCBUCKETS 256 /* Hash buckets per CatCache */ -#define MAXCCTUPLES 5000 /* Maximum # of tuples in all caches */ - -/* - * Given a hash value and the size of the hash table, find the bucket - * in which the hash value belongs. Since the hash table must contain - * a power-of-2 number of elements, this is a simple bitmask. - */ -#define HASH_INDEX(h, sz) ((Index) ((h) & ((sz) - 1))) - - -/* - * variables, macros and other stuff - */ - -#ifdef CACHEDEBUG -#define CACHE1_elog(a,b) elog(a,b) -#define CACHE2_elog(a,b,c) elog(a,b,c) -#define CACHE3_elog(a,b,c,d) elog(a,b,c,d) -#define CACHE4_elog(a,b,c,d,e) elog(a,b,c,d,e) -#define CACHE5_elog(a,b,c,d,e,f) elog(a,b,c,d,e,f) -#define CACHE6_elog(a,b,c,d,e,f,g) elog(a,b,c,d,e,f,g) -#else -#define CACHE1_elog(a,b) -#define CACHE2_elog(a,b,c) -#define CACHE3_elog(a,b,c,d) -#define CACHE4_elog(a,b,c,d,e) -#define CACHE5_elog(a,b,c,d,e,f) -#define CACHE6_elog(a,b,c,d,e,f,g) -#endif - -/* Cache management header --- pointer is NULL until created */ -static CatCacheHeader *CacheHdr = NULL; - -/* - * EQPROC is used in CatalogCacheInitializeCache to find the equality - * functions for system types that are used as cache key fields. - * See also GetCCHashFunc, which should support the same set of types. - * - * XXX this should be replaced by catalog lookups, - * but that seems to pose considerable risk of circularity... - */ -static const Oid eqproc[] = { - F_BOOLEQ, InvalidOid, F_CHAREQ, F_NAMEEQ, InvalidOid, - F_INT2EQ, F_INT2VECTOREQ, F_INT4EQ, F_OIDEQ, F_TEXTEQ, - F_OIDEQ, InvalidOid, InvalidOid, InvalidOid, F_OIDVECTOREQ -}; - -#define EQPROC(SYSTEMTYPEOID) eqproc[(SYSTEMTYPEOID)-BOOLOID] - - -static uint32 CatalogCacheComputeHashValue(CatCache *cache, int nkeys, - ScanKey cur_skey); -static uint32 CatalogCacheComputeTupleHashValue(CatCache *cache, - HeapTuple tuple); -#ifdef CATCACHE_STATS -static void CatCachePrintStats(void); -#endif -static void CatCacheRemoveCTup(CatCache *cache, CatCTup *ct); -static void CatCacheRemoveCList(CatCache *cache, CatCList *cl); -static void CatalogCacheInitializeCache(CatCache *cache); -static CatCTup *CatalogCacheCreateEntry(CatCache *cache, HeapTuple ntp, - uint32 hashValue, Index hashIndex, - bool negative); -static HeapTuple build_dummy_tuple(CatCache *cache, int nkeys, ScanKey skeys); - - -/* - * internal support functions - */ - -static PGFunction -GetCCHashFunc(Oid keytype) -{ - switch (keytype) - { - case BOOLOID: - case CHAROID: - return hashchar; - case NAMEOID: - return hashname; - case INT2OID: - return hashint2; - case INT2VECTOROID: - return hashint2vector; - case INT4OID: - return hashint4; - case TEXTOID: - return hashvarlena; - case OIDOID: - case REGPROCOID: - case REGPROCEDUREOID: - case REGOPEROID: - case REGOPERATOROID: - case REGCLASSOID: - case REGTYPEOID: - return hashoid; - case OIDVECTOROID: - return hashoidvector; - default: - elog(FATAL, "GetCCHashFunc: type %u unsupported as catcache key", - keytype); - return (PGFunction) NULL; - } -} - -/* - * CatalogCacheComputeHashValue - * - * Compute the hash value associated with a given set of lookup keys - */ -static uint32 -CatalogCacheComputeHashValue(CatCache *cache, int nkeys, ScanKey cur_skey) -{ - uint32 hashValue = 0; - - CACHE4_elog(DEBUG1, "CatalogCacheComputeHashValue %s %d %p", - cache->cc_relname, - nkeys, - cache); - - switch (nkeys) - { - case 4: - hashValue ^= - DatumGetUInt32(DirectFunctionCall1(cache->cc_hashfunc[3], - cur_skey[3].sk_argument)) << 9; - /* FALLTHROUGH */ - case 3: - hashValue ^= - DatumGetUInt32(DirectFunctionCall1(cache->cc_hashfunc[2], - cur_skey[2].sk_argument)) << 6; - /* FALLTHROUGH */ - case 2: - hashValue ^= - DatumGetUInt32(DirectFunctionCall1(cache->cc_hashfunc[1], - cur_skey[1].sk_argument)) << 3; - /* FALLTHROUGH */ - case 1: - hashValue ^= - DatumGetUInt32(DirectFunctionCall1(cache->cc_hashfunc[0], - cur_skey[0].sk_argument)); - break; - default: - elog(FATAL, "CCComputeHashValue: %d nkeys", nkeys); - break; - } - - return hashValue; -} - -/* - * CatalogCacheComputeTupleHashValue - * - * Compute the hash value associated with a given tuple to be cached - */ -static uint32 -CatalogCacheComputeTupleHashValue(CatCache *cache, HeapTuple tuple) -{ - ScanKeyData cur_skey[4]; - bool isNull = false; - - /* Copy pre-initialized overhead data for scankey */ - memcpy(cur_skey, cache->cc_skey, sizeof(cur_skey)); - - /* Now extract key fields from tuple, insert into scankey */ - switch (cache->cc_nkeys) - { - case 4: - cur_skey[3].sk_argument = - (cache->cc_key[3] == ObjectIdAttributeNumber) - ? ObjectIdGetDatum(tuple->t_data->t_oid) - : fastgetattr(tuple, - cache->cc_key[3], - cache->cc_tupdesc, - &isNull); - Assert(!isNull); - /* FALLTHROUGH */ - case 3: - cur_skey[2].sk_argument = - (cache->cc_key[2] == ObjectIdAttributeNumber) - ? ObjectIdGetDatum(tuple->t_data->t_oid) - : fastgetattr(tuple, - cache->cc_key[2], - cache->cc_tupdesc, - &isNull); - Assert(!isNull); - /* FALLTHROUGH */ - case 2: - cur_skey[1].sk_argument = - (cache->cc_key[1] == ObjectIdAttributeNumber) - ? ObjectIdGetDatum(tuple->t_data->t_oid) - : fastgetattr(tuple, - cache->cc_key[1], - cache->cc_tupdesc, - &isNull); - Assert(!isNull); - /* FALLTHROUGH */ - case 1: - cur_skey[0].sk_argument = - (cache->cc_key[0] == ObjectIdAttributeNumber) - ? ObjectIdGetDatum(tuple->t_data->t_oid) - : fastgetattr(tuple, - cache->cc_key[0], - cache->cc_tupdesc, - &isNull); - Assert(!isNull); - break; - default: - elog(FATAL, "CCComputeTupleHashValue: %d cc_nkeys", - cache->cc_nkeys); - break; - } - - return CatalogCacheComputeHashValue(cache, cache->cc_nkeys, cur_skey); -} - - -#ifdef CATCACHE_STATS - -static void -CatCachePrintStats(void) -{ - CatCache *cache; - long cc_searches = 0; - long cc_hits = 0; - long cc_neg_hits = 0; - long cc_newloads = 0; - long cc_invals = 0; - long cc_discards = 0; - long cc_lsearches = 0; - long cc_lhits = 0; - - elog(DEBUG1, "Catcache stats dump: %d/%d tuples in catcaches", - CacheHdr->ch_ntup, CacheHdr->ch_maxtup); - - for (cache = CacheHdr->ch_caches; cache; cache = cache->cc_next) - { - if (cache->cc_ntup == 0 && cache->cc_searches == 0) - continue; /* don't print unused caches */ - elog(DEBUG1, "Catcache %s/%s: %d tup, %ld srch, %ld+%ld=%ld hits, %ld+%ld=%ld loads, %ld invals, %ld discards, %ld lsrch, %ld lhits", - cache->cc_relname, - cache->cc_indname, - cache->cc_ntup, - cache->cc_searches, - cache->cc_hits, - cache->cc_neg_hits, - cache->cc_hits + cache->cc_neg_hits, - cache->cc_newloads, - cache->cc_searches - cache->cc_hits - cache->cc_neg_hits - cache->cc_newloads, - cache->cc_searches - cache->cc_hits - cache->cc_neg_hits, - cache->cc_invals, - cache->cc_discards, - cache->cc_lsearches, - cache->cc_lhits); - cc_searches += cache->cc_searches; - cc_hits += cache->cc_hits; - cc_neg_hits += cache->cc_neg_hits; - cc_newloads += cache->cc_newloads; - cc_invals += cache->cc_invals; - cc_discards += cache->cc_discards; - cc_lsearches += cache->cc_lsearches; - cc_lhits += cache->cc_lhits; - } - elog(DEBUG1, "Catcache totals: %d tup, %ld srch, %ld+%ld=%ld hits, %ld+%ld=%ld loads, %ld invals, %ld discards, %ld lsrch, %ld lhits", - CacheHdr->ch_ntup, - cc_searches, - cc_hits, - cc_neg_hits, - cc_hits + cc_neg_hits, - cc_newloads, - cc_searches - cc_hits - cc_neg_hits - cc_newloads, - cc_searches - cc_hits - cc_neg_hits, - cc_invals, - cc_discards, - cc_lsearches, - cc_lhits); -} - -#endif /* CATCACHE_STATS */ - - -/* - * CatCacheRemoveCTup - * - * Unlink and delete the given cache entry - * - * NB: if it is a member of a CatCList, the CatCList is deleted too. - */ -static void -CatCacheRemoveCTup(CatCache *cache, CatCTup *ct) -{ - Assert(ct->refcount == 0); - Assert(ct->my_cache == cache); - - if (ct->c_list) - CatCacheRemoveCList(cache, ct->c_list); - - /* delink from linked lists */ - DLRemove(&ct->lrulist_elem); - DLRemove(&ct->cache_elem); - - /* free associated tuple data */ - if (ct->tuple.t_data != NULL) - pfree(ct->tuple.t_data); - pfree(ct); - - --cache->cc_ntup; - --CacheHdr->ch_ntup; -} - -/* - * CatCacheRemoveCList - * - * Unlink and delete the given cache list entry - */ -static void -CatCacheRemoveCList(CatCache *cache, CatCList *cl) -{ - 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; - } - - /* delink from linked list */ - DLRemove(&cl->cache_elem); - - /* free associated tuple data */ - if (cl->tuple.t_data != NULL) - pfree(cl->tuple.t_data); - pfree(cl); -} - - -/* - * CatalogCacheIdInvalidate - * - * Invalidate entries in the specified cache, given a hash value and - * item pointer. Positive entries are deleted if they match the item - * pointer. Negative entries must be deleted if they match the hash - * value (since we do not have the exact key of the tuple that's being - * inserted). But this should only rarely result in loss of a cache - * entry that could have been kept. - * - * Note that it's not very relevant whether the tuple identified by - * the item pointer is being inserted or deleted. We don't expect to - * find matching positive entries in the one case, and we don't expect - * to find matching negative entries in the other; but we will do the - * right things in any case. - * - * This routine is only quasi-public: it should only be used by inval.c. - */ -void -CatalogCacheIdInvalidate(int cacheId, - uint32 hashValue, - ItemPointer pointer) -{ - CatCache *ccp; - - /* - * sanity checks - */ - Assert(ItemPointerIsValid(pointer)); - CACHE1_elog(DEBUG1, "CatalogCacheIdInvalidate: called"); - - /* - * inspect caches to find the proper cache - */ - for (ccp = CacheHdr->ch_caches; ccp; ccp = ccp->cc_next) - { - Index hashIndex; - Dlelem *elt, - *nextelt; - - if (cacheId != ccp->id) - continue; - - /* - * 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 (elt = DLGetHead(&ccp->cc_lists); elt; elt = nextelt) - { - CatCList *cl = (CatCList *) DLE_VAL(elt); - - nextelt = DLGetSucc(elt); - - if (cl->refcount > 0) - cl->dead = true; - else - CatCacheRemoveCList(ccp, cl); - } - - /* - * inspect the proper hash bucket for tuple matches - */ - hashIndex = HASH_INDEX(hashValue, ccp->cc_nbuckets); - - for (elt = DLGetHead(&ccp->cc_bucket[hashIndex]); elt; elt = nextelt) - { - CatCTup *ct = (CatCTup *) DLE_VAL(elt); - - nextelt = DLGetSucc(elt); - - if (hashValue != ct->hash_value) - continue; /* ignore non-matching hash values */ - - if (ct->negative || - ItemPointerEquals(pointer, &ct->tuple.t_self)) - { - if (ct->refcount > 0) - ct->dead = true; - else - CatCacheRemoveCTup(ccp, ct); - CACHE1_elog(DEBUG1, "CatalogCacheIdInvalidate: invalidated"); -#ifdef CATCACHE_STATS - ccp->cc_invals++; -#endif - /* could be multiple matches, so keep looking! */ - } - } - break; /* need only search this one cache */ - } -} - -/* ---------------------------------------------------------------- - * public functions - * ---------------------------------------------------------------- - */ - - -/* - * Standard routine for creating cache context if it doesn't exist yet - * - * There are a lot of places (probably far more than necessary) that check - * whether CacheMemoryContext exists yet and want to create it if not. - * We centralize knowledge of exactly how to create it here. - */ -void -CreateCacheMemoryContext(void) -{ - /* - * Purely for paranoia, check that context doesn't exist; caller - * probably did so already. - */ - if (!CacheMemoryContext) - CacheMemoryContext = AllocSetContextCreate(TopMemoryContext, - "CacheMemoryContext", - ALLOCSET_DEFAULT_MINSIZE, - ALLOCSET_DEFAULT_INITSIZE, - ALLOCSET_DEFAULT_MAXSIZE); -} - - -/* - * AtEOXact_CatCache - * - * Clean up catcaches at end of transaction (either commit or abort) - * - * We scan the caches to reset refcounts to zero. This is of course - * necessary in the abort case, since elog() may have interrupted routines. - * In the commit case, any nonzero counts indicate failure to call - * ReleaseSysCache, so we put out a notice for debugging purposes. - */ -void -AtEOXact_CatCache(bool isCommit) -{ - CatCache *ccp; - Dlelem *elt, - *nextelt; - - /* - * First clean up CatCLists - */ - for (ccp = CacheHdr->ch_caches; ccp; ccp = ccp->cc_next) - { - for (elt = DLGetHead(&ccp->cc_lists); elt; elt = nextelt) - { - CatCList *cl = (CatCList *) DLE_VAL(elt); - - nextelt = DLGetSucc(elt); - - if (cl->refcount != 0) - { - if (isCommit) - elog(WARNING, "Cache reference leak: cache %s (%d), list %p has count %d", - ccp->cc_relname, ccp->id, cl, cl->refcount); - cl->refcount = 0; - } - - /* Clean up any now-deletable dead entries */ - if (cl->dead) - CatCacheRemoveCList(ccp, cl); - } - } - - /* - * Now clean up tuples; we can scan them all using the global LRU list - */ - for (elt = DLGetHead(&CacheHdr->ch_lrulist); elt; elt = nextelt) - { - CatCTup *ct = (CatCTup *) DLE_VAL(elt); - - nextelt = DLGetSucc(elt); - - if (ct->refcount != 0) - { - if (isCommit) - elog(WARNING, "Cache reference leak: cache %s (%d), tuple %u has count %d", - ct->my_cache->cc_relname, ct->my_cache->id, - ct->tuple.t_data->t_oid, - ct->refcount); - ct->refcount = 0; - } - - /* Clean up any now-deletable dead entries */ - if (ct->dead) - CatCacheRemoveCTup(ct->my_cache, ct); - } -} - -/* - * ResetCatalogCache - * - * Reset one catalog cache to empty. - * - * This is not very efficient if the target cache is nearly empty. - * However, it shouldn't need to be efficient; we don't invoke it often. - */ -static void -ResetCatalogCache(CatCache *cache) -{ - Dlelem *elt, - *nextelt; - int i; - - /* Remove each list in this cache, or at least mark it dead */ - for (elt = DLGetHead(&cache->cc_lists); elt; elt = nextelt) - { - CatCList *cl = (CatCList *) DLE_VAL(elt); - - nextelt = DLGetSucc(elt); - - 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++) - { - for (elt = DLGetHead(&cache->cc_bucket[i]); elt; elt = nextelt) - { - CatCTup *ct = (CatCTup *) DLE_VAL(elt); - - nextelt = DLGetSucc(elt); - - if (ct->refcount > 0) - ct->dead = true; - else - CatCacheRemoveCTup(cache, ct); -#ifdef CATCACHE_STATS - cache->cc_invals++; -#endif - } - } -} - -/* - * ResetCatalogCaches - * - * Reset all caches when a shared cache inval event forces it - */ -void -ResetCatalogCaches(void) -{ - CatCache *cache; - - CACHE1_elog(DEBUG1, "ResetCatalogCaches called"); - - for (cache = CacheHdr->ch_caches; cache; cache = cache->cc_next) - ResetCatalogCache(cache); - - CACHE1_elog(DEBUG1, "end of ResetCatalogCaches call"); -} - -/* - * CatalogCacheFlushRelation - * - * This is called by RelationFlushRelation() to clear out cached information - * about a relation being dropped. (This could be a DROP TABLE command, - * or a temp table being dropped at end of transaction, or a table created - * during the current transaction that is being dropped because of abort.) - * Remove all cache entries relevant to the specified relation OID. - * - * A special case occurs when relId is itself one of the cacheable system - * tables --- although those'll never be dropped, they can get flushed from - * the relcache (VACUUM causes this, for example). In that case we need - * to flush all cache entries that came from that table. (At one point we - * also tried to force re-execution of CatalogCacheInitializeCache for - * the cache(s) on that table. This is a bad idea since it leads to all - * kinds of trouble if a cache flush occurs while loading cache entries. - * We now avoid the need to do it by copying cc_tupdesc out of the relcache, - * rather than relying on the relcache to keep a tupdesc for us. Of course - * this assumes the tupdesc of a cachable system table will not change...) - */ -void -CatalogCacheFlushRelation(Oid relId) -{ - CatCache *cache; - - CACHE2_elog(DEBUG1, "CatalogCacheFlushRelation called for %u", relId); - - for (cache = CacheHdr->ch_caches; cache; cache = cache->cc_next) - { - int i; - - /* We can ignore uninitialized caches, since they must be empty */ - if (cache->cc_tupdesc == NULL) - continue; - - /* Does this cache store tuples of the target relation itself? */ - if (cache->cc_tupdesc->attrs[0]->attrelid == relId) - { - /* Yes, so flush all its contents */ - ResetCatalogCache(cache); - continue; - } - - /* Does this cache store tuples associated with relations at all? */ - if (cache->cc_reloidattr == 0) - continue; /* nope, leave it alone */ - - /* Yes, scan the tuples and remove those related to relId */ - for (i = 0; i < cache->cc_nbuckets; i++) - { - Dlelem *elt, - *nextelt; - - for (elt = DLGetHead(&cache->cc_bucket[i]); elt; elt = nextelt) - { - CatCTup *ct = (CatCTup *) DLE_VAL(elt); - Oid tupRelid; - - nextelt = DLGetSucc(elt); - - /* - * Negative entries are never considered related to a rel, - * even if the rel is part of their lookup key. - */ - if (ct->negative) - continue; - - if (cache->cc_reloidattr == ObjectIdAttributeNumber) - tupRelid = ct->tuple.t_data->t_oid; - else - { - bool isNull; - - tupRelid = - DatumGetObjectId(fastgetattr(&ct->tuple, - cache->cc_reloidattr, - cache->cc_tupdesc, - &isNull)); - Assert(!isNull); - } - - if (tupRelid == relId) - { - if (ct->refcount > 0) - ct->dead = true; - else - CatCacheRemoveCTup(cache, ct); -#ifdef CATCACHE_STATS - cache->cc_invals++; -#endif - } - } - } - } - - CACHE1_elog(DEBUG1, "end of CatalogCacheFlushRelation call"); -} - -/* - * InitCatCache - * - * This allocates and initializes a cache for a system catalog relation. - * Actually, the cache is only partially initialized to avoid opening the - * relation. The relation will be opened and the rest of the cache - * structure initialized on the first access. - */ -#ifdef CACHEDEBUG -#define InitCatCache_DEBUG1 \ -do { \ - elog(DEBUG1, "InitCatCache: rel=%s id=%d nkeys=%d size=%d\n", \ - cp->cc_relname, cp->id, cp->cc_nkeys, cp->cc_nbuckets); \ -} while(0) - -#else -#define InitCatCache_DEBUG1 -#endif - -CatCache * -InitCatCache(int id, - const char *relname, - const char *indname, - int reloidattr, - int nkeys, - const int *key) -{ - CatCache *cp; - MemoryContext oldcxt; - int i; - - /* - * 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, including - * global LRU list header - */ - if (CacheHdr == NULL) - { - CacheHdr = (CatCacheHeader *) palloc(sizeof(CatCacheHeader)); - CacheHdr->ch_caches = NULL; - CacheHdr->ch_ntup = 0; - CacheHdr->ch_maxtup = MAXCCTUPLES; - DLInitList(&CacheHdr->ch_lrulist); -#ifdef CATCACHE_STATS - on_proc_exit(CatCachePrintStats, 0); -#endif - } - - /* - * allocate a new cache structure - * - * Note: we assume zeroing initializes the Dllist headers correctly - */ - cp = (CatCache *) palloc(sizeof(CatCache) + NCCBUCKETS * sizeof(Dllist)); - MemSet((char *) cp, 0, sizeof(CatCache) + NCCBUCKETS * sizeof(Dllist)); - - /* - * 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 = relname; - cp->cc_indname = indname; - cp->cc_reloid = InvalidOid; /* temporary */ - cp->cc_relisshared = false; /* temporary */ - cp->cc_tupdesc = (TupleDesc) NULL; - cp->cc_reloidattr = reloidattr; - cp->cc_ntup = 0; - cp->cc_nbuckets = NCCBUCKETS; - cp->cc_nkeys = nkeys; - for (i = 0; i < nkeys; ++i) - cp->cc_key[i] = key[i]; - - /* - * new cache is initialized as far as we can go for now. print some - * debugging information, if appropriate. - */ - InitCatCache_DEBUG1; - - /* - * add completed cache to top of group header's list - */ - cp->cc_next = CacheHdr->ch_caches; - CacheHdr->ch_caches = cp; - - /* - * back to the old context before we return... - */ - MemoryContextSwitchTo(oldcxt); - - return cp; -} - -/* - * CatalogCacheInitializeCache - * - * This function does final initialization of a catcache: obtain the tuple - * descriptor and set up the hash and equality function links. We assume - * that the relcache entry can be opened at this point! - */ -#ifdef CACHEDEBUG -#define CatalogCacheInitializeCache_DEBUG1 \ - elog(DEBUG1, "CatalogCacheInitializeCache: cache @%p %s", cache, \ - cache->cc_relname) - -#define CatalogCacheInitializeCache_DEBUG2 \ -do { \ - if (cache->cc_key[i] > 0) { \ - elog(DEBUG1, "CatalogCacheInitializeCache: load %d/%d w/%d, %u", \ - i+1, cache->cc_nkeys, cache->cc_key[i], \ - tupdesc->attrs[cache->cc_key[i] - 1]->atttypid); \ - } else { \ - elog(DEBUG1, "CatalogCacheInitializeCache: load %d/%d w/%d", \ - i+1, cache->cc_nkeys, cache->cc_key[i]); \ - } \ -} while(0) - -#else -#define CatalogCacheInitializeCache_DEBUG1 -#define CatalogCacheInitializeCache_DEBUG2 -#endif - -static void -CatalogCacheInitializeCache(CatCache *cache) -{ - Relation relation; - MemoryContext oldcxt; - TupleDesc tupdesc; - int i; - - CatalogCacheInitializeCache_DEBUG1; - - /* - * Open the relation without locking --- we only need the tupdesc, - * which we assume will never change ... - */ - relation = heap_openr(cache->cc_relname, NoLock); - Assert(RelationIsValid(relation)); - - /* - * 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)); - - /* - * get the relation's OID and relisshared flag, too - */ - cache->cc_reloid = RelationGetRelid(relation); - cache->cc_relisshared = RelationGetForm(relation)->relisshared; - - /* - * return to the caller's memory context and close the rel - */ - MemoryContextSwitchTo(oldcxt); - - heap_close(relation, NoLock); - - CACHE3_elog(DEBUG1, "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; - - CatalogCacheInitializeCache_DEBUG2; - - if (cache->cc_key[i] > 0) - keytype = tupdesc->attrs[cache->cc_key[i] - 1]->atttypid; - else - { - if (cache->cc_key[i] != ObjectIdAttributeNumber) - elog(FATAL, "CatalogCacheInit: only sys attr supported is OID"); - keytype = OIDOID; - } - - cache->cc_hashfunc[i] = GetCCHashFunc(keytype); - - cache->cc_isname[i] = (keytype == NAMEOID); - - /* - * If GetCCHashFunc liked the type, safe to index into eqproc[] - */ - cache->cc_skey[i].sk_procedure = EQPROC(keytype); - - /* Do function lookup */ - fmgr_info_cxt(cache->cc_skey[i].sk_procedure, - &cache->cc_skey[i].sk_func, - CacheMemoryContext); - - /* Initialize sk_attno suitably for HeapKeyTest() and heap scans */ - cache->cc_skey[i].sk_attno = cache->cc_key[i]; - - CACHE4_elog(DEBUG1, "CatalogCacheInit %s %d %p", - cache->cc_relname, - i, - cache); - } - - /* - * mark this cache fully initialized - */ - cache->cc_tupdesc = tupdesc; -} - -/* - * InitCatCachePhase2 -- external interface for CatalogCacheInitializeCache - * - * The only reason to call this routine is to ensure that the relcache - * has created entries for all the catalogs and indexes referenced by - * catcaches. Therefore, open the index too. An exception is the indexes - * on pg_am, which we don't use (cf. IndexScanOK). - */ -void -InitCatCachePhase2(CatCache *cache) -{ - if (cache->cc_tupdesc == NULL) - CatalogCacheInitializeCache(cache); - - if (cache->id != AMOID && - cache->id != AMNAME) - { - Relation idesc; - - idesc = index_openr(cache->cc_indname); - index_close(idesc); - } -} - - -/* - * IndexScanOK - * - * This function checks for tuples that will be fetched by - * IndexSupportInitialize() during relcache initialization for - * certain system indexes that support critical syscaches. - * We can't use an indexscan to fetch these, else we'll get into - * infinite recursion. A plain heap scan will work, however. - * - * Once we have completed relcache initialization (signaled by - * criticalRelcachesBuilt), we don't have to worry anymore. - */ -static bool -IndexScanOK(CatCache *cache, ScanKey cur_skey) -{ - if (cache->id == INDEXRELID) - { - /* - * Since the OIDs of indexes aren't hardwired, it's painful to - * figure out which is which. Just force all pg_index searches - * to be heap scans while building the relcaches. - */ - if (!criticalRelcachesBuilt) - return false; - } - else if (cache->id == AMOID || - cache->id == 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; - } - else if (cache->id == OPEROID) - { - if (!criticalRelcachesBuilt) - { - /* Looking for an OID comparison function? */ - Oid lookup_oid = DatumGetObjectId(cur_skey[0].sk_argument); - - if (lookup_oid >= MIN_OIDCMP && lookup_oid <= MAX_OIDCMP) - return false; - } - } - - /* Normal case, allow index scan */ - return true; -} - -/* - * SearchCatCache - * - * This call searches a system cache for a tuple, opening the relation - * if necessary (on the first access to a particular cache). - * - * The result is NULL if not found, or a pointer to a HeapTuple in - * the cache. The caller must not modify the tuple, and must call - * ReleaseCatCache() when done with it. - * - * The search key values should be expressed as Datums of the key columns' - * datatype(s). (Pass zeroes for any unused parameters.) As a special - * exception, the passed-in key for a NAME column can be just a C string; - * the caller need not go to the trouble of converting it to a fully - * null-padded NAME. - */ -HeapTuple -SearchCatCache(CatCache *cache, - Datum v1, - Datum v2, - Datum v3, - Datum v4) -{ - ScanKeyData cur_skey[4]; - uint32 hashValue; - Index hashIndex; - Dlelem *elt; - CatCTup *ct; - Relation relation; - SysScanDesc scandesc; - HeapTuple ntp; - - /* - * one-time startup overhead for each cache - */ - if (cache->cc_tupdesc == NULL) - CatalogCacheInitializeCache(cache); - -#ifdef CATCACHE_STATS - cache->cc_searches++; -#endif - - /* - * initialize the search key information - */ - memcpy(cur_skey, cache->cc_skey, sizeof(cur_skey)); - cur_skey[0].sk_argument = v1; - cur_skey[1].sk_argument = v2; - cur_skey[2].sk_argument = v3; - cur_skey[3].sk_argument = v4; - - /* - * find the hash bucket in which to look for the tuple - */ - hashValue = CatalogCacheComputeHashValue(cache, cache->cc_nkeys, cur_skey); - hashIndex = HASH_INDEX(hashValue, cache->cc_nbuckets); - - /* - * scan the hash bucket until we find a match or exhaust our tuples - */ - for (elt = DLGetHead(&cache->cc_bucket[hashIndex]); - elt; - elt = DLGetSucc(elt)) - { - bool res; - - ct = (CatCTup *) DLE_VAL(elt); - - if (ct->dead) - continue; /* ignore dead entries */ - - if (ct->hash_value != hashValue) - continue; /* quickly skip entry if wrong hash val */ - - /* - * see if the cached tuple matches our key. - */ - HeapKeyTest(&ct->tuple, - cache->cc_tupdesc, - cache->cc_nkeys, - cur_skey, - res); - if (!res) - continue; - - /* - * we found a match in the cache: move it to the front of the global - * LRU list. We also 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.) - */ - DLMoveToFront(&ct->lrulist_elem); - DLMoveToFront(&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) - { - ct->refcount++; - - CACHE3_elog(DEBUG1, "SearchCatCache(%s): found in bucket %d", - cache->cc_relname, hashIndex); - -#ifdef CATCACHE_STATS - cache->cc_hits++; -#endif - - return &ct->tuple; - } - else - { - CACHE3_elog(DEBUG1, "SearchCatCache(%s): found neg entry in bucket %d", - cache->cc_relname, hashIndex); - -#ifdef CATCACHE_STATS - cache->cc_neg_hits++; -#endif - - return NULL; - } - } - - /* - * 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 heap_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. - */ - relation = heap_open(cache->cc_reloid, AccessShareLock); - - scandesc = systable_beginscan(relation, - cache->cc_indname, - IndexScanOK(cache, cur_skey), - SnapshotNow, - cache->cc_nkeys, - cur_skey); - - ct = NULL; - - while (HeapTupleIsValid(ntp = systable_getnext(scandesc))) - { - ct = CatalogCacheCreateEntry(cache, ntp, - hashValue, hashIndex, - false); - break; /* assume only one match */ - } - - systable_endscan(scandesc); - - heap_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. - */ - if (ct == NULL) - { - ntp = build_dummy_tuple(cache, cache->cc_nkeys, cur_skey); - ct = CatalogCacheCreateEntry(cache, ntp, - hashValue, hashIndex, - true); - heap_freetuple(ntp); - - CACHE4_elog(DEBUG1, "SearchCatCache(%s): Contains %d/%d tuples", - cache->cc_relname, cache->cc_ntup, CacheHdr->ch_ntup); - CACHE3_elog(DEBUG1, "SearchCatCache(%s): put neg entry in bucket %d", - cache->cc_relname, hashIndex); - - /* - * We are not returning the new entry to the caller, so reset its - * refcount. - */ - ct->refcount = 0; /* negative entries never have refs */ - - return NULL; - } - - CACHE4_elog(DEBUG1, "SearchCatCache(%s): Contains %d/%d tuples", - cache->cc_relname, cache->cc_ntup, CacheHdr->ch_ntup); - CACHE3_elog(DEBUG1, "SearchCatCache(%s): put in bucket %d", - cache->cc_relname, hashIndex); - -#ifdef CATCACHE_STATS - cache->cc_newloads++; -#endif - - return &ct->tuple; -} - -/* - * ReleaseCatCache - * - * Decrement the reference count of a catcache entry (releasing the - * hold grabbed by a successful SearchCatCache). - * - * NOTE: if compiled with -DCATCACHE_FORCE_RELEASE then catcache entries - * will be freed as soon as their refcount goes to zero. In combination - * with aset.c's CLOBBER_FREED_MEMORY option, this provides a good test - * to catch references to already-released catcache entries. - */ -void -ReleaseCatCache(HeapTuple tuple) -{ - 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 (ct->refcount == 0 -#ifndef CATCACHE_FORCE_RELEASE - && ct->dead -#endif - ) - CatCacheRemoveCTup(ct->my_cache, ct); -} - - -/* - * SearchCatCacheList - * - * Generate a list of all tuples matching a partial key (that is, - * a key specifying just the first K of the cache's N key columns). - * - * The caller must not modify the list object or the pointed-to tuples, - * and must call ReleaseCatCacheList() when done with the list. - */ -CatCList * -SearchCatCacheList(CatCache *cache, - int nkeys, - Datum v1, - Datum v2, - Datum v3, - Datum v4) -{ - ScanKeyData cur_skey[4]; - uint32 lHashValue; - Dlelem *elt; - CatCList *cl; - CatCTup *ct; - List *ctlist; - int nmembers; - Relation relation; - SysScanDesc scandesc; - bool ordered; - HeapTuple ntp; - MemoryContext oldcxt; - int i; - - /* - * one-time startup overhead for each cache - */ - if (cache->cc_tupdesc == NULL) - CatalogCacheInitializeCache(cache); - - Assert(nkeys > 0 && nkeys < cache->cc_nkeys); - -#ifdef CATCACHE_STATS - cache->cc_lsearches++; -#endif - - /* - * initialize the search key information - */ - memcpy(cur_skey, cache->cc_skey, sizeof(cur_skey)); - cur_skey[0].sk_argument = v1; - cur_skey[1].sk_argument = v2; - cur_skey[2].sk_argument = v3; - cur_skey[3].sk_argument = v4; - - /* - * compute a hash value of the given keys for faster search. We don't - * presently divide the CatCList items into buckets, but this still lets - * us skip non-matching items quickly most of the time. - */ - lHashValue = CatalogCacheComputeHashValue(cache, nkeys, cur_skey); - - /* - * scan the items until we find a match or exhaust our list - */ - for (elt = DLGetHead(&cache->cc_lists); - elt; - elt = DLGetSucc(elt)) - { - bool res; - - cl = (CatCList *) DLE_VAL(elt); - - 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; - HeapKeyTest(&cl->tuple, - cache->cc_tupdesc, - nkeys, - cur_skey, - res); - if (!res) - continue; - - /* - * we found a matching list: move each of its members to the front - * of the global LRU list. Also move the list itself to the front - * of the cache's list-of-lists, 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.) Also bump the members' refcounts. - */ - for (i = 0; i < cl->n_members; i++) - { - cl->members[i]->refcount++; - DLMoveToFront(&cl->members[i]->lrulist_elem); - } - DLMoveToFront(&cl->cache_elem); - - /* Bump the list's refcount and return it */ - cl->refcount++; - - CACHE2_elog(DEBUG1, "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. - */ - relation = heap_open(cache->cc_reloid, AccessShareLock); - - scandesc = systable_beginscan(relation, - cache->cc_indname, - true, - SnapshotNow, - nkeys, - cur_skey); - - /* The list will be ordered iff we are doing an index scan */ - ordered = (scandesc->irel != NULL); - - ctlist = NIL; - nmembers = 0; - - while (HeapTupleIsValid(ntp = systable_getnext(scandesc))) - { - uint32 hashValue; - Index hashIndex; - - /* - * See if there's an entry for this tuple already. - */ - ct = NULL; - hashValue = CatalogCacheComputeTupleHashValue(cache, ntp); - hashIndex = HASH_INDEX(hashValue, cache->cc_nbuckets); - - for (elt = DLGetHead(&cache->cc_bucket[hashIndex]); - elt; - elt = DLGetSucc(elt)) - { - ct = (CatCTup *) DLE_VAL(elt); - - 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 a match, so bump its refcount and move to front */ - ct->refcount++; - - DLMoveToFront(&ct->lrulist_elem); - - break; - } - - if (elt == NULL) - { - /* We didn't find a usable entry, so make a new one */ - ct = CatalogCacheCreateEntry(cache, ntp, - hashValue, hashIndex, - false); - } - - ctlist = lcons(ct, ctlist); - nmembers++; - } - - systable_endscan(scandesc); - - heap_close(relation, AccessShareLock); - - /* - * Now we can build the CatCList entry. First we need a dummy tuple - * containing the key values... - */ - ntp = build_dummy_tuple(cache, nkeys, cur_skey); - oldcxt = MemoryContextSwitchTo(CacheMemoryContext); - cl = (CatCList *) palloc(sizeof(CatCList) + nmembers * sizeof(CatCTup *)); - heap_copytuple_with_tuple(ntp, &cl->tuple); - MemoryContextSwitchTo(oldcxt); - heap_freetuple(ntp); - - cl->cl_magic = CL_MAGIC; - cl->my_cache = cache; - DLInitElem(&cl->cache_elem, (void *) cl); - cl->refcount = 1; /* count this first reference */ - cl->dead = false; - cl->ordered = ordered; - cl->nkeys = nkeys; - cl->hash_value = lHashValue; - cl->n_members = nmembers; - /* The list is backwards because we built it with lcons */ - for (i = nmembers; --i >= 0; ) - { - cl->members[i] = ct = (CatCTup *) lfirst(ctlist); - Assert(ct->c_list == NULL); - ct->c_list = cl; - /* mark list dead if any members already dead */ - if (ct->dead) - cl->dead = true; - ctlist = lnext(ctlist); - } - - DLAddHead(&cache->cc_lists, &cl->cache_elem); - - CACHE3_elog(DEBUG1, "SearchCatCacheList(%s): made list of %d members", - cache->cc_relname, nmembers); - - return cl; -} - -/* - * ReleaseCatCacheList - * - * Decrement the reference counts of a catcache list. - */ -void -ReleaseCatCacheList(CatCList *list) -{ - int i; - - /* Safety checks to ensure we were handed a cache entry */ - Assert(list->cl_magic == CL_MAGIC); - Assert(list->refcount > 0); - - for (i = list->n_members; --i >= 0; ) - { - CatCTup *ct = list->members[i]; - - Assert(ct->refcount > 0); - - ct->refcount--; - - if (ct->dead) - list->dead = true; - /* can't remove tuple before list is removed */ - } - - list->refcount--; - - if (list->refcount == 0 -#ifndef CATCACHE_FORCE_RELEASE - && list->dead -#endif - ) - CatCacheRemoveCList(list->my_cache, list); -} - - -/* - * CatalogCacheCreateEntry - * Create a new CatCTup entry, copying the given HeapTuple and other - * supplied data into it. The new entry is given refcount 1. - */ -static CatCTup * -CatalogCacheCreateEntry(CatCache *cache, HeapTuple ntp, - uint32 hashValue, Index hashIndex, bool negative) -{ - CatCTup *ct; - MemoryContext oldcxt; - - /* - * Allocate CatCTup header in cache memory, and copy the tuple there too. - */ - oldcxt = MemoryContextSwitchTo(CacheMemoryContext); - ct = (CatCTup *) palloc(sizeof(CatCTup)); - heap_copytuple_with_tuple(ntp, &ct->tuple); - MemoryContextSwitchTo(oldcxt); - - /* - * Finish initializing the CatCTup header, and add it to the cache's - * linked lists and counts. - */ - ct->ct_magic = CT_MAGIC; - ct->my_cache = cache; - DLInitElem(&ct->lrulist_elem, (void *) ct); - DLInitElem(&ct->cache_elem, (void *) ct); - ct->c_list = NULL; - ct->refcount = 1; /* count this first reference */ - ct->dead = false; - ct->negative = negative; - ct->hash_value = hashValue; - - DLAddHead(&CacheHdr->ch_lrulist, &ct->lrulist_elem); - DLAddHead(&cache->cc_bucket[hashIndex], &ct->cache_elem); - - cache->cc_ntup++; - CacheHdr->ch_ntup++; - - /* - * If we've exceeded the desired size of the caches, try to throw away - * the least recently used entry. NB: the newly-built entry cannot - * get thrown away here, because it has positive refcount. - */ - if (CacheHdr->ch_ntup > CacheHdr->ch_maxtup) - { - Dlelem *elt, - *prevelt; - - for (elt = DLGetTail(&CacheHdr->ch_lrulist); elt; elt = prevelt) - { - CatCTup *oldct = (CatCTup *) DLE_VAL(elt); - - prevelt = DLGetPred(elt); - - if (oldct->refcount == 0) - { - CACHE2_elog(DEBUG1, "CatCacheCreateEntry(%s): Overflow, LRU removal", - cache->cc_relname); -#ifdef CATCACHE_STATS - oldct->my_cache->cc_discards++; -#endif - CatCacheRemoveCTup(oldct->my_cache, oldct); - if (CacheHdr->ch_ntup <= CacheHdr->ch_maxtup) - break; - } - } - } - - return ct; -} - -/* - * build_dummy_tuple - * Generate a palloc'd HeapTuple that contains the specified key - * columns, and NULLs for other columns. - * - * This is used to store the keys for negative cache entries and CatCList - * entries, which don't have real tuples associated with them. - */ -static HeapTuple -build_dummy_tuple(CatCache *cache, int nkeys, ScanKey skeys) -{ - HeapTuple ntp; - TupleDesc tupDesc = cache->cc_tupdesc; - Datum *values; - char *nulls; - Oid tupOid = InvalidOid; - NameData tempNames[4]; - int i; - - values = (Datum *) palloc(tupDesc->natts * sizeof(Datum)); - nulls = (char *) palloc(tupDesc->natts * sizeof(char)); - - memset(values, 0, tupDesc->natts * sizeof(Datum)); - memset(nulls, 'n', tupDesc->natts * sizeof(char)); - - for (i = 0; i < nkeys; i++) - { - int attindex = cache->cc_key[i]; - Datum keyval = skeys[i].sk_argument; - - if (attindex > 0) - { - /* - * Here we 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 in heap_formtuple could fall off the - * end of memory. - */ - if (cache->cc_isname[i]) - { - Name newval = &tempNames[i]; - - namestrcpy(newval, DatumGetCString(keyval)); - keyval = NameGetDatum(newval); - } - values[attindex-1] = keyval; - nulls[attindex-1] = ' '; - } - else - { - Assert(attindex == ObjectIdAttributeNumber); - tupOid = DatumGetObjectId(keyval); - } - } - - ntp = heap_formtuple(tupDesc, values, nulls); - ntp->t_data->t_oid = tupOid; - - pfree(values); - pfree(nulls); - - return ntp; -} - - -/* - * PrepareToInvalidateCacheTuple() - * - * This is part of a rather subtle chain of events, so pay attention: - * - * When a tuple is inserted or deleted, it cannot be flushed from the - * catcaches immediately, for reasons explained at the top of cache/inval.c. - * Instead we have to add entry(s) for the tuple to a list of pending tuple - * invalidations that will be done at the end of the command or transaction. - * - * The lists of tuples that need to be flushed are kept by inval.c. This - * routine is a helper routine for inval.c. Given a tuple belonging to - * the specified relation, find all catcaches it could be in, compute the - * correct hash value for each such catcache, and call the specified function - * to record the cache id, hash value, and tuple ItemPointer in inval.c's - * lists. CatalogCacheIdInvalidate will be called later, if appropriate, - * using the recorded information. - * - * Note that it is irrelevant whether the given tuple is actually loaded - * into the catcache at the moment. Even if it's not there now, it might - * be by the end of the command, or there might be a matching negative entry - * to flush --- or other backends' caches might have such entries --- so - * we have to make list entries to flush it later. - * - * Also note that it's not an error if there are no catcaches for the - * specified relation. inval.c doesn't know exactly which rels have - * catcaches --- it will call this routine for any tuple that's in a - * system relation. - */ -void -PrepareToInvalidateCacheTuple(Relation relation, - HeapTuple tuple, - void (*function) (int, uint32, ItemPointer, Oid)) -{ - CatCache *ccp; - Oid reloid; - - CACHE1_elog(DEBUG1, "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 in this cache, - * and call the passed function to register the information. - * ---------------- - */ - - for (ccp = CacheHdr->ch_caches; ccp; ccp = ccp->cc_next) - { - /* Just in case cache hasn't finished initialization yet... */ - if (ccp->cc_tupdesc == NULL) - CatalogCacheInitializeCache(ccp); - - if (ccp->cc_reloid != reloid) - continue; - - (*function) (ccp->id, - CatalogCacheComputeTupleHashValue(ccp, tuple), - &tuple->t_self, - ccp->cc_relisshared ? (Oid) 0 : MyDatabaseId); - } -} diff --git a/src/backend/utils/cache/fcache.c b/src/backend/utils/cache/fcache.c deleted file mode 100644 index 0ad615fc803..00000000000 --- a/src/backend/utils/cache/fcache.c +++ /dev/null @@ -1,53 +0,0 @@ -/*------------------------------------------------------------------------- - * - * fcache.c - * Code for the 'function cache' used in Oper and Func nodes. - * - * - * Portions Copyright (c) 1996-2002, PostgreSQL Global Development Group - * Portions Copyright (c) 1994, Regents of the University of California - * - * IDENTIFICATION - * $Header: /cvsroot/pgsql/src/backend/utils/cache/Attic/fcache.c,v 1.45 2002/06/20 20:29:39 momjian Exp $ - * - *------------------------------------------------------------------------- - */ -#include "postgres.h" - -#include "miscadmin.h" -#include "utils/acl.h" -#include "utils/fcache.h" -#include "utils/lsyscache.h" - - -/* - * Build a 'FunctionCache' struct given the PG_PROC oid. - */ -FunctionCachePtr -init_fcache(Oid foid, int nargs, MemoryContext fcacheCxt) -{ - FunctionCachePtr retval; - AclResult aclresult; - - /* Check permission to call function */ - aclresult = pg_proc_aclcheck(foid, GetUserId(), ACL_EXECUTE); - if (aclresult != ACLCHECK_OK) - aclcheck_error(aclresult, get_func_name(foid)); - - /* Safety check (should never fail, as parser should check sooner) */ - if (nargs > FUNC_MAX_ARGS) - elog(ERROR, "init_fcache: too many arguments"); - - /* Create fcache entry in the desired context */ - retval = (FunctionCachePtr) MemoryContextAlloc(fcacheCxt, - sizeof(FunctionCache)); - MemSet(retval, 0, sizeof(FunctionCache)); - - /* Set up the primary fmgr lookup information */ - fmgr_info_cxt(foid, &(retval->func), fcacheCxt); - - /* Initialize additional info */ - retval->setArgsValid = false; - - return retval; -} diff --git a/src/backend/utils/cache/inval.c b/src/backend/utils/cache/inval.c deleted file mode 100644 index 02a6d8f8ddc..00000000000 --- a/src/backend/utils/cache/inval.c +++ /dev/null @@ -1,736 +0,0 @@ -/*------------------------------------------------------------------------- - * - * inval.c - * POSTGRES cache invalidation dispatcher code. - * - * This is subtle stuff, so pay attention: - * - * When a tuple is updated or deleted, our standard time qualification rules - * consider that it is *still valid* so long as we are in the same command, - * ie, until the next CommandCounterIncrement() or transaction commit. - * (See utils/time/tqual.c, and note that system catalogs are generally - * scanned under SnapshotNow rules by the system, or plain user snapshots - * for user queries.) At the command boundary, the old tuple stops - * being valid and the new version, if any, becomes valid. Therefore, - * we cannot simply flush a tuple from the system caches during heap_update() - * or heap_delete(). The tuple is still good at that point; what's more, - * even if we did flush it, it might be reloaded into the caches by a later - * request in the same command. So the correct behavior is to keep a list - * of outdated (updated/deleted) tuples and then do the required cache - * flushes at the next command boundary. We must also keep track of - * inserted tuples so that we can flush "negative" cache entries that match - * the new tuples; again, that mustn't happen until end of command. - * - * Once we have finished the command, we still need to remember inserted - * tuples (including new versions of updated tuples), so that we can flush - * them from the caches if we abort the transaction. Similarly, we'd better - * be able to flush "negative" cache entries that may have been loaded in - * place of deleted tuples, so we still need the deleted ones too. - * - * If we successfully complete the transaction, we have to broadcast all - * these invalidation events to other backends (via the SI message queue) - * so that they can flush obsolete entries from their caches. Note we have - * to record the transaction commit before sending SI messages, otherwise - * the other backends won't see our updated tuples as good. - * - * In short, we need to remember until xact end every insert or delete - * of a tuple that might be in the system caches. Updates are treated as - * two events, delete + insert, for simplicity. (There are cases where - * it'd be possible to record just one event, but we don't currently try.) - * - * We do not need to register EVERY tuple operation in this way, just those - * on tuples in relations that have associated catcaches. We do, however, - * have to register every operation on every tuple that *could* be in a - * catcache, whether or not it currently is in our cache. Also, if the - * tuple is in a relation that has multiple catcaches, we need to register - * an invalidation message for each such catcache. catcache.c's - * PrepareToInvalidateCacheTuple() routine provides the knowledge of which - * catcaches may need invalidation for a given tuple. - * - * Also, whenever we see an operation on a pg_class or pg_attribute tuple, - * we register a relcache flush operation for the relation described by that - * tuple. - * - * We keep the relcache flush requests in lists separate from the catcache - * tuple flush requests. This allows us to issue all the pending catcache - * flushes before we issue relcache flushes, which saves us from loading - * a catcache tuple during relcache load only to flush it again right away. - * Also, we avoid queuing multiple relcache flush requests for the same - * relation, since a relcache flush is relatively expensive to do. - * (XXX is it worth testing likewise for duplicate catcache flush entries? - * Probably not.) - * - * If a relcache flush is issued for a system relation that we preload - * from the relcache init file, we must also delete the init file so that - * it will be rebuilt during the next backend restart. The actual work of - * manipulating the init file is in relcache.c, but we keep track of the - * need for it here. - * - * All the request lists are kept in TopTransactionContext memory, since - * they need not live beyond the end of the current transaction. - * - * - * Portions Copyright (c) 1996-2002, PostgreSQL Global Development Group - * Portions Copyright (c) 1994, Regents of the University of California - * - * IDENTIFICATION - * $Header: /cvsroot/pgsql/src/backend/utils/cache/inval.c,v 1.52 2002/06/20 20:29:39 momjian Exp $ - * - *------------------------------------------------------------------------- - */ -#include "postgres.h" - -#include "catalog/catalog.h" -#include "miscadmin.h" -#include "storage/sinval.h" -#include "utils/catcache.h" -#include "utils/inval.h" -#include "utils/memutils.h" -#include "utils/relcache.h" - - -/* - * To minimize palloc traffic, we keep pending requests in successively- - * larger chunks (a slightly more sophisticated version of an expansible - * array). All request types can be stored as SharedInvalidationMessage - * records. - */ -typedef struct InvalidationChunk -{ - struct InvalidationChunk *next; /* list link */ - int nitems; /* # items currently stored in chunk */ - int maxitems; /* size of allocated array in this chunk */ - SharedInvalidationMessage msgs[1]; /* VARIABLE LENGTH ARRAY */ -} InvalidationChunk; /* VARIABLE LENGTH STRUCTURE */ - -typedef struct InvalidationListHeader -{ - InvalidationChunk *cclist; /* list of chunks holding catcache msgs */ - InvalidationChunk *rclist; /* list of chunks holding relcache msgs */ -} InvalidationListHeader; - -/*---------------- - * Invalidation info is divided into two lists: - * 1) events so far in current command, not yet reflected to caches. - * 2) events in previous commands of current transaction; these have - * been reflected to local caches, and must be either broadcast to - * other backends or rolled back from local cache when we commit - * or abort the transaction. - * - * The relcache-file-invalidated flag can just be a simple boolean, - * since we only act on it at transaction commit; we don't care which - * command of the transaction set it. - *---------------- - */ - -/* head of current-command event list */ -static InvalidationListHeader CurrentCmdInvalidMsgs; - -/* head of previous-commands event list */ -static InvalidationListHeader PriorCmdInvalidMsgs; - -static bool RelcacheInitFileInval; /* init file must be invalidated? */ - -/* - * Dynamically-registered callback functions. Current implementation - * assumes there won't be very many of these at once; could improve if needed. - */ - -#define MAX_CACHE_CALLBACKS 20 - -static struct CACHECALLBACK -{ - int16 id; /* cache number or SHAREDINVALRELCACHE_ID */ - CacheCallbackFunction function; - Datum arg; -} cache_callback_list[MAX_CACHE_CALLBACKS]; - -static int cache_callback_count = 0; - - -/* ---------------------------------------------------------------- - * Invalidation list support functions - * - * These three routines encapsulate processing of the "chunked" - * representation of what is logically just a list of messages. - * ---------------------------------------------------------------- - */ - -/* - * AddInvalidationMessage - * Add an invalidation message to a list (of chunks). - * - * Note that we do not pay any great attention to maintaining the original - * ordering of the messages. - */ -static void -AddInvalidationMessage(InvalidationChunk **listHdr, - SharedInvalidationMessage *msg) -{ - InvalidationChunk *chunk = *listHdr; - - if (chunk == NULL) - { - /* First time through; create initial chunk */ -#define FIRSTCHUNKSIZE 16 - chunk = (InvalidationChunk *) - MemoryContextAlloc(TopTransactionContext, - sizeof(InvalidationChunk) + - (FIRSTCHUNKSIZE - 1) *sizeof(SharedInvalidationMessage)); - chunk->nitems = 0; - chunk->maxitems = FIRSTCHUNKSIZE; - chunk->next = *listHdr; - *listHdr = chunk; - } - else if (chunk->nitems >= chunk->maxitems) - { - /* Need another chunk; double size of last chunk */ - int chunksize = 2 * chunk->maxitems; - - chunk = (InvalidationChunk *) - MemoryContextAlloc(TopTransactionContext, - sizeof(InvalidationChunk) + - (chunksize - 1) *sizeof(SharedInvalidationMessage)); - chunk->nitems = 0; - chunk->maxitems = chunksize; - chunk->next = *listHdr; - *listHdr = chunk; - } - /* Okay, add message to current chunk */ - chunk->msgs[chunk->nitems] = *msg; - chunk->nitems++; -} - -/* - * Free a list of inval message chunks. - * - * NOTE: when we are about to commit or abort a transaction, it's - * not really necessary to pfree the lists explicitly, since they will - * go away anyway when TopTransactionContext is destroyed. - */ -static void -FreeInvalidationMessageList(InvalidationChunk **listHdr) -{ - InvalidationChunk *chunk = *listHdr; - - *listHdr = NULL; - - while (chunk != NULL) - { - InvalidationChunk *nextchunk = chunk->next; - - pfree(chunk); - chunk = nextchunk; - } -} - -/* - * Append one list of invalidation message chunks to another, resetting - * the source chunk-list pointer to NULL. - */ -static void -AppendInvalidationMessageList(InvalidationChunk **destHdr, - InvalidationChunk **srcHdr) -{ - InvalidationChunk *chunk = *srcHdr; - - if (chunk == NULL) - return; /* nothing to do */ - - while (chunk->next != NULL) - chunk = chunk->next; - - chunk->next = *destHdr; - - *destHdr = *srcHdr; - - *srcHdr = NULL; -} - -/* - * Process a list of invalidation messages. - * - * This is a macro that executes the given code fragment for each message in - * a message chunk list. The fragment should refer to the message as *msg. - */ -#define ProcessMessageList(listHdr, codeFragment) \ - do { \ - InvalidationChunk *_chunk; \ - for (_chunk = (listHdr); _chunk != NULL; _chunk = _chunk->next) \ - { \ - int _cindex; \ - for (_cindex = 0; _cindex < _chunk->nitems; _cindex++) \ - { \ - SharedInvalidationMessage *msg = &_chunk->msgs[_cindex]; \ - codeFragment; \ - } \ - } \ - } while (0) - - -/* ---------------------------------------------------------------- - * Invalidation set support functions - * - * These routines understand about the division of a logical invalidation - * list into separate physical lists for catcache and relcache entries. - * ---------------------------------------------------------------- - */ - -/* - * Add a catcache inval entry - */ -static void -AddCatcacheInvalidationMessage(InvalidationListHeader *hdr, - int id, uint32 hashValue, - ItemPointer tuplePtr, Oid dbId) -{ - SharedInvalidationMessage msg; - - msg.cc.id = (int16) id; - msg.cc.tuplePtr = *tuplePtr; - msg.cc.dbId = dbId; - msg.cc.hashValue = hashValue; - AddInvalidationMessage(&hdr->cclist, &msg); -} - -/* - * Add a relcache inval entry - */ -static void -AddRelcacheInvalidationMessage(InvalidationListHeader *hdr, - Oid dbId, Oid relId) -{ - SharedInvalidationMessage msg; - - /* Don't add a duplicate item */ - /* We assume comparing relId is sufficient, needn't check dbId */ - ProcessMessageList(hdr->rclist, - if (msg->rc.relId == relId) return); - - /* OK, add the item */ - msg.rc.id = SHAREDINVALRELCACHE_ID; - msg.rc.dbId = dbId; - msg.rc.relId = relId; - AddInvalidationMessage(&hdr->rclist, &msg); -} - -/* - * Append one list of invalidation messages to another, resetting - * the source list to empty. - */ -static void -AppendInvalidationMessages(InvalidationListHeader *dest, - InvalidationListHeader *src) -{ - AppendInvalidationMessageList(&dest->cclist, &src->cclist); - AppendInvalidationMessageList(&dest->rclist, &src->rclist); -} - -/* - * Reset an invalidation list to empty - * - * physicalFree may be set false if caller knows transaction is ending - */ -static void -DiscardInvalidationMessages(InvalidationListHeader *hdr, bool physicalFree) -{ - if (physicalFree) - { - /* Physically pfree the list data */ - FreeInvalidationMessageList(&hdr->cclist); - FreeInvalidationMessageList(&hdr->rclist); - } - else - { - /* - * Assume the storage will go away at xact end, just reset - * pointers - */ - hdr->cclist = NULL; - hdr->rclist = NULL; - } -} - -/* - * Execute the given function for all the messages in an invalidation list. - * The list is not altered. - * - * catcache entries are processed first, for reasons mentioned above. - */ -static void -ProcessInvalidationMessages(InvalidationListHeader *hdr, - void (*func) (SharedInvalidationMessage *msg)) -{ - ProcessMessageList(hdr->cclist, func(msg)); - ProcessMessageList(hdr->rclist, func(msg)); -} - -/* ---------------------------------------------------------------- - * private support functions - * ---------------------------------------------------------------- - */ - -/* - * RegisterCatcacheInvalidation - * - * Register an invalidation event for a catcache tuple entry. - */ -static void -RegisterCatcacheInvalidation(int cacheId, - uint32 hashValue, - ItemPointer tuplePtr, - Oid dbId) -{ - AddCatcacheInvalidationMessage(&CurrentCmdInvalidMsgs, - cacheId, hashValue, tuplePtr, dbId); -} - -/* - * RegisterRelcacheInvalidation - * - * As above, but register a relcache invalidation event. - */ -static void -RegisterRelcacheInvalidation(Oid dbId, Oid relId) -{ - AddRelcacheInvalidationMessage(&CurrentCmdInvalidMsgs, - dbId, relId); - /* - * If the relation being invalidated is one of those cached in the - * relcache init file, mark that we need to zap that file at commit. - */ - if (RelationIdIsInInitFile(relId)) - RelcacheInitFileInval = true; -} - -/* - * LocalExecuteInvalidationMessage - * - * Process a single invalidation message (which could be either type). - * Only the local caches are flushed; this does not transmit the message - * to other backends. - */ -static void -LocalExecuteInvalidationMessage(SharedInvalidationMessage *msg) -{ - int i; - - if (msg->id >= 0) - { - if (msg->cc.dbId == MyDatabaseId || msg->cc.dbId == 0) - { - CatalogCacheIdInvalidate(msg->cc.id, - msg->cc.hashValue, - &msg->cc.tuplePtr); - - for (i = 0; i < cache_callback_count; i++) - { - struct CACHECALLBACK *ccitem = cache_callback_list + i; - - if (ccitem->id == msg->cc.id) - (*ccitem->function) (ccitem->arg, InvalidOid); - } - } - } - else if (msg->id == SHAREDINVALRELCACHE_ID) - { - if (msg->rc.dbId == MyDatabaseId || msg->rc.dbId == 0) - { - RelationIdInvalidateRelationCacheByRelationId(msg->rc.relId); - - for (i = 0; i < cache_callback_count; i++) - { - struct CACHECALLBACK *ccitem = cache_callback_list + i; - - if (ccitem->id == SHAREDINVALRELCACHE_ID) - (*ccitem->function) (ccitem->arg, msg->rc.relId); - } - } - } - else - { - elog(FATAL, "ExecuteInvalidationMessage: bogus message id %d", - msg->id); - } -} - -/* - * InvalidateSystemCaches - * - * This blows away all tuples in the system catalog caches and - * all the cached relation descriptors (and closes their files too). - * Relation descriptors that have positive refcounts are then rebuilt. - * - * We call this when we see a shared-inval-queue overflow signal, - * since that tells us we've lost some shared-inval messages and hence - * don't know what needs to be invalidated. - */ -static void -InvalidateSystemCaches(void) -{ - int i; - - ResetCatalogCaches(); - RelationCacheInvalidate(); - - for (i = 0; i < cache_callback_count; i++) - { - struct CACHECALLBACK *ccitem = cache_callback_list + i; - - (*ccitem->function) (ccitem->arg, InvalidOid); - } -} - -/* - * PrepareForTupleInvalidation - * Detect whether invalidation of this tuple implies invalidation - * of catalog/relation cache entries; if so, register inval events. - */ -static void -PrepareForTupleInvalidation(Relation relation, HeapTuple tuple, - void (*CacheIdRegisterFunc) (int, uint32, - ItemPointer, Oid), - void (*RelationIdRegisterFunc) (Oid, Oid)) -{ - Oid tupleRelId; - Oid relationId; - - if (IsBootstrapProcessingMode()) - return; - - /* - * We only need to worry about invalidation for tuples that are in - * system relations; user-relation tuples are never in catcaches and - * can't affect the relcache either. - */ - if (!IsSystemRelation(relation)) - return; - /* - * TOAST tuples can likewise be ignored here. - * Note that TOAST tables are considered system relations - * so they are not filtered by the above test. - */ - if (IsToastRelation(relation)) - return; - - /* - * First let the catcache do its thing - */ - PrepareToInvalidateCacheTuple(relation, tuple, - CacheIdRegisterFunc); - - /* - * Now, is this tuple one of the primary definers of a relcache entry? - */ - tupleRelId = RelationGetRelid(relation); - - if (tupleRelId == RelOid_pg_class) - relationId = tuple->t_data->t_oid; - else if (tupleRelId == RelOid_pg_attribute) - relationId = ((Form_pg_attribute) GETSTRUCT(tuple))->attrelid; - else - return; - - /* - * Yes. We need to register a relcache invalidation event for the - * relation identified by relationId. - * - * KLUGE ALERT: we always send the relcache event with MyDatabaseId, even - * if the rel in question is shared. This essentially means that only - * backends in this same database will react to the relcache flush - * request. This is in fact appropriate, since only those backends - * could see our pg_class or pg_attribute change anyway. It looks a - * bit ugly though. - */ - (*RelationIdRegisterFunc) (MyDatabaseId, relationId); -} - - -/* ---------------------------------------------------------------- - * public functions - * ---------------------------------------------------------------- - */ - -/* - * AcceptInvalidationMessages - * Read and process invalidation messages from the shared invalidation - * message queue. - * - * Note: - * This should be called as the first step in processing a transaction. - */ -void -AcceptInvalidationMessages(void) -{ - ReceiveSharedInvalidMessages(LocalExecuteInvalidationMessage, - InvalidateSystemCaches); -} - -/* - * AtEOXactInvalidationMessages - * Process queued-up invalidation messages at end of transaction. - * - * If isCommit, we must send out the messages in our PriorCmdInvalidMsgs list - * to the shared invalidation message queue. Note that these will be read - * not only by other backends, but also by our own backend at the next - * transaction start (via AcceptInvalidationMessages). This means that - * we can skip immediate local processing of anything that's still in - * CurrentCmdInvalidMsgs, and just send that list out too. - * - * If not isCommit, we are aborting, and must locally process the messages - * in PriorCmdInvalidMsgs. No messages need be sent to other backends, - * since they'll not have seen our changed tuples anyway. We can forget - * about CurrentCmdInvalidMsgs too, since those changes haven't touched - * the caches yet. - * - * In any case, reset the various lists to empty. We need not physically - * free memory here, since TopTransactionContext is about to be emptied - * anyway. - * - * Note: - * This should be called as the last step in processing a transaction. - */ -void -AtEOXactInvalidationMessages(bool isCommit) -{ - if (isCommit) - { - /* - * Relcache init file invalidation requires processing both - * before and after we send the SI messages. However, we need - * not do anything unless we committed. - */ - if (RelcacheInitFileInval) - RelationCacheInitFileInvalidate(true); - - AppendInvalidationMessages(&PriorCmdInvalidMsgs, - &CurrentCmdInvalidMsgs); - - ProcessInvalidationMessages(&PriorCmdInvalidMsgs, - SendSharedInvalidMessage); - - if (RelcacheInitFileInval) - RelationCacheInitFileInvalidate(false); - } - else - { - ProcessInvalidationMessages(&PriorCmdInvalidMsgs, - LocalExecuteInvalidationMessage); - } - - RelcacheInitFileInval = false; - - DiscardInvalidationMessages(&PriorCmdInvalidMsgs, false); - DiscardInvalidationMessages(&CurrentCmdInvalidMsgs, false); -} - -/* - * CommandEndInvalidationMessages - * Process queued-up invalidation messages at end of one command - * in a transaction. - * - * Here, we send no messages to the shared queue, since we don't know yet if - * we will commit. We do need to locally process the CurrentCmdInvalidMsgs - * list, so as to flush our caches of any entries we have outdated in the - * current command. We then move the current-cmd list over to become part - * of the prior-cmds list. - * - * The isCommit = false case is not currently used, but may someday be - * needed to support rollback to a savepoint within a transaction. - * - * Note: - * This should be called during CommandCounterIncrement(), - * after we have advanced the command ID. - */ -void -CommandEndInvalidationMessages(bool isCommit) -{ - if (isCommit) - { - ProcessInvalidationMessages(&CurrentCmdInvalidMsgs, - LocalExecuteInvalidationMessage); - AppendInvalidationMessages(&PriorCmdInvalidMsgs, - &CurrentCmdInvalidMsgs); - } - else - { - /* XXX what needs to be done here? */ - } -} - -/* - * CacheInvalidateHeapTuple - * Register the given tuple for invalidation at end of command - * (ie, current command is outdating this tuple). - */ -void -CacheInvalidateHeapTuple(Relation relation, HeapTuple tuple) -{ - PrepareForTupleInvalidation(relation, tuple, - RegisterCatcacheInvalidation, - RegisterRelcacheInvalidation); -} - -/* - * CacheInvalidateRelcache - * Register invalidation of the specified relation's relcache entry - * at end of command. - * - * This is used in places that need to force relcache rebuild but aren't - * changing any of the tuples recognized as contributors to the relcache - * entry by PrepareForTupleInvalidation. (An example is dropping an index.) - */ -void -CacheInvalidateRelcache(Oid relationId) -{ - /* See KLUGE ALERT in PrepareForTupleInvalidation */ - RegisterRelcacheInvalidation(MyDatabaseId, relationId); -} - -/* - * CacheRegisterSyscacheCallback - * Register the specified function to be called for all future - * invalidation events in the specified cache. - * - * NOTE: currently, the OID argument to the callback routine is not - * provided for syscache callbacks; the routine doesn't really get any - * useful info as to exactly what changed. It should treat every call - * as a "cache flush" request. - */ -void -CacheRegisterSyscacheCallback(int cacheid, - CacheCallbackFunction func, - Datum arg) -{ - if (cache_callback_count >= MAX_CACHE_CALLBACKS) - elog(FATAL, "Out of cache_callback_list slots"); - - cache_callback_list[cache_callback_count].id = cacheid; - cache_callback_list[cache_callback_count].function = func; - cache_callback_list[cache_callback_count].arg = arg; - - ++cache_callback_count; -} - -/* - * CacheRegisterRelcacheCallback - * Register the specified function to be called for all future - * relcache invalidation events. The OID of the relation being - * invalidated will be passed to the function. - * - * NOTE: InvalidOid will be passed if a cache reset request is received. - * In this case the called routines should flush all cached state. - */ -void -CacheRegisterRelcacheCallback(CacheCallbackFunction func, - Datum arg) -{ - if (cache_callback_count >= MAX_CACHE_CALLBACKS) - elog(FATAL, "Out of cache_callback_list slots"); - - cache_callback_list[cache_callback_count].id = SHAREDINVALRELCACHE_ID; - cache_callback_list[cache_callback_count].function = func; - cache_callback_list[cache_callback_count].arg = arg; - - ++cache_callback_count; -} diff --git a/src/backend/utils/cache/lsyscache.c b/src/backend/utils/cache/lsyscache.c deleted file mode 100644 index 233910a85c3..00000000000 --- a/src/backend/utils/cache/lsyscache.c +++ /dev/null @@ -1,1389 +0,0 @@ -/*------------------------------------------------------------------------- - * - * lsyscache.c - * Convenience routines for common queries in the system catalog cache. - * - * Portions Copyright (c) 1996-2002, PostgreSQL Global Development Group - * Portions Copyright (c) 1994, Regents of the University of California - * - * IDENTIFICATION - * $Header: /cvsroot/pgsql/src/backend/utils/cache/lsyscache.c,v 1.74 2002/06/20 20:29:39 momjian Exp $ - * - * NOTES - * Eventually, the index information should go through here, too. - *------------------------------------------------------------------------- - */ -#include "postgres.h" - -#include "access/tupmacs.h" -#include "catalog/pg_amop.h" -#include "catalog/pg_namespace.h" -#include "catalog/pg_opclass.h" -#include "catalog/pg_operator.h" -#include "catalog/pg_proc.h" -#include "catalog/pg_shadow.h" -#include "catalog/pg_statistic.h" -#include "catalog/pg_type.h" -#include "nodes/makefuncs.h" -#include "utils/array.h" -#include "utils/builtins.h" -#include "utils/lsyscache.h" -#include "utils/syscache.h" - - -/* ---------- AMOP CACHES ---------- */ - -/* - * op_in_opclass - * - * Return t iff operator 'opno' is in operator class 'opclass'. - */ -bool -op_in_opclass(Oid opno, Oid opclass) -{ - return SearchSysCacheExists(AMOPOPID, - ObjectIdGetDatum(opclass), - ObjectIdGetDatum(opno), - 0, 0); -} - -/* - * op_requires_recheck - * - * Return t if operator 'opno' requires a recheck when used as a - * member of opclass 'opclass' (ie, this opclass is lossy for this - * operator). - * - * Caller should already have verified that opno is a member of opclass, - * therefore we raise an error if the tuple is not found. - */ -bool -op_requires_recheck(Oid opno, Oid opclass) -{ - HeapTuple tp; - Form_pg_amop amop_tup; - bool result; - - tp = SearchSysCache(AMOPOPID, - ObjectIdGetDatum(opclass), - ObjectIdGetDatum(opno), - 0, 0); - if (!HeapTupleIsValid(tp)) - elog(ERROR, "op_requires_recheck: op %u is not a member of opclass %u", - opno, opclass); - amop_tup = (Form_pg_amop) GETSTRUCT(tp); - - result = amop_tup->amopreqcheck; - ReleaseSysCache(tp); - return result; -} - -/* ---------- ATTRIBUTE CACHES ---------- */ - -/* - * get_attname - * - * Given the relation id and the attribute number, - * return the "attname" field from the attribute relation. - * - * Note: returns a palloc'd copy of the string, or NULL if no such operator. - */ -char * -get_attname(Oid relid, AttrNumber attnum) -{ - HeapTuple tp; - - tp = SearchSysCache(ATTNUM, - ObjectIdGetDatum(relid), - Int16GetDatum(attnum), - 0, 0); - if (HeapTupleIsValid(tp)) - { - Form_pg_attribute att_tup = (Form_pg_attribute) GETSTRUCT(tp); - char *result; - - result = pstrdup(NameStr(att_tup->attname)); - ReleaseSysCache(tp); - return result; - } - else - return NULL; -} - -/* - * get_attnum - * - * Given the relation id and the attribute name, - * return the "attnum" field from the attribute relation. - */ -AttrNumber -get_attnum(Oid relid, char *attname) -{ - HeapTuple tp; - - tp = SearchSysCache(ATTNAME, - ObjectIdGetDatum(relid), - PointerGetDatum(attname), - 0, 0); - if (HeapTupleIsValid(tp)) - { - Form_pg_attribute att_tup = (Form_pg_attribute) GETSTRUCT(tp); - AttrNumber result; - - result = att_tup->attnum; - ReleaseSysCache(tp); - return result; - } - else - return InvalidAttrNumber; -} - -/* - * get_atttype - * - * Given the relation OID and the attribute number with the relation, - * return the attribute type OID. - */ -Oid -get_atttype(Oid relid, AttrNumber attnum) -{ - HeapTuple tp; - - tp = SearchSysCache(ATTNUM, - ObjectIdGetDatum(relid), - Int16GetDatum(attnum), - 0, 0); - if (HeapTupleIsValid(tp)) - { - Form_pg_attribute att_tup = (Form_pg_attribute) GETSTRUCT(tp); - Oid result; - - result = att_tup->atttypid; - ReleaseSysCache(tp); - return result; - } - else - return InvalidOid; -} - -/* This routine uses the attname instead of the attnum because it - * replaces the routine find_atttype, which is called sometimes when - * only the attname, not the attno, is available. - */ -bool -get_attisset(Oid relid, char *attname) -{ - HeapTuple tp; - - tp = SearchSysCache(ATTNAME, - ObjectIdGetDatum(relid), - PointerGetDatum(attname), - 0, 0); - if (HeapTupleIsValid(tp)) - { - Form_pg_attribute att_tup = (Form_pg_attribute) GETSTRUCT(tp); - bool result; - - result = att_tup->attisset; - ReleaseSysCache(tp); - return result; - } - else - return false; -} - -/* - * get_atttypmod - * - * Given the relation id and the attribute number, - * return the "atttypmod" field from the attribute relation. - */ -int32 -get_atttypmod(Oid relid, AttrNumber attnum) -{ - HeapTuple tp; - - tp = SearchSysCache(ATTNUM, - ObjectIdGetDatum(relid), - Int16GetDatum(attnum), - 0, 0); - if (HeapTupleIsValid(tp)) - { - Form_pg_attribute att_tup = (Form_pg_attribute) GETSTRUCT(tp); - int32 result; - - result = att_tup->atttypmod; - ReleaseSysCache(tp); - return result; - } - else - return -1; -} - -/* - * get_atttypetypmod - * - * A two-fer: given the relation id and the attribute number, - * fetch both type OID and atttypmod in a single cache lookup. - * - * Unlike the otherwise-similar get_atttype/get_atttypmod, this routine - * raises an error if it can't obtain the information. - */ -void -get_atttypetypmod(Oid relid, AttrNumber attnum, - Oid *typid, int32 *typmod) -{ - HeapTuple tp; - Form_pg_attribute att_tup; - - tp = SearchSysCache(ATTNUM, - ObjectIdGetDatum(relid), - Int16GetDatum(attnum), - 0, 0); - if (!HeapTupleIsValid(tp)) - elog(ERROR, "cache lookup failed for relation %u attribute %d", - relid, attnum); - att_tup = (Form_pg_attribute) GETSTRUCT(tp); - - *typid = att_tup->atttypid; - *typmod = att_tup->atttypmod; - ReleaseSysCache(tp); -} - -/* ---------- INDEX CACHE ---------- */ - -/* watch this space... - */ - -/* ---------- OPCLASS CACHE ---------- */ - -/* - * opclass_is_btree - * - * Returns TRUE iff the specified opclass is associated with the - * btree index access method. - */ -bool -opclass_is_btree(Oid opclass) -{ - HeapTuple tp; - Form_pg_opclass cla_tup; - bool result; - - tp = SearchSysCache(CLAOID, - ObjectIdGetDatum(opclass), - 0, 0, 0); - if (!HeapTupleIsValid(tp)) - elog(ERROR, "cache lookup failed for opclass %u", opclass); - cla_tup = (Form_pg_opclass) GETSTRUCT(tp); - - result = (cla_tup->opcamid == BTREE_AM_OID); - ReleaseSysCache(tp); - return result; -} - -/* ---------- OPERATOR CACHE ---------- */ - -/* - * get_opcode - * - * Returns the regproc id of the routine used to implement an - * operator given the operator oid. - */ -RegProcedure -get_opcode(Oid opno) -{ - HeapTuple tp; - - tp = SearchSysCache(OPEROID, - ObjectIdGetDatum(opno), - 0, 0, 0); - if (HeapTupleIsValid(tp)) - { - Form_pg_operator optup = (Form_pg_operator) GETSTRUCT(tp); - RegProcedure result; - - result = optup->oprcode; - ReleaseSysCache(tp); - return result; - } - else - return (RegProcedure) InvalidOid; -} - -/* - * get_opname - * returns the name of the operator with the given opno - * - * Note: returns a palloc'd copy of the string, or NULL if no such operator. - */ -char * -get_opname(Oid opno) -{ - HeapTuple tp; - - tp = SearchSysCache(OPEROID, - ObjectIdGetDatum(opno), - 0, 0, 0); - if (HeapTupleIsValid(tp)) - { - Form_pg_operator optup = (Form_pg_operator) GETSTRUCT(tp); - char *result; - - result = pstrdup(NameStr(optup->oprname)); - ReleaseSysCache(tp); - return result; - } - else - return NULL; -} - -/* - * op_mergejoinable - * - * Returns the left and right sort operators and types corresponding to a - * mergejoinable operator, or nil if the operator is not mergejoinable. - */ -bool -op_mergejoinable(Oid opno, Oid ltype, Oid rtype, Oid *leftOp, Oid *rightOp) -{ - HeapTuple tp; - bool result = false; - - tp = SearchSysCache(OPEROID, - ObjectIdGetDatum(opno), - 0, 0, 0); - if (HeapTupleIsValid(tp)) - { - Form_pg_operator optup = (Form_pg_operator) GETSTRUCT(tp); - - if (optup->oprlsortop && - optup->oprrsortop && - optup->oprleft == ltype && - optup->oprright == rtype) - { - *leftOp = optup->oprlsortop; - *rightOp = optup->oprrsortop; - result = true; - } - ReleaseSysCache(tp); - } - return result; -} - -/* - * op_mergejoin_crossops - * - * Returns the cross-type comparison operators (ltype "<" rtype and - * ltype ">" rtype) for an operator previously determined to be - * mergejoinable. Optionally, fetches the regproc ids of these - * operators, as well as their operator OIDs. - */ -void -op_mergejoin_crossops(Oid opno, Oid *ltop, Oid *gtop, - RegProcedure *ltproc, RegProcedure *gtproc) -{ - HeapTuple tp; - Form_pg_operator optup; - - /* - * Get the declared comparison operators of the operator. - */ - tp = SearchSysCache(OPEROID, - ObjectIdGetDatum(opno), - 0, 0, 0); - if (!HeapTupleIsValid(tp)) /* shouldn't happen */ - elog(ERROR, "op_mergejoin_crossops: operator %u not found", opno); - optup = (Form_pg_operator) GETSTRUCT(tp); - *ltop = optup->oprltcmpop; - *gtop = optup->oprgtcmpop; - ReleaseSysCache(tp); - - /* Check < op provided */ - if (!OidIsValid(*ltop)) - elog(ERROR, "op_mergejoin_crossops: mergejoin operator %u has no matching < operator", - opno); - if (ltproc) - *ltproc = get_opcode(*ltop); - - /* Check > op provided */ - if (!OidIsValid(*gtop)) - elog(ERROR, "op_mergejoin_crossops: mergejoin operator %u has no matching > operator", - opno); - if (gtproc) - *gtproc = get_opcode(*gtop); -} - -/* - * op_hashjoinable - * - * Returns the hash operator corresponding to a hashjoinable operator, - * or InvalidOid if the operator is not hashjoinable. - */ -Oid -op_hashjoinable(Oid opno, Oid ltype, Oid rtype) -{ - HeapTuple tp; - Oid result = InvalidOid; - - tp = SearchSysCache(OPEROID, - ObjectIdGetDatum(opno), - 0, 0, 0); - if (HeapTupleIsValid(tp)) - { - Form_pg_operator optup = (Form_pg_operator) GETSTRUCT(tp); - - if (optup->oprcanhash && - optup->oprleft == ltype && - optup->oprright == rtype) - result = opno; - ReleaseSysCache(tp); - } - return result; -} - -/* - * op_volatile - * - * Get the provolatile flag for the operator's underlying function. - */ -char -op_volatile(Oid opno) -{ - RegProcedure funcid = get_opcode(opno); - - if (funcid == (RegProcedure) InvalidOid) - elog(ERROR, "Operator OID %u does not exist", opno); - - return func_volatile((Oid) funcid); -} - -/* - * get_commutator - * - * Returns the corresponding commutator of an operator. - */ -Oid -get_commutator(Oid opno) -{ - HeapTuple tp; - - tp = SearchSysCache(OPEROID, - ObjectIdGetDatum(opno), - 0, 0, 0); - if (HeapTupleIsValid(tp)) - { - Form_pg_operator optup = (Form_pg_operator) GETSTRUCT(tp); - Oid result; - - result = optup->oprcom; - ReleaseSysCache(tp); - return result; - } - else - return InvalidOid; -} - -/* - * get_negator - * - * Returns the corresponding negator of an operator. - */ -Oid -get_negator(Oid opno) -{ - HeapTuple tp; - - tp = SearchSysCache(OPEROID, - ObjectIdGetDatum(opno), - 0, 0, 0); - if (HeapTupleIsValid(tp)) - { - Form_pg_operator optup = (Form_pg_operator) GETSTRUCT(tp); - Oid result; - - result = optup->oprnegate; - ReleaseSysCache(tp); - return result; - } - else - return InvalidOid; -} - -/* - * get_oprrest - * - * Returns procedure id for computing selectivity of an operator. - */ -RegProcedure -get_oprrest(Oid opno) -{ - HeapTuple tp; - - tp = SearchSysCache(OPEROID, - ObjectIdGetDatum(opno), - 0, 0, 0); - if (HeapTupleIsValid(tp)) - { - Form_pg_operator optup = (Form_pg_operator) GETSTRUCT(tp); - RegProcedure result; - - result = optup->oprrest; - ReleaseSysCache(tp); - return result; - } - else - return (RegProcedure) InvalidOid; -} - -/* - * get_oprjoin - * - * Returns procedure id for computing selectivity of a join. - */ -RegProcedure -get_oprjoin(Oid opno) -{ - HeapTuple tp; - - tp = SearchSysCache(OPEROID, - ObjectIdGetDatum(opno), - 0, 0, 0); - if (HeapTupleIsValid(tp)) - { - Form_pg_operator optup = (Form_pg_operator) GETSTRUCT(tp); - RegProcedure result; - - result = optup->oprjoin; - ReleaseSysCache(tp); - return result; - } - else - return (RegProcedure) InvalidOid; -} - -/* ---------- FUNCTION CACHE ---------- */ - -/* - * get_func_name - * returns the name of the function with the given funcid - * - * Note: returns a palloc'd copy of the string, or NULL if no such function. - */ -char * -get_func_name(Oid funcid) -{ - HeapTuple tp; - - tp = SearchSysCache(PROCOID, - ObjectIdGetDatum(funcid), - 0, 0, 0); - if (HeapTupleIsValid(tp)) - { - Form_pg_proc functup = (Form_pg_proc) GETSTRUCT(tp); - char *result; - - result = pstrdup(NameStr(functup->proname)); - ReleaseSysCache(tp); - return result; - } - else - return NULL; -} - -/* - * get_func_rettype - * Given procedure id, return the function's result type. - */ -Oid -get_func_rettype(Oid funcid) -{ - HeapTuple tp; - Oid result; - - tp = SearchSysCache(PROCOID, - ObjectIdGetDatum(funcid), - 0, 0, 0); - if (!HeapTupleIsValid(tp)) - elog(ERROR, "Function OID %u does not exist", funcid); - - result = ((Form_pg_proc) GETSTRUCT(tp))->prorettype; - ReleaseSysCache(tp); - return result; -} - -/* - * get_func_retset - * Given procedure id, return the function's proretset flag. - */ -bool -get_func_retset(Oid funcid) -{ - HeapTuple tp; - bool result; - - tp = SearchSysCache(PROCOID, - ObjectIdGetDatum(funcid), - 0, 0, 0); - if (!HeapTupleIsValid(tp)) - elog(ERROR, "Function OID %u does not exist", funcid); - - result = ((Form_pg_proc) GETSTRUCT(tp))->proretset; - ReleaseSysCache(tp); - return result; -} - -/* - * func_volatile - * Given procedure id, return the function's provolatile flag. - */ -char -func_volatile(Oid funcid) -{ - HeapTuple tp; - char result; - - tp = SearchSysCache(PROCOID, - ObjectIdGetDatum(funcid), - 0, 0, 0); - if (!HeapTupleIsValid(tp)) - elog(ERROR, "Function OID %u does not exist", funcid); - - result = ((Form_pg_proc) GETSTRUCT(tp))->provolatile; - ReleaseSysCache(tp); - return result; -} - -/* ---------- RELATION CACHE ---------- */ - -/* - * get_relname_relid - * Given name and namespace of a relation, look up the OID. - * - * Returns InvalidOid if there is no such relation. - */ -Oid -get_relname_relid(const char *relname, Oid relnamespace) -{ - return GetSysCacheOid(RELNAMENSP, - PointerGetDatum(relname), - ObjectIdGetDatum(relnamespace), - 0, 0); -} - -#ifdef NOT_USED -/* - * get_relnatts - * - * Returns the number of attributes for a given relation. - */ -int -get_relnatts(Oid relid) -{ - HeapTuple tp; - - tp = SearchSysCache(RELOID, - ObjectIdGetDatum(relid), - 0, 0, 0); - if (HeapTupleIsValid(tp)) - { - Form_pg_class reltup = (Form_pg_class) GETSTRUCT(tp); - int result; - - result = reltup->relnatts; - ReleaseSysCache(tp); - return result; - } - else - return InvalidAttrNumber; -} -#endif - -/* - * get_rel_name - * Returns the name of a given relation. - * - * Returns a palloc'd copy of the string, or NULL if no such relation. - * - * NOTE: since relation name is not unique, be wary of code that uses this - * for anything except preparing error messages. - */ -char * -get_rel_name(Oid relid) -{ - HeapTuple tp; - - tp = SearchSysCache(RELOID, - ObjectIdGetDatum(relid), - 0, 0, 0); - if (HeapTupleIsValid(tp)) - { - Form_pg_class reltup = (Form_pg_class) GETSTRUCT(tp); - char *result; - - result = pstrdup(NameStr(reltup->relname)); - ReleaseSysCache(tp); - return result; - } - else - return NULL; -} - -/* - * get_rel_namespace - * - * Returns the pg_namespace OID associated with a given relation. - */ -Oid -get_rel_namespace(Oid relid) -{ - HeapTuple tp; - - tp = SearchSysCache(RELOID, - ObjectIdGetDatum(relid), - 0, 0, 0); - if (HeapTupleIsValid(tp)) - { - Form_pg_class reltup = (Form_pg_class) GETSTRUCT(tp); - Oid result; - - result = reltup->relnamespace; - ReleaseSysCache(tp); - return result; - } - else - return InvalidOid; -} - -/* - * get_rel_type_id - * - * Returns the pg_type OID associated with a given relation. - * - * Note: not all pg_class entries have associated pg_type OIDs; so be - * careful to check for InvalidOid result. - */ -Oid -get_rel_type_id(Oid relid) -{ - HeapTuple tp; - - tp = SearchSysCache(RELOID, - ObjectIdGetDatum(relid), - 0, 0, 0); - if (HeapTupleIsValid(tp)) - { - Form_pg_class reltup = (Form_pg_class) GETSTRUCT(tp); - Oid result; - - result = reltup->reltype; - ReleaseSysCache(tp); - return result; - } - else - return InvalidOid; -} - -/* ---------- TYPE CACHE ---------- */ - -/* - * get_typisdefined - * - * Given the type OID, determine whether the type is defined - * (if not, it's only a shell). - */ -bool -get_typisdefined(Oid typid) -{ - HeapTuple tp; - - tp = SearchSysCache(TYPEOID, - ObjectIdGetDatum(typid), - 0, 0, 0); - if (HeapTupleIsValid(tp)) - { - Form_pg_type typtup = (Form_pg_type) GETSTRUCT(tp); - bool result; - - result = typtup->typisdefined; - ReleaseSysCache(tp); - return result; - } - else - return false; -} - -/* - * get_typlen - * - * Given the type OID, return the length of the type. - */ -int16 -get_typlen(Oid typid) -{ - HeapTuple tp; - - tp = SearchSysCache(TYPEOID, - ObjectIdGetDatum(typid), - 0, 0, 0); - if (HeapTupleIsValid(tp)) - { - Form_pg_type typtup = (Form_pg_type) GETSTRUCT(tp); - int16 result; - - result = typtup->typlen; - ReleaseSysCache(tp); - return result; - } - else - return 0; -} - -/* - * get_typbyval - * - * Given the type OID, determine whether the type is returned by value or - * not. Returns true if by value, false if by reference. - */ -bool -get_typbyval(Oid typid) -{ - HeapTuple tp; - - tp = SearchSysCache(TYPEOID, - ObjectIdGetDatum(typid), - 0, 0, 0); - if (HeapTupleIsValid(tp)) - { - Form_pg_type typtup = (Form_pg_type) GETSTRUCT(tp); - bool result; - - result = typtup->typbyval; - ReleaseSysCache(tp); - return result; - } - else - return false; -} - -/* - * get_typlenbyval - * - * A two-fer: given the type OID, return both typlen and typbyval. - * - * Since both pieces of info are needed to know how to copy a Datum, - * many places need both. Might as well get them with one cache lookup - * instead of two. Also, this routine raises an error instead of - * returning a bogus value when given a bad type OID. - */ -void -get_typlenbyval(Oid typid, int16 *typlen, bool *typbyval) -{ - HeapTuple tp; - Form_pg_type typtup; - - tp = SearchSysCache(TYPEOID, - ObjectIdGetDatum(typid), - 0, 0, 0); - if (!HeapTupleIsValid(tp)) - elog(ERROR, "cache lookup failed for type %u", typid); - typtup = (Form_pg_type) GETSTRUCT(tp); - *typlen = typtup->typlen; - *typbyval = typtup->typbyval; - ReleaseSysCache(tp); -} - -#ifdef NOT_USED -char -get_typalign(Oid typid) -{ - HeapTuple tp; - - tp = SearchSysCache(TYPEOID, - ObjectIdGetDatum(typid), - 0, 0, 0); - if (HeapTupleIsValid(tp)) - { - Form_pg_type typtup = (Form_pg_type) GETSTRUCT(tp); - char result; - - result = typtup->typalign; - ReleaseSysCache(tp); - return result; - } - else - return 'i'; -} -#endif - -char -get_typstorage(Oid typid) -{ - HeapTuple tp; - - tp = SearchSysCache(TYPEOID, - ObjectIdGetDatum(typid), - 0, 0, 0); - if (HeapTupleIsValid(tp)) - { - Form_pg_type typtup = (Form_pg_type) GETSTRUCT(tp); - char result; - - result = typtup->typstorage; - ReleaseSysCache(tp); - return result; - } - else - return 'p'; -} - -/* - * get_typdefault - * Given a type OID, return the type's default value, if any. - * - * The result is a palloc'd expression node tree, or NULL if there - * is no defined default for the datatype. - * - * NB: caller should be prepared to coerce result to correct datatype; - * the returned expression tree might produce something of the wrong type. - */ -Node * -get_typdefault(Oid typid) -{ - HeapTuple typeTuple; - Form_pg_type type; - Datum datum; - bool isNull; - Node *expr; - - typeTuple = SearchSysCache(TYPEOID, - ObjectIdGetDatum(typid), - 0, 0, 0); - if (!HeapTupleIsValid(typeTuple)) - elog(ERROR, "get_typdefault: failed to lookup type %u", typid); - type = (Form_pg_type) GETSTRUCT(typeTuple); - - /* - * typdefault and typdefaultbin are potentially null, so don't try to - * access 'em as struct fields. Must do it the hard way with - * SysCacheGetAttr. - */ - datum = SysCacheGetAttr(TYPEOID, - typeTuple, - Anum_pg_type_typdefaultbin, - &isNull); - - if (!isNull) - { - /* We have an expression default */ - expr = stringToNode(DatumGetCString(DirectFunctionCall1(textout, - datum))); - } - else - { - /* Perhaps we have a plain literal default */ - datum = SysCacheGetAttr(TYPEOID, - typeTuple, - Anum_pg_type_typdefault, - &isNull); - - if (!isNull) - { - char *strDefaultVal; - - /* Convert text datum to C string */ - strDefaultVal = DatumGetCString(DirectFunctionCall1(textout, - datum)); - /* Convert C string to a value of the given type */ - datum = OidFunctionCall3(type->typinput, - CStringGetDatum(strDefaultVal), - ObjectIdGetDatum(type->typelem), - Int32GetDatum(-1)); - /* Build a Const node containing the value */ - expr = (Node *) makeConst(typid, - type->typlen, - datum, - false, - type->typbyval, - false, /* not a set */ - false); - pfree(strDefaultVal); - } - else - { - /* No default */ - expr = NULL; - } - } - - ReleaseSysCache(typeTuple); - - return expr; -} - -/* - * getBaseType - * If the given type is a domain, return its base type; - * otherwise return the type's own OID. - */ -Oid -getBaseType(Oid typid) -{ - /* - * We loop to find the bottom base type in a stack of domains. - */ - for (;;) - { - HeapTuple tup; - Form_pg_type typTup; - - tup = SearchSysCache(TYPEOID, - ObjectIdGetDatum(typid), - 0, 0, 0); - if (!HeapTupleIsValid(tup)) - elog(ERROR, "getBaseType: failed to lookup type %u", typid); - typTup = (Form_pg_type) GETSTRUCT(tup); - if (typTup->typtype != 'd') - { - /* Not a domain, so done */ - ReleaseSysCache(tup); - break; - } - - typid = typTup->typbasetype; - ReleaseSysCache(tup); - } - - return typid; -} - -/* - * get_typavgwidth - * - * Given a type OID and a typmod value (pass -1 if typmod is unknown), - * estimate the average width of values of the type. This is used by - * the planner, which doesn't require absolutely correct results; - * it's OK (and expected) to guess if we don't know for sure. - */ -int32 -get_typavgwidth(Oid typid, int32 typmod) -{ - int typlen = get_typlen(typid); - int32 maxwidth; - - /* - * Easy if it's a fixed-width type - */ - if (typlen > 0) - return typlen; - - /* - * type_maximum_size knows the encoding of typmod for some datatypes; - * don't duplicate that knowledge here. - */ - maxwidth = type_maximum_size(typid, typmod); - if (maxwidth > 0) - { - /* - * For BPCHAR, the max width is also the only width. Otherwise we - * need to guess about the typical data width given the max. A - * sliding scale for percentage of max width seems reasonable. - */ - if (typid == BPCHAROID) - return maxwidth; - if (maxwidth <= 32) - return maxwidth; /* assume full width */ - if (maxwidth < 1000) - return 32 + (maxwidth - 32) / 2; /* assume 50% */ - - /* - * Beyond 1000, assume we're looking at something like - * "varchar(10000)" where the limit isn't actually reached often, - * and use a fixed estimate. - */ - return 32 + (1000 - 32) / 2; - } - - /* - * Ooops, we have no idea ... wild guess time. - */ - return 32; -} - -/* - * get_typtype - * - * Given the type OID, find if it is a basic type, a named relation - * or the generic type 'relation'. - * It returns the null char if the cache lookup fails... - */ -#ifdef NOT_USED -char -get_typtype(Oid typid) -{ - HeapTuple tp; - - tp = SearchSysCache(TYPEOID, - ObjectIdGetDatum(typid), - 0, 0, 0); - if (HeapTupleIsValid(tp)) - { - Form_pg_type typtup = (Form_pg_type) GETSTRUCT(tp); - char result; - - result = typtup->typtype; - ReleaseSysCache(tp); - return result; - } - else - return '\0'; -} -#endif - -/* ---------- STATISTICS CACHE ---------- */ - -/* - * get_attavgwidth - * - * Given the table and attribute number of a column, get the average - * width of entries in the column. Return zero if no data available. - */ -int32 -get_attavgwidth(Oid relid, AttrNumber attnum) -{ - HeapTuple tp; - - tp = SearchSysCache(STATRELATT, - ObjectIdGetDatum(relid), - Int16GetDatum(attnum), - 0, 0); - if (HeapTupleIsValid(tp)) - { - int32 stawidth = ((Form_pg_statistic) GETSTRUCT(tp))->stawidth; - - ReleaseSysCache(tp); - if (stawidth > 0) - return stawidth; - } - return 0; -} - -/* - * get_attstatsslot - * - * Extract the contents of a "slot" of a pg_statistic tuple. - * Returns TRUE if requested slot type was found, else FALSE. - * - * Unlike other routines in this file, this takes a pointer to an - * already-looked-up tuple in the pg_statistic cache. We do this since - * most callers will want to extract more than one value from the cache - * entry, and we don't want to repeat the cache lookup unnecessarily. - * - * statstuple: pg_statistics tuple to be examined. - * atttype: type OID of attribute. - * atttypmod: typmod of attribute. - * reqkind: STAKIND code for desired statistics slot kind. - * reqop: STAOP value wanted, or InvalidOid if don't care. - * values, nvalues: if not NULL, the slot's stavalues are extracted. - * numbers, nnumbers: if not NULL, the slot's stanumbers are extracted. - * - * If assigned, values and numbers are set to point to palloc'd arrays. - * If the attribute type is pass-by-reference, the values referenced by - * the values array are themselves palloc'd. The palloc'd stuff can be - * freed by calling free_attstatsslot. - */ -bool -get_attstatsslot(HeapTuple statstuple, - Oid atttype, int32 atttypmod, - int reqkind, Oid reqop, - Datum **values, int *nvalues, - float4 **numbers, int *nnumbers) -{ - Form_pg_statistic stats = (Form_pg_statistic) GETSTRUCT(statstuple); - int i, - j; - Datum val; - bool isnull; - ArrayType *statarray; - int narrayelem; - HeapTuple typeTuple; - FmgrInfo inputproc; - Oid typelem; - - for (i = 0; i < STATISTIC_NUM_SLOTS; i++) - { - if ((&stats->stakind1)[i] == reqkind && - (reqop == InvalidOid || (&stats->staop1)[i] == reqop)) - break; - } - if (i >= STATISTIC_NUM_SLOTS) - return false; /* not there */ - - if (values) - { - val = SysCacheGetAttr(STATRELATT, statstuple, - Anum_pg_statistic_stavalues1 + i, - &isnull); - if (isnull) - elog(ERROR, "get_attstatsslot: stavalues is null"); - statarray = DatumGetArrayTypeP(val); - - /* - * Do initial examination of the array. This produces a list of - * text Datums --- ie, pointers into the text array value. - */ - deconstruct_array(statarray, false, -1, 'i', values, nvalues); - narrayelem = *nvalues; - - /* - * We now need to replace each text Datum by its internal - * equivalent. - * - * Get the type input proc and typelem for the column datatype. - */ - typeTuple = SearchSysCache(TYPEOID, - ObjectIdGetDatum(atttype), - 0, 0, 0); - if (!HeapTupleIsValid(typeTuple)) - elog(ERROR, "get_attstatsslot: Cache lookup failed for type %u", - atttype); - fmgr_info(((Form_pg_type) GETSTRUCT(typeTuple))->typinput, &inputproc); - typelem = ((Form_pg_type) GETSTRUCT(typeTuple))->typelem; - ReleaseSysCache(typeTuple); - - /* - * Do the conversions. The palloc'd array of Datums is reused in - * place. - */ - for (j = 0; j < narrayelem; j++) - { - char *strval; - - strval = DatumGetCString(DirectFunctionCall1(textout, - (*values)[j])); - (*values)[j] = FunctionCall3(&inputproc, - CStringGetDatum(strval), - ObjectIdGetDatum(typelem), - Int32GetDatum(atttypmod)); - pfree(strval); - } - - /* - * Free statarray if it's a detoasted copy. - */ - if ((Pointer) statarray != DatumGetPointer(val)) - pfree(statarray); - } - - if (numbers) - { - val = SysCacheGetAttr(STATRELATT, statstuple, - Anum_pg_statistic_stanumbers1 + i, - &isnull); - if (isnull) - elog(ERROR, "get_attstatsslot: stanumbers is null"); - statarray = DatumGetArrayTypeP(val); - - /* - * We expect the array to be a 1-D float4 array; verify that. We - * don't need to use deconstruct_array() since the array data is - * just going to look like a C array of float4 values. - */ - narrayelem = ARR_DIMS(statarray)[0]; - if (ARR_NDIM(statarray) != 1 || narrayelem <= 0 || - ARR_SIZE(statarray) != (ARR_OVERHEAD(1) + narrayelem * sizeof(float4))) - elog(ERROR, "get_attstatsslot: stanumbers is bogus"); - *numbers = (float4 *) palloc(narrayelem * sizeof(float4)); - memcpy(*numbers, ARR_DATA_PTR(statarray), narrayelem * sizeof(float4)); - *nnumbers = narrayelem; - - /* - * Free statarray if it's a detoasted copy. - */ - if ((Pointer) statarray != DatumGetPointer(val)) - pfree(statarray); - } - - return true; -} - -void -free_attstatsslot(Oid atttype, - Datum *values, int nvalues, - float4 *numbers, int nnumbers) -{ - if (values) - { - if (!get_typbyval(atttype)) - { - int i; - - for (i = 0; i < nvalues; i++) - pfree(DatumGetPointer(values[i])); - } - pfree(values); - } - if (numbers) - pfree(numbers); -} - -/* ---------- PG_NAMESPACE CACHE ---------- */ - -/* - * get_namespace_name - * Returns the name of a given namespace - * - * Returns a palloc'd copy of the string, or NULL if no such namespace. - */ -char * -get_namespace_name(Oid nspid) -{ - HeapTuple tp; - - tp = SearchSysCache(NAMESPACEOID, - ObjectIdGetDatum(nspid), - 0, 0, 0); - if (HeapTupleIsValid(tp)) - { - Form_pg_namespace nsptup = (Form_pg_namespace) GETSTRUCT(tp); - char *result; - - result = pstrdup(NameStr(nsptup->nspname)); - ReleaseSysCache(tp); - return result; - } - else - return NULL; -} - -/* ---------- PG_SHADOW CACHE ---------- */ - -/* - * get_usesysid - * - * Given a user name, look up the user's sysid. - * Raises an error if no such user (rather than returning zero, - * which might possibly be a valid usesysid). - * - * Note: the type of usesysid is currently int4, but may change to Oid - * someday. It'd be reasonable to return zero on failure if we were - * using Oid ... - */ -int32 -get_usesysid(const char *username) -{ - int32 result; - HeapTuple userTup; - - userTup = SearchSysCache(SHADOWNAME, - PointerGetDatum(username), - 0, 0, 0); - if (!HeapTupleIsValid(userTup)) - elog(ERROR, "user \"%s\" does not exist", username); - - result = ((Form_pg_shadow) GETSTRUCT(userTup))->usesysid; - - ReleaseSysCache(userTup); - - return result; -} diff --git a/src/backend/utils/cache/relcache.c b/src/backend/utils/cache/relcache.c deleted file mode 100644 index ec70be31b67..00000000000 --- a/src/backend/utils/cache/relcache.c +++ /dev/null @@ -1,3229 +0,0 @@ -/*------------------------------------------------------------------------- - * - * relcache.c - * POSTGRES relation descriptor cache code - * - * Portions Copyright (c) 1996-2002, PostgreSQL Global Development Group - * Portions Copyright (c) 1994, Regents of the University of California - * - * - * IDENTIFICATION - * $Header: /cvsroot/pgsql/src/backend/utils/cache/relcache.c,v 1.165 2002/06/20 20:29:39 momjian Exp $ - * - *------------------------------------------------------------------------- - */ -/* - * INTERFACE ROUTINES - * RelationCacheInitialize - initialize relcache - * RelationCacheInitializePhase2 - finish initializing relcache - * RelationIdGetRelation - get a reldesc by relation id - * RelationSysNameGetRelation - get a reldesc by system rel name - * RelationIdCacheGetRelation - get a cached reldesc by relid - * RelationClose - close an open relation - * - * NOTES - * The following code contains many undocumented hacks. Please be - * careful.... - */ -#include "postgres.h" - -#include <sys/types.h> -#include <errno.h> -#include <sys/file.h> -#include <fcntl.h> -#include <unistd.h> - -#include "access/genam.h" -#include "access/heapam.h" -#include "access/istrat.h" -#include "catalog/catalog.h" -#include "catalog/catname.h" -#include "catalog/indexing.h" -#include "catalog/pg_amop.h" -#include "catalog/pg_amproc.h" -#include "catalog/pg_attrdef.h" -#include "catalog/pg_attribute.h" -#include "catalog/pg_index.h" -#include "catalog/pg_namespace.h" -#include "catalog/pg_opclass.h" -#include "catalog/pg_proc.h" -#include "catalog/pg_relcheck.h" -#include "catalog/pg_rewrite.h" -#include "catalog/pg_type.h" -#include "commands/trigger.h" -#include "miscadmin.h" -#include "storage/smgr.h" -#include "utils/builtins.h" -#include "utils/catcache.h" -#include "utils/fmgroids.h" -#include "utils/inval.h" -#include "utils/lsyscache.h" -#include "utils/relcache.h" -#include "utils/syscache.h" - - -/* - * name of relcache init file, used to speed up backend startup - */ -#define RELCACHE_INIT_FILENAME "pg_internal.init" - -/* - * hardcoded tuple descriptors. see include/catalog/pg_attribute.h - */ -static FormData_pg_attribute Desc_pg_class[Natts_pg_class] = {Schema_pg_class}; -static FormData_pg_attribute Desc_pg_attribute[Natts_pg_attribute] = {Schema_pg_attribute}; -static FormData_pg_attribute Desc_pg_proc[Natts_pg_proc] = {Schema_pg_proc}; -static FormData_pg_attribute Desc_pg_type[Natts_pg_type] = {Schema_pg_type}; - -/* - * Hash tables that index the relation cache - * - * Relations are looked up two ways, by OID and by name, - * thus there are two hash tables for referencing them. - * - * The OID index covers all relcache entries. The name index - * covers *only* system relations (only those in PG_CATALOG_NAMESPACE). - */ -static HTAB *RelationIdCache; -static HTAB *RelationSysNameCache; - -/* - * Bufmgr uses RelFileNode for lookup. Actually, I would like to do - * not pass Relation to bufmgr & beyond at all and keep some cache - * in smgr, but no time to do it right way now. -- vadim 10/22/2000 - */ -static HTAB *RelationNodeCache; - -/* - * newlyCreatedRelns - - * relations created during this transaction. We need to keep track of - * these. - */ -static List *newlyCreatedRelns = NIL; - -/* - * This flag is false until we have prepared the critical relcache entries - * that are needed to do indexscans on the tables read by relcache building. - */ -bool criticalRelcachesBuilt = false; - -/* - * This flag is set if we discover that we need to write a new relcache - * cache file at the end of startup. - */ -static bool needNewCacheFile = false; - -/* - * This counter counts relcache inval events received since backend startup - * (but only for rels that are actually in cache). Presently, we use it only - * to detect whether data about to be written by write_relcache_init_file() - * might already be obsolete. - */ -static long relcacheInvalsReceived = 0L; - -/* - * This list remembers the OIDs of the relations cached in the relcache - * init file. - */ -static List *initFileRelationIds = NIL; - -/* - * RelationBuildDescInfo exists so code can be shared - * between RelationIdGetRelation() and RelationSysNameGetRelation() - */ -typedef struct RelationBuildDescInfo -{ - int infotype; /* lookup by id or by name */ -#define INFO_RELID 1 -#define INFO_RELNAME 2 - union - { - Oid info_id; /* relation object id */ - char *info_name; /* system relation name */ - } i; -} RelationBuildDescInfo; - -typedef struct relidcacheent -{ - Oid reloid; - Relation reldesc; -} RelIdCacheEnt; - -typedef struct relnamecacheent -{ - NameData relname; - Relation reldesc; -} RelNameCacheEnt; - -typedef struct relnodecacheent -{ - RelFileNode relnode; - Relation reldesc; -} RelNodeCacheEnt; - -/* - * macros to manipulate the lookup hashtables - */ -#define RelationCacheInsert(RELATION) \ -do { \ - RelIdCacheEnt *idhentry; RelNodeCacheEnt *nodentry; bool found; \ - idhentry = (RelIdCacheEnt*)hash_search(RelationIdCache, \ - (void *) &(RELATION->rd_id), \ - HASH_ENTER, \ - &found); \ - if (idhentry == NULL) \ - elog(ERROR, "out of memory for relation descriptor cache"); \ - /* used to give notice if found -- now just keep quiet */ \ - idhentry->reldesc = RELATION; \ - nodentry = (RelNodeCacheEnt*)hash_search(RelationNodeCache, \ - (void *) &(RELATION->rd_node), \ - HASH_ENTER, \ - &found); \ - if (nodentry == NULL) \ - elog(ERROR, "out of memory for relation descriptor cache"); \ - /* used to give notice if found -- now just keep quiet */ \ - nodentry->reldesc = RELATION; \ - if (IsSystemNamespace(RelationGetNamespace(RELATION))) \ - { \ - char *relname = RelationGetRelationName(RELATION); \ - RelNameCacheEnt *namehentry; \ - namehentry = (RelNameCacheEnt*)hash_search(RelationSysNameCache, \ - relname, \ - HASH_ENTER, \ - &found); \ - if (namehentry == NULL) \ - elog(ERROR, "out of memory for relation descriptor cache"); \ - /* used to give notice if found -- now just keep quiet */ \ - namehentry->reldesc = RELATION; \ - } \ -} while(0) - -#define RelationIdCacheLookup(ID, RELATION) \ -do { \ - RelIdCacheEnt *hentry; \ - hentry = (RelIdCacheEnt*)hash_search(RelationIdCache, \ - (void *)&(ID), HASH_FIND,NULL); \ - if (hentry) \ - RELATION = hentry->reldesc; \ - else \ - RELATION = NULL; \ -} while(0) - -#define RelationSysNameCacheLookup(NAME, RELATION) \ -do { \ - RelNameCacheEnt *hentry; \ - hentry = (RelNameCacheEnt*)hash_search(RelationSysNameCache, \ - (void *) (NAME), HASH_FIND,NULL); \ - if (hentry) \ - RELATION = hentry->reldesc; \ - else \ - RELATION = NULL; \ -} while(0) - -#define RelationNodeCacheLookup(NODE, RELATION) \ -do { \ - RelNodeCacheEnt *hentry; \ - hentry = (RelNodeCacheEnt*)hash_search(RelationNodeCache, \ - (void *)&(NODE), HASH_FIND,NULL); \ - if (hentry) \ - RELATION = hentry->reldesc; \ - else \ - RELATION = NULL; \ -} while(0) - -#define RelationCacheDelete(RELATION) \ -do { \ - RelIdCacheEnt *idhentry; RelNodeCacheEnt *nodentry; \ - idhentry = (RelIdCacheEnt*)hash_search(RelationIdCache, \ - (void *)&(RELATION->rd_id), \ - HASH_REMOVE, NULL); \ - if (idhentry == NULL) \ - elog(WARNING, "trying to delete a reldesc that does not exist."); \ - nodentry = (RelNodeCacheEnt*)hash_search(RelationNodeCache, \ - (void *)&(RELATION->rd_node), \ - HASH_REMOVE, NULL); \ - if (nodentry == NULL) \ - elog(WARNING, "trying to delete a reldesc that does not exist."); \ - if (IsSystemNamespace(RelationGetNamespace(RELATION))) \ - { \ - char *relname = RelationGetRelationName(RELATION); \ - RelNameCacheEnt *namehentry; \ - namehentry = (RelNameCacheEnt*)hash_search(RelationSysNameCache, \ - relname, \ - HASH_REMOVE, NULL); \ - if (namehentry == NULL) \ - elog(WARNING, "trying to delete a reldesc that does not exist."); \ - } \ -} while(0) - - -/* - * Special cache for opclass-related information - */ -typedef struct opclasscacheent -{ - Oid opclassoid; /* lookup key: OID of opclass */ - bool valid; /* set TRUE after successful fill-in */ - StrategyNumber numStrats; /* max # of strategies (from pg_am) */ - StrategyNumber numSupport; /* max # of support procs (from pg_am) */ - Oid *operatorOids; /* strategy operators' OIDs */ - RegProcedure *operatorProcs; /* strategy operators' procs */ - RegProcedure *supportProcs; /* support procs */ -} OpClassCacheEnt; - -static HTAB *OpClassCache = NULL; - - -/* non-export function prototypes */ - -static void RelationClearRelation(Relation relation, bool rebuildIt); - -#ifdef ENABLE_REINDEX_NAILED_RELATIONS -static void RelationReloadClassinfo(Relation relation); -#endif /* ENABLE_REINDEX_NAILED_RELATIONS */ -static void RelationFlushRelation(Relation relation); -static Relation RelationSysNameCacheGetRelation(const char *relationName); -static bool load_relcache_init_file(void); -static void write_relcache_init_file(void); - -static void formrdesc(const char *relationName, int natts, - FormData_pg_attribute *att); - -static HeapTuple ScanPgRelation(RelationBuildDescInfo buildinfo); -static Relation AllocateRelationDesc(Relation relation, Form_pg_class relp); -static void RelationBuildTupleDesc(RelationBuildDescInfo buildinfo, - Relation relation); -static Relation RelationBuildDesc(RelationBuildDescInfo buildinfo, - Relation oldrelation); -static void AttrDefaultFetch(Relation relation); -static void RelCheckFetch(Relation relation); -static List *insert_ordered_oid(List *list, Oid datum); -static void IndexSupportInitialize(Form_pg_index iform, - IndexStrategy indexStrategy, - Oid *indexOperator, - RegProcedure *indexSupport, - StrategyNumber maxStrategyNumber, - StrategyNumber maxSupportNumber, - AttrNumber maxAttributeNumber); -static OpClassCacheEnt *LookupOpclassInfo(Oid operatorClassOid, - StrategyNumber numStrats, - StrategyNumber numSupport); - - -/* - * ScanPgRelation - * - * this is used by RelationBuildDesc to find a pg_class - * tuple matching either a relation name or a relation id - * as specified in buildinfo. - * - * NB: the returned tuple has been copied into palloc'd storage - * and must eventually be freed with heap_freetuple. - */ -static HeapTuple -ScanPgRelation(RelationBuildDescInfo buildinfo) -{ - HeapTuple pg_class_tuple; - Relation pg_class_desc; - const char *indexRelname; - SysScanDesc pg_class_scan; - ScanKeyData key[2]; - int nkeys; - - /* - * form a scan key - */ - switch (buildinfo.infotype) - { - case INFO_RELID: - ScanKeyEntryInitialize(&key[0], 0, - ObjectIdAttributeNumber, - F_OIDEQ, - ObjectIdGetDatum(buildinfo.i.info_id)); - nkeys = 1; - indexRelname = ClassOidIndex; - break; - - case INFO_RELNAME: - ScanKeyEntryInitialize(&key[0], 0, - Anum_pg_class_relname, - F_NAMEEQ, - NameGetDatum(buildinfo.i.info_name)); - ScanKeyEntryInitialize(&key[1], 0, - Anum_pg_class_relnamespace, - F_OIDEQ, - ObjectIdGetDatum(PG_CATALOG_NAMESPACE)); - nkeys = 2; - indexRelname = ClassNameNspIndex; - break; - - default: - elog(ERROR, "ScanPgRelation: bad buildinfo"); - return NULL; /* keep compiler quiet */ - } - - /* - * Open pg_class and fetch a tuple. Force heap scan if we haven't - * yet built the critical relcache entries (this includes initdb - * and startup without a pg_internal.init file). - */ - pg_class_desc = heap_openr(RelationRelationName, AccessShareLock); - pg_class_scan = systable_beginscan(pg_class_desc, indexRelname, - criticalRelcachesBuilt, - SnapshotNow, - nkeys, key); - - pg_class_tuple = systable_getnext(pg_class_scan); - - /* - * Must copy tuple before releasing buffer. - */ - if (HeapTupleIsValid(pg_class_tuple)) - pg_class_tuple = heap_copytuple(pg_class_tuple); - - /* all done */ - systable_endscan(pg_class_scan); - heap_close(pg_class_desc, AccessShareLock); - - return pg_class_tuple; -} - -/* - * AllocateRelationDesc - * - * This is used to allocate memory for a new relation descriptor - * and initialize the rd_rel field. - * - * If 'relation' is NULL, allocate a new RelationData object. - * If not, reuse the given object (that path is taken only when - * we have to rebuild a relcache entry during RelationClearRelation). - */ -static Relation -AllocateRelationDesc(Relation relation, Form_pg_class relp) -{ - MemoryContext oldcxt; - Form_pg_class relationForm; - - /* Relcache entries must live in CacheMemoryContext */ - oldcxt = MemoryContextSwitchTo(CacheMemoryContext); - - /* - * allocate space for new relation descriptor, if needed - */ - if (relation == NULL) - relation = (Relation) palloc(sizeof(RelationData)); - - /* - * clear all fields of reldesc - */ - MemSet((char *) relation, 0, sizeof(RelationData)); - relation->rd_targblock = InvalidBlockNumber; - - /* make sure relation is marked as having no open file yet */ - relation->rd_fd = -1; - - /* - * Copy the relation tuple form - * - * We only allocate space for the fixed fields, ie, CLASS_TUPLE_SIZE. - * relacl is NOT stored in the relcache --- there'd be little point in - * it, since we don't copy the tuple's nullvalues bitmap and hence - * wouldn't know if the value is valid ... bottom line is that relacl - * *cannot* be retrieved from the relcache. Get it from the syscache - * if you need it. - */ - relationForm = (Form_pg_class) palloc(CLASS_TUPLE_SIZE); - - memcpy((char *) relationForm, (char *) relp, CLASS_TUPLE_SIZE); - - /* initialize relation tuple form */ - relation->rd_rel = relationForm; - - /* and allocate attribute tuple form storage */ - relation->rd_att = CreateTemplateTupleDesc(relationForm->relnatts); - - MemoryContextSwitchTo(oldcxt); - - return relation; -} - -/* - * RelationBuildTupleDesc - * - * Form the relation's tuple descriptor from information in - * the pg_attribute, pg_attrdef & pg_relcheck system catalogs. - */ -static void -RelationBuildTupleDesc(RelationBuildDescInfo buildinfo, - Relation relation) -{ - HeapTuple pg_attribute_tuple; - Relation pg_attribute_desc; - SysScanDesc pg_attribute_scan; - ScanKeyData skey[2]; - int need; - TupleConstr *constr; - AttrDefault *attrdef = NULL; - int ndef = 0; - - constr = (TupleConstr *) MemoryContextAlloc(CacheMemoryContext, - sizeof(TupleConstr)); - constr->has_not_null = false; - - /* - * Form a scan key that selects only user attributes (attnum > 0). - * (Eliminating system attribute rows at the index level is lots - * faster than fetching them.) - */ - ScanKeyEntryInitialize(&skey[0], 0, - Anum_pg_attribute_attrelid, - F_OIDEQ, - ObjectIdGetDatum(RelationGetRelid(relation))); - ScanKeyEntryInitialize(&skey[1], 0, - Anum_pg_attribute_attnum, - F_INT2GT, - Int16GetDatum(0)); - - /* - * Open pg_attribute and begin a scan. Force heap scan if we haven't - * yet built the critical relcache entries (this includes initdb - * and startup without a pg_internal.init file). - */ - pg_attribute_desc = heap_openr(AttributeRelationName, AccessShareLock); - pg_attribute_scan = systable_beginscan(pg_attribute_desc, - AttributeRelidNumIndex, - criticalRelcachesBuilt, - SnapshotNow, - 2, skey); - - /* - * add attribute data to relation->rd_att - */ - need = relation->rd_rel->relnatts; - - while (HeapTupleIsValid(pg_attribute_tuple = systable_getnext(pg_attribute_scan))) - { - Form_pg_attribute attp; - - attp = (Form_pg_attribute) GETSTRUCT(pg_attribute_tuple); - - if (attp->attnum <= 0 || - attp->attnum > relation->rd_rel->relnatts) - elog(ERROR, "Bogus attribute number %d for %s", - attp->attnum, RelationGetRelationName(relation)); - - relation->rd_att->attrs[attp->attnum - 1] = - (Form_pg_attribute) MemoryContextAlloc(CacheMemoryContext, - ATTRIBUTE_TUPLE_SIZE); - - memcpy((char *) (relation->rd_att->attrs[attp->attnum - 1]), - (char *) attp, - ATTRIBUTE_TUPLE_SIZE); - - /* Update constraint/default info */ - if (attp->attnotnull) - constr->has_not_null = true; - - if (attp->atthasdef) - { - if (attrdef == NULL) - { - attrdef = (AttrDefault *) - MemoryContextAlloc(CacheMemoryContext, - relation->rd_rel->relnatts * - sizeof(AttrDefault)); - MemSet(attrdef, 0, - relation->rd_rel->relnatts * sizeof(AttrDefault)); - } - attrdef[ndef].adnum = attp->attnum; - attrdef[ndef].adbin = NULL; - ndef++; - } - need--; - if (need == 0) - break; - } - - /* - * end the scan and close the attribute relation - */ - systable_endscan(pg_attribute_scan); - heap_close(pg_attribute_desc, AccessShareLock); - - if (need != 0) - elog(ERROR, "catalog is missing %d attribute(s) for relid %u", - need, RelationGetRelid(relation)); - - /* - * The attcacheoff values we read from pg_attribute should all be -1 - * ("unknown"). Verify this if assert checking is on. They will be - * computed when and if needed during tuple access. - */ -#ifdef USE_ASSERT_CHECKING - { - int i; - - for (i = 0; i < relation->rd_rel->relnatts; i++) - Assert(relation->rd_att->attrs[i]->attcacheoff == -1); - } -#endif - - /* - * However, we can easily set the attcacheoff value for the first - * attribute: it must be zero. This eliminates the need for special - * cases for attnum=1 that used to exist in fastgetattr() and - * index_getattr(). - */ - relation->rd_att->attrs[0]->attcacheoff = 0; - - /* - * Set up constraint/default info - */ - if (constr->has_not_null || ndef > 0 || relation->rd_rel->relchecks) - { - relation->rd_att->constr = constr; - - if (ndef > 0) /* DEFAULTs */ - { - if (ndef < relation->rd_rel->relnatts) - constr->defval = (AttrDefault *) - repalloc(attrdef, ndef * sizeof(AttrDefault)); - else - constr->defval = attrdef; - constr->num_defval = ndef; - AttrDefaultFetch(relation); - } - else - constr->num_defval = 0; - - if (relation->rd_rel->relchecks > 0) /* CHECKs */ - { - constr->num_check = relation->rd_rel->relchecks; - constr->check = (ConstrCheck *) - MemoryContextAlloc(CacheMemoryContext, - constr->num_check * sizeof(ConstrCheck)); - MemSet(constr->check, 0, constr->num_check * sizeof(ConstrCheck)); - RelCheckFetch(relation); - } - else - constr->num_check = 0; - } - else - { - pfree(constr); - relation->rd_att->constr = NULL; - } -} - -/* - * RelationBuildRuleLock - * - * Form the relation's rewrite rules from information in - * the pg_rewrite system catalog. - * - * Note: The rule parsetrees are potentially very complex node structures. - * To allow these trees to be freed when the relcache entry is flushed, - * we make a private memory context to hold the RuleLock information for - * each relcache entry that has associated rules. The context is used - * just for rule info, not for any other subsidiary data of the relcache - * entry, because that keeps the update logic in RelationClearRelation() - * manageable. The other subsidiary data structures are simple enough - * to be easy to free explicitly, anyway. - */ -static void -RelationBuildRuleLock(Relation relation) -{ - MemoryContext rulescxt; - MemoryContext oldcxt; - HeapTuple rewrite_tuple; - Relation rewrite_desc; - TupleDesc rewrite_tupdesc; - SysScanDesc rewrite_scan; - ScanKeyData key; - RuleLock *rulelock; - int numlocks; - RewriteRule **rules; - int maxlocks; - - /* - * Make the private context. Parameters are set on the assumption - * that it'll probably not contain much data. - */ - rulescxt = AllocSetContextCreate(CacheMemoryContext, - RelationGetRelationName(relation), - 0, /* minsize */ - 1024, /* initsize */ - 1024); /* maxsize */ - relation->rd_rulescxt = rulescxt; - - /* - * allocate an array to hold the rewrite rules (the array is extended if - * necessary) - */ - maxlocks = 4; - rules = (RewriteRule **) - MemoryContextAlloc(rulescxt, sizeof(RewriteRule *) * maxlocks); - numlocks = 0; - - /* - * form a scan key - */ - ScanKeyEntryInitialize(&key, 0, - Anum_pg_rewrite_ev_class, - F_OIDEQ, - ObjectIdGetDatum(RelationGetRelid(relation))); - - /* - * open pg_rewrite and begin a scan - * - * Note: since we scan the rules using RewriteRelRulenameIndex, - * we will be reading the rules in name order, except possibly - * during emergency-recovery operations (ie, IsIgnoringSystemIndexes). - * This in turn ensures that rules will be fired in name order. - */ - rewrite_desc = heap_openr(RewriteRelationName, AccessShareLock); - rewrite_tupdesc = RelationGetDescr(rewrite_desc); - rewrite_scan = systable_beginscan(rewrite_desc, - RewriteRelRulenameIndex, - true, SnapshotNow, - 1, &key); - - while (HeapTupleIsValid(rewrite_tuple = systable_getnext(rewrite_scan))) - { - Form_pg_rewrite rewrite_form = (Form_pg_rewrite) GETSTRUCT(rewrite_tuple); - bool isnull; - Datum ruleaction; - Datum rule_evqual; - char *ruleaction_str; - char *rule_evqual_str; - RewriteRule *rule; - - rule = (RewriteRule *) MemoryContextAlloc(rulescxt, - sizeof(RewriteRule)); - - rule->ruleId = rewrite_tuple->t_data->t_oid; - - rule->event = rewrite_form->ev_type - '0'; - rule->attrno = rewrite_form->ev_attr; - rule->isInstead = rewrite_form->is_instead; - - /* Must use heap_getattr to fetch ev_qual and ev_action */ - - ruleaction = heap_getattr(rewrite_tuple, - Anum_pg_rewrite_ev_action, - rewrite_tupdesc, - &isnull); - Assert(!isnull); - ruleaction_str = DatumGetCString(DirectFunctionCall1(textout, - ruleaction)); - oldcxt = MemoryContextSwitchTo(rulescxt); - rule->actions = (List *) stringToNode(ruleaction_str); - MemoryContextSwitchTo(oldcxt); - pfree(ruleaction_str); - - rule_evqual = heap_getattr(rewrite_tuple, - Anum_pg_rewrite_ev_qual, - rewrite_tupdesc, - &isnull); - Assert(!isnull); - rule_evqual_str = DatumGetCString(DirectFunctionCall1(textout, - rule_evqual)); - oldcxt = MemoryContextSwitchTo(rulescxt); - rule->qual = (Node *) stringToNode(rule_evqual_str); - MemoryContextSwitchTo(oldcxt); - pfree(rule_evqual_str); - - if (numlocks >= maxlocks) - { - maxlocks *= 2; - rules = (RewriteRule **) - repalloc(rules, sizeof(RewriteRule *) * maxlocks); - } - rules[numlocks++] = rule; - } - - /* - * end the scan and close the attribute relation - */ - systable_endscan(rewrite_scan); - heap_close(rewrite_desc, AccessShareLock); - - /* - * form a RuleLock and insert into relation - */ - rulelock = (RuleLock *) MemoryContextAlloc(rulescxt, sizeof(RuleLock)); - rulelock->numLocks = numlocks; - rulelock->rules = rules; - - relation->rd_rules = rulelock; -} - -/* - * equalRuleLocks - * - * Determine whether two RuleLocks are equivalent - * - * Probably this should be in the rules code someplace... - */ -static bool -equalRuleLocks(RuleLock *rlock1, RuleLock *rlock2) -{ - int i; - - /* - * As of 7.3 we assume the rule ordering is repeatable, - * because RelationBuildRuleLock should read 'em in a - * consistent order. So just compare corresponding slots. - */ - if (rlock1 != NULL) - { - if (rlock2 == NULL) - return false; - if (rlock1->numLocks != rlock2->numLocks) - return false; - for (i = 0; i < rlock1->numLocks; i++) - { - RewriteRule *rule1 = rlock1->rules[i]; - RewriteRule *rule2 = rlock2->rules[i]; - - if (rule1->ruleId != rule2->ruleId) - return false; - if (rule1->event != rule2->event) - return false; - if (rule1->attrno != rule2->attrno) - return false; - if (rule1->isInstead != rule2->isInstead) - return false; - if (!equal(rule1->qual, rule2->qual)) - return false; - if (!equal(rule1->actions, rule2->actions)) - return false; - } - } - else if (rlock2 != NULL) - return false; - return true; -} - - -/* ---------------------------------- - * RelationBuildDesc - * - * Build a relation descriptor --- either a new one, or by - * recycling the given old relation object. The latter case - * supports rebuilding a relcache entry without invalidating - * pointers to it. - * -------------------------------- - */ -static Relation -RelationBuildDesc(RelationBuildDescInfo buildinfo, - Relation oldrelation) -{ - Relation relation; - Oid relid; - HeapTuple pg_class_tuple; - Form_pg_class relp; - MemoryContext oldcxt; - - /* - * find the tuple in pg_class corresponding to the given relation id - */ - pg_class_tuple = ScanPgRelation(buildinfo); - - /* - * if no such tuple exists, return NULL - */ - if (!HeapTupleIsValid(pg_class_tuple)) - return NULL; - - /* - * get information from the pg_class_tuple - */ - relid = pg_class_tuple->t_data->t_oid; - relp = (Form_pg_class) GETSTRUCT(pg_class_tuple); - - /* - * allocate storage for the relation descriptor, and copy - * pg_class_tuple to relation->rd_rel. - */ - relation = AllocateRelationDesc(oldrelation, relp); - - /* - * now we can free the memory allocated for pg_class_tuple - */ - heap_freetuple(pg_class_tuple); - - /* - * initialize the relation's relation id (relation->rd_id) - */ - RelationGetRelid(relation) = relid; - - /* - * initialize relation->rd_refcnt - */ - RelationSetReferenceCount(relation, 1); - - /* - * normal relations are not nailed into the cache - */ - relation->rd_isnailed = false; - - /* - * initialize the tuple descriptor (relation->rd_att). - */ - RelationBuildTupleDesc(buildinfo, relation); - - /* - * Fetch rules and triggers that affect this relation - */ - if (relation->rd_rel->relhasrules) - RelationBuildRuleLock(relation); - else - { - relation->rd_rules = NULL; - relation->rd_rulescxt = NULL; - } - - if (relation->rd_rel->reltriggers > 0) - RelationBuildTriggers(relation); - else - relation->trigdesc = NULL; - - /* - * if it's an index, initialize index-related information - */ - if (OidIsValid(relation->rd_rel->relam)) - RelationInitIndexAccessInfo(relation); - - /* - * initialize the relation lock manager information - */ - RelationInitLockInfo(relation); /* see lmgr.c */ - - if (relation->rd_rel->relisshared) - relation->rd_node.tblNode = InvalidOid; - else - relation->rd_node.tblNode = MyDatabaseId; - relation->rd_node.relNode = relation->rd_rel->relfilenode; - - /* make sure relation is marked as having no open file yet */ - relation->rd_fd = -1; - - /* - * insert newly created relation into proper relcaches, restore memory - * context and return the new reldesc. - */ - oldcxt = MemoryContextSwitchTo(CacheMemoryContext); - RelationCacheInsert(relation); - MemoryContextSwitchTo(oldcxt); - - return relation; -} - -/* - * Initialize index-access-method support data for an index relation - */ -void -RelationInitIndexAccessInfo(Relation relation) -{ - HeapTuple tuple; - Size iformsize; - Form_pg_index iform; - Form_pg_am aform; - MemoryContext indexcxt; - IndexStrategy strategy; - Oid *operator; - RegProcedure *support; - FmgrInfo *supportinfo; - int natts; - uint16 amstrategies; - uint16 amsupport; - - /* - * Make a copy of the pg_index entry for the index. Note that this - * is a variable-length tuple. - */ - tuple = SearchSysCache(INDEXRELID, - ObjectIdGetDatum(RelationGetRelid(relation)), - 0, 0, 0); - if (!HeapTupleIsValid(tuple)) - elog(ERROR, "RelationInitIndexAccessInfo: no pg_index entry for index %u", - RelationGetRelid(relation)); - iformsize = tuple->t_len - tuple->t_data->t_hoff; - iform = (Form_pg_index) MemoryContextAlloc(CacheMemoryContext, iformsize); - memcpy(iform, GETSTRUCT(tuple), iformsize); - ReleaseSysCache(tuple); - relation->rd_index = iform; - - /* this field is now kinda redundant... */ - relation->rd_uniqueindex = iform->indisunique; - - /* - * Make a copy of the pg_am entry for the index's access method - */ - tuple = SearchSysCache(AMOID, - ObjectIdGetDatum(relation->rd_rel->relam), - 0, 0, 0); - if (!HeapTupleIsValid(tuple)) - elog(ERROR, "RelationInitIndexAccessInfo: cache lookup failed for AM %u", - relation->rd_rel->relam); - aform = (Form_pg_am) MemoryContextAlloc(CacheMemoryContext, sizeof *aform); - memcpy(aform, GETSTRUCT(tuple), sizeof *aform); - ReleaseSysCache(tuple); - relation->rd_am = aform; - - natts = relation->rd_rel->relnatts; - amstrategies = aform->amstrategies; - amsupport = aform->amsupport; - - /* - * Make the private context to hold index access info. The reason we - * need a context, and not just a couple of pallocs, is so that we - * won't leak any subsidiary info attached to fmgr lookup records. - * - * Context parameters are set on the assumption that it'll probably not - * contain much data. - */ - indexcxt = AllocSetContextCreate(CacheMemoryContext, - RelationGetRelationName(relation), - 0, /* minsize */ - 512, /* initsize */ - 1024); /* maxsize */ - relation->rd_indexcxt = indexcxt; - - /* - * Allocate arrays to hold data - */ - if (amstrategies > 0) - { - int noperators = natts * amstrategies; - Size stratSize; - - stratSize = AttributeNumberGetIndexStrategySize(natts, amstrategies); - strategy = (IndexStrategy) MemoryContextAlloc(indexcxt, stratSize); - MemSet(strategy, 0, stratSize); - operator = (Oid *) - MemoryContextAlloc(indexcxt, noperators * sizeof(Oid)); - MemSet(operator, 0, noperators * sizeof(Oid)); - } - else - { - strategy = NULL; - operator = NULL; - } - - if (amsupport > 0) - { - int nsupport = natts * amsupport; - - support = (RegProcedure *) - MemoryContextAlloc(indexcxt, nsupport * sizeof(RegProcedure)); - MemSet(support, 0, nsupport * sizeof(RegProcedure)); - supportinfo = (FmgrInfo *) - MemoryContextAlloc(indexcxt, nsupport * sizeof(FmgrInfo)); - MemSet(supportinfo, 0, nsupport * sizeof(FmgrInfo)); - } - else - { - support = NULL; - supportinfo = NULL; - } - - relation->rd_istrat = strategy; - relation->rd_operator = operator; - relation->rd_support = support; - relation->rd_supportinfo = supportinfo; - - /* - * Fill the strategy map and the support RegProcedure arrays. - * (supportinfo is left as zeroes, and is filled on-the-fly when used) - */ - IndexSupportInitialize(iform, - strategy, operator, support, - amstrategies, amsupport, natts); -} - -/* - * IndexSupportInitialize - * Initializes an index strategy and associated support procedures, - * given the index's pg_index tuple. - * - * Data is returned into *indexStrategy, *indexOperator, and *indexSupport, - * all of which are objects allocated by the caller. - * - * The caller also passes maxStrategyNumber, maxSupportNumber, and - * maxAttributeNumber, since these indicate the size of the arrays - * it has allocated --- but in practice these numbers must always match - * those obtainable from the system catalog entries for the index and - * access method. - */ -static void -IndexSupportInitialize(Form_pg_index iform, - IndexStrategy indexStrategy, - Oid *indexOperator, - RegProcedure *indexSupport, - StrategyNumber maxStrategyNumber, - StrategyNumber maxSupportNumber, - AttrNumber maxAttributeNumber) -{ - int attIndex; - - maxStrategyNumber = AMStrategies(maxStrategyNumber); - - /* - * XXX note that the following assumes the INDEX tuple is well formed - * and that the *key and *class are 0 terminated. - */ - for (attIndex = 0; attIndex < maxAttributeNumber; attIndex++) - { - OpClassCacheEnt *opcentry; - - if (iform->indkey[attIndex] == InvalidAttrNumber || - !OidIsValid(iform->indclass[attIndex])) - elog(ERROR, "IndexSupportInitialize: bogus pg_index tuple"); - - /* look up the info for this opclass, using a cache */ - opcentry = LookupOpclassInfo(iform->indclass[attIndex], - maxStrategyNumber, - maxSupportNumber); - - /* load the strategy information for the index operators */ - if (maxStrategyNumber > 0) - { - StrategyMap map; - Oid *opers; - StrategyNumber strategy; - - map = IndexStrategyGetStrategyMap(indexStrategy, - maxStrategyNumber, - attIndex + 1); - opers = &indexOperator[attIndex * maxStrategyNumber]; - - for (strategy = 0; strategy < maxStrategyNumber; strategy++) - { - ScanKey mapentry; - - mapentry = StrategyMapGetScanKeyEntry(map, strategy + 1); - if (RegProcedureIsValid(opcentry->operatorProcs[strategy])) - { - MemSet(mapentry, 0, sizeof(*mapentry)); - mapentry->sk_flags = 0; - mapentry->sk_procedure = opcentry->operatorProcs[strategy]; - /* - * Mark mapentry->sk_func invalid, until and unless - * someone sets it up. - */ - mapentry->sk_func.fn_oid = InvalidOid; - } - else - ScanKeyEntrySetIllegal(mapentry); - opers[strategy] = opcentry->operatorOids[strategy]; - } - } - - /* if support routines exist for this access method, load them */ - if (maxSupportNumber > 0) - { - RegProcedure *procs; - StrategyNumber support; - - procs = &indexSupport[attIndex * maxSupportNumber]; - - for (support = 0; support < maxSupportNumber; ++support) - procs[support] = opcentry->supportProcs[support]; - } - } -} - -/* - * LookupOpclassInfo - * - * This routine maintains a per-opclass cache of the information needed - * by IndexSupportInitialize(). This is more efficient than relying on - * the catalog cache, because we can load all the info about a particular - * opclass in a single indexscan of pg_amproc or pg_amop. - * - * The information from pg_am about expected range of strategy and support - * numbers is passed in, rather than being looked up, mainly because the - * caller will have it already. - * - * XXX There isn't any provision for flushing the cache. However, there - * isn't any provision for flushing relcache entries when opclass info - * changes, either :-( - */ -static OpClassCacheEnt * -LookupOpclassInfo(Oid operatorClassOid, - StrategyNumber numStrats, - StrategyNumber numSupport) -{ - OpClassCacheEnt *opcentry; - bool found; - Relation pg_amop_desc; - Relation pg_amproc_desc; - SysScanDesc pg_amop_scan; - SysScanDesc pg_amproc_scan; - ScanKeyData key; - HeapTuple htup; - bool indexOK; - - if (OpClassCache == NULL) - { - /* First time through: initialize the opclass cache */ - HASHCTL ctl; - - if (!CacheMemoryContext) - CreateCacheMemoryContext(); - - MemSet(&ctl, 0, sizeof(ctl)); - ctl.keysize = sizeof(Oid); - ctl.entrysize = sizeof(OpClassCacheEnt); - ctl.hash = tag_hash; - OpClassCache = hash_create("Operator class cache", 64, - &ctl, HASH_ELEM | HASH_FUNCTION); - } - - opcentry = (OpClassCacheEnt *) hash_search(OpClassCache, - (void *) &operatorClassOid, - HASH_ENTER, &found); - if (opcentry == NULL) - elog(ERROR, "out of memory for operator class cache"); - - if (found && opcentry->valid) - { - /* Already made an entry for it */ - Assert(numStrats == opcentry->numStrats); - Assert(numSupport == opcentry->numSupport); - return opcentry; - } - - /* Need to fill in new entry */ - opcentry->valid = false; /* until known OK */ - opcentry->numStrats = numStrats; - opcentry->numSupport = numSupport; - - if (numStrats > 0) - { - opcentry->operatorOids = (Oid *) - MemoryContextAlloc(CacheMemoryContext, - numStrats * sizeof(Oid)); - MemSet(opcentry->operatorOids, 0, numStrats * sizeof(Oid)); - opcentry->operatorProcs = (RegProcedure *) - MemoryContextAlloc(CacheMemoryContext, - numStrats * sizeof(RegProcedure)); - MemSet(opcentry->operatorProcs, 0, numStrats * sizeof(RegProcedure)); - } - else - { - opcentry->operatorOids = NULL; - opcentry->operatorProcs = NULL; - } - - if (numSupport > 0) - { - opcentry->supportProcs = (RegProcedure *) - MemoryContextAlloc(CacheMemoryContext, - numSupport * sizeof(RegProcedure)); - MemSet(opcentry->supportProcs, 0, numSupport * sizeof(RegProcedure)); - } - else - opcentry->supportProcs = NULL; - - /* - * To avoid infinite recursion during startup, force a heap scan if - * we're looking up info for the opclasses used by the indexes we - * would like to reference here. - */ - indexOK = criticalRelcachesBuilt || - (operatorClassOid != OID_BTREE_OPS_OID && - operatorClassOid != INT2_BTREE_OPS_OID); - - /* - * Scan pg_amop to obtain operators for the opclass - */ - if (numStrats > 0) - { - ScanKeyEntryInitialize(&key, 0, - Anum_pg_amop_amopclaid, - F_OIDEQ, - ObjectIdGetDatum(operatorClassOid)); - pg_amop_desc = heap_openr(AccessMethodOperatorRelationName, - AccessShareLock); - pg_amop_scan = systable_beginscan(pg_amop_desc, - AccessMethodStrategyIndex, - indexOK, - SnapshotNow, - 1, &key); - - while (HeapTupleIsValid(htup = systable_getnext(pg_amop_scan))) - { - Form_pg_amop amopform = (Form_pg_amop) GETSTRUCT(htup); - - if (amopform->amopstrategy <= 0 || - (StrategyNumber) amopform->amopstrategy > numStrats) - elog(ERROR, "Bogus amopstrategy number %d for opclass %u", - amopform->amopstrategy, operatorClassOid); - opcentry->operatorOids[amopform->amopstrategy - 1] = - amopform->amopopr; - opcentry->operatorProcs[amopform->amopstrategy - 1] = - get_opcode(amopform->amopopr); - } - - systable_endscan(pg_amop_scan); - heap_close(pg_amop_desc, AccessShareLock); - } - - /* - * Scan pg_amproc to obtain support procs for the opclass - */ - if (numSupport > 0) - { - ScanKeyEntryInitialize(&key, 0, - Anum_pg_amproc_amopclaid, - F_OIDEQ, - ObjectIdGetDatum(operatorClassOid)); - pg_amproc_desc = heap_openr(AccessMethodProcedureRelationName, - AccessShareLock); - pg_amproc_scan = systable_beginscan(pg_amproc_desc, - AccessMethodProcedureIndex, - indexOK, - SnapshotNow, - 1, &key); - - while (HeapTupleIsValid(htup = systable_getnext(pg_amproc_scan))) - { - Form_pg_amproc amprocform = (Form_pg_amproc) GETSTRUCT(htup); - - if (amprocform->amprocnum <= 0 || - (StrategyNumber) amprocform->amprocnum > numSupport) - elog(ERROR, "Bogus amproc number %d for opclass %u", - amprocform->amprocnum, operatorClassOid); - - opcentry->supportProcs[amprocform->amprocnum - 1] = - amprocform->amproc; - } - - systable_endscan(pg_amproc_scan); - heap_close(pg_amproc_desc, AccessShareLock); - } - - opcentry->valid = true; - return opcentry; -} - - -/* - * formrdesc - * - * This is a special cut-down version of RelationBuildDesc() - * used by RelationCacheInitialize() in initializing the relcache. - * The relation descriptor is built just from the supplied parameters, - * without actually looking at any system table entries. We cheat - * quite a lot since we only need to work for a few basic system - * catalogs. - * - * formrdesc is currently used for: pg_class, pg_attribute, pg_proc, - * and pg_type (see RelationCacheInitialize). - * - * Note that these catalogs can't have constraints, default values, - * rules, or triggers, since we don't cope with any of that. - * - * NOTE: we assume we are already switched into CacheMemoryContext. - */ -static void -formrdesc(const char *relationName, - int natts, - FormData_pg_attribute *att) -{ - Relation relation; - int i; - - /* - * allocate new relation desc - */ - relation = (Relation) palloc(sizeof(RelationData)); - - /* - * clear all fields of reldesc - */ - MemSet((char *) relation, 0, sizeof(RelationData)); - relation->rd_targblock = InvalidBlockNumber; - - /* make sure relation is marked as having no open file yet */ - relation->rd_fd = -1; - - /* - * initialize reference count - */ - RelationSetReferenceCount(relation, 1); - - /* - * all entries built with this routine are nailed-in-cache - */ - relation->rd_isnailed = true; - - /* - * initialize relation tuple form - * - * The data we insert here is pretty incomplete/bogus, but it'll serve to - * get us launched. RelationCacheInitializePhase2() will read the - * real data from pg_class and replace what we've done here. - */ - relation->rd_rel = (Form_pg_class) palloc(CLASS_TUPLE_SIZE); - MemSet(relation->rd_rel, 0, CLASS_TUPLE_SIZE); - - namestrcpy(&relation->rd_rel->relname, relationName); - relation->rd_rel->relnamespace = PG_CATALOG_NAMESPACE; - - /* - * It's important to distinguish between shared and non-shared - * relations, even at bootstrap time, to make sure we know where they - * are stored. At present, all relations that formrdesc is used for - * are not shared. - */ - relation->rd_rel->relisshared = false; - - relation->rd_rel->relpages = 1; - relation->rd_rel->reltuples = 1; - relation->rd_rel->relkind = RELKIND_RELATION; - relation->rd_rel->relhasoids = true; - relation->rd_rel->relnatts = (int16) natts; - - /* - * initialize attribute tuple form - * - * Unlike the case with the relation tuple, this data had better be - * right because it will never be replaced. The input values must be - * correctly defined by macros in src/include/catalog/ headers. - */ - relation->rd_att = CreateTemplateTupleDesc(natts); - - /* - * initialize tuple desc info - */ - for (i = 0; i < natts; i++) - { - relation->rd_att->attrs[i] = (Form_pg_attribute) palloc(ATTRIBUTE_TUPLE_SIZE); - memcpy((char *) relation->rd_att->attrs[i], - (char *) &att[i], - ATTRIBUTE_TUPLE_SIZE); - /* make sure attcacheoff is valid */ - relation->rd_att->attrs[i]->attcacheoff = -1; - } - - /* initialize first attribute's attcacheoff, cf RelationBuildTupleDesc */ - relation->rd_att->attrs[0]->attcacheoff = 0; - - /* - * initialize relation id from info in att array (my, this is ugly) - */ - RelationGetRelid(relation) = relation->rd_att->attrs[0]->attrelid; - - /* - * initialize the relation's lock manager and RelFileNode information - */ - RelationInitLockInfo(relation); /* see lmgr.c */ - - if (relation->rd_rel->relisshared) - relation->rd_node.tblNode = InvalidOid; - else - relation->rd_node.tblNode = MyDatabaseId; - relation->rd_node.relNode = - relation->rd_rel->relfilenode = RelationGetRelid(relation); - - /* - * initialize the rel-has-index flag, using hardwired knowledge - */ - relation->rd_rel->relhasindex = false; - - /* In bootstrap mode, we have no indexes */ - if (!IsBootstrapProcessingMode()) - { - /* Otherwise, all the rels formrdesc is used for have indexes */ - relation->rd_rel->relhasindex = true; - } - - /* - * add new reldesc to relcache - */ - RelationCacheInsert(relation); -} - - -/* ---------------------------------------------------------------- - * Relation Descriptor Lookup Interface - * ---------------------------------------------------------------- - */ - -/* - * RelationIdCacheGetRelation - * - * Lookup an existing reldesc by OID. - * - * Only try to get the reldesc by looking in the cache, - * do not go to the disk. - * - * NB: relation ref count is incremented if successful. - * Caller should eventually decrement count. (Usually, - * that happens by calling RelationClose().) - */ -Relation -RelationIdCacheGetRelation(Oid relationId) -{ - Relation rd; - - RelationIdCacheLookup(relationId, rd); - - if (RelationIsValid(rd)) - RelationIncrementReferenceCount(rd); - - return rd; -} - -/* - * RelationSysNameCacheGetRelation - * - * As above, but lookup by name; only works for system catalogs. - */ -static Relation -RelationSysNameCacheGetRelation(const char *relationName) -{ - Relation rd; - NameData name; - - /* - * make sure that the name key used for hash lookup is properly - * null-padded - */ - namestrcpy(&name, relationName); - RelationSysNameCacheLookup(NameStr(name), rd); - - if (RelationIsValid(rd)) - RelationIncrementReferenceCount(rd); - - return rd; -} - -Relation -RelationNodeCacheGetRelation(RelFileNode rnode) -{ - Relation rd; - - RelationNodeCacheLookup(rnode, rd); - - if (RelationIsValid(rd)) - RelationIncrementReferenceCount(rd); - - return rd; -} - -/* - * RelationIdGetRelation - * - * Lookup a reldesc by OID; make one if not already in cache. - * - * NB: relation ref count is incremented, or set to 1 if new entry. - * Caller should eventually decrement count. (Usually, - * that happens by calling RelationClose().) - */ -Relation -RelationIdGetRelation(Oid relationId) -{ - Relation rd; - RelationBuildDescInfo buildinfo; - - /* - * first try and get a reldesc from the cache - */ - rd = RelationIdCacheGetRelation(relationId); - if (RelationIsValid(rd)) - return rd; - - /* - * no reldesc in the cache, so have RelationBuildDesc() build one and - * add it. - */ - buildinfo.infotype = INFO_RELID; - buildinfo.i.info_id = relationId; - - rd = RelationBuildDesc(buildinfo, NULL); - return rd; -} - -/* - * RelationSysNameGetRelation - * - * As above, but lookup by name; only works for system catalogs. - */ -Relation -RelationSysNameGetRelation(const char *relationName) -{ - Relation rd; - RelationBuildDescInfo buildinfo; - - /* - * first try and get a reldesc from the cache - */ - rd = RelationSysNameCacheGetRelation(relationName); - if (RelationIsValid(rd)) - return rd; - - /* - * no reldesc in the cache, so have RelationBuildDesc() build one and - * add it. - */ - buildinfo.infotype = INFO_RELNAME; - buildinfo.i.info_name = (char *) relationName; - - rd = RelationBuildDesc(buildinfo, NULL); - return rd; -} - -/* ---------------------------------------------------------------- - * cache invalidation support routines - * ---------------------------------------------------------------- - */ - -/* - * RelationClose - close an open relation - * - * Actually, we just decrement the refcount. - * - * NOTE: if compiled with -DRELCACHE_FORCE_RELEASE then relcache entries - * will be freed as soon as their refcount goes to zero. In combination - * with aset.c's CLOBBER_FREED_MEMORY option, this provides a good test - * to catch references to already-released relcache entries. It slows - * things down quite a bit, however. - */ -void -RelationClose(Relation relation) -{ - /* Note: no locking manipulations needed */ - RelationDecrementReferenceCount(relation); - -#ifdef RELCACHE_FORCE_RELEASE - if (RelationHasReferenceCountZero(relation) && !relation->rd_myxactonly) - RelationClearRelation(relation, false); -#endif -} - -#ifdef ENABLE_REINDEX_NAILED_RELATIONS -/* - * RelationReloadClassinfo - * - * This function is especially for nailed relations. - * relhasindex/relfilenode could be changed even for - * nailed relations. - */ -static void -RelationReloadClassinfo(Relation relation) -{ - RelationBuildDescInfo buildinfo; - HeapTuple pg_class_tuple; - Form_pg_class relp; - - if (!relation->rd_rel) - return; - buildinfo.infotype = INFO_RELID; - buildinfo.i.info_id = relation->rd_id; - pg_class_tuple = ScanPgRelation(buildinfo); - if (!HeapTupleIsValid(pg_class_tuple)) - { - elog(ERROR, "RelationReloadClassinfo system relation id=%d doesn't exist", relation->rd_id); - return; - } - RelationCacheDelete(relation); - relp = (Form_pg_class) GETSTRUCT(pg_class_tuple); - memcpy((char *) relation->rd_rel, (char *) relp, CLASS_TUPLE_SIZE); - relation->rd_node.relNode = relp->relfilenode; - RelationCacheInsert(relation); - heap_freetuple(pg_class_tuple); - - return; -} -#endif /* ENABLE_REINDEX_NAILED_RELATIONS */ - -/* - * RelationClearRelation - * - * Physically blow away a relation cache entry, or reset it and rebuild - * it from scratch (that is, from catalog entries). The latter path is - * usually used when we are notified of a change to an open relation - * (one with refcount > 0). However, this routine just does whichever - * it's told to do; callers must determine which they want. - */ -static void -RelationClearRelation(Relation relation, bool rebuildIt) -{ - MemoryContext oldcxt; - - /* - * Make sure smgr and lower levels close the relation's files, if they - * weren't closed already. If the relation is not getting deleted, - * the next smgr access should reopen the files automatically. This - * ensures that the low-level file access state is updated after, say, - * a vacuum truncation. - */ - if (relation->rd_fd >= 0) - { - smgrclose(DEFAULT_SMGR, relation); - relation->rd_fd = -1; - } - - /* - * Never, never ever blow away a nailed-in system relation, because - * we'd be unable to recover. - */ - if (relation->rd_isnailed) - { -#ifdef ENABLE_REINDEX_NAILED_RELATIONS - RelationReloadClassinfo(relation); -#endif /* ENABLE_REINDEX_NAILED_RELATIONS */ - return; - } - - /* - * Remove relation from hash tables - * - * Note: we might be reinserting it momentarily, but we must not have it - * visible in the hash tables until it's valid again, so don't try to - * optimize this away... - */ - oldcxt = MemoryContextSwitchTo(CacheMemoryContext); - RelationCacheDelete(relation); - MemoryContextSwitchTo(oldcxt); - - /* Clear out catcache's entries for this relation */ - CatalogCacheFlushRelation(RelationGetRelid(relation)); - - /* - * Free all the subsidiary data structures of the relcache entry. We - * cannot free rd_att if we are trying to rebuild the entry, however, - * because pointers to it may be cached in various places. The trigger - * manager might also have pointers into the trigdesc, and the rule - * manager might have pointers into the rewrite rules. So to begin - * with, we can only get rid of these fields: - */ - if (relation->rd_index) - pfree(relation->rd_index); - if (relation->rd_am) - pfree(relation->rd_am); - if (relation->rd_rel) - pfree(relation->rd_rel); - freeList(relation->rd_indexlist); - if (relation->rd_indexcxt) - MemoryContextDelete(relation->rd_indexcxt); - - /* - * If we're really done with the relcache entry, blow it away. But if - * someone is still using it, reconstruct the whole deal without - * moving the physical RelationData record (so that the someone's - * pointer is still valid). - */ - if (!rebuildIt) - { - /* ok to zap remaining substructure */ - FreeTupleDesc(relation->rd_att); - if (relation->rd_rulescxt) - MemoryContextDelete(relation->rd_rulescxt); - FreeTriggerDesc(relation->trigdesc); - pfree(relation); - } - else - { - /* - * When rebuilding an open relcache entry, must preserve ref count - * and myxactonly flag. Also attempt to preserve the tupledesc, - * rewrite rules, and trigger substructures in place. Furthermore - * we save/restore rd_nblocks (in case it is a local relation) - * *and* call RelationGetNumberOfBlocks (in case it isn't). - */ - int old_refcnt = relation->rd_refcnt; - bool old_myxactonly = relation->rd_myxactonly; - TupleDesc old_att = relation->rd_att; - RuleLock *old_rules = relation->rd_rules; - MemoryContext old_rulescxt = relation->rd_rulescxt; - TriggerDesc *old_trigdesc = relation->trigdesc; - BlockNumber old_nblocks = relation->rd_nblocks; - RelationBuildDescInfo buildinfo; - - buildinfo.infotype = INFO_RELID; - buildinfo.i.info_id = RelationGetRelid(relation); - - if (RelationBuildDesc(buildinfo, relation) != relation) - { - /* Should only get here if relation was deleted */ - FreeTupleDesc(old_att); - if (old_rulescxt) - MemoryContextDelete(old_rulescxt); - FreeTriggerDesc(old_trigdesc); - pfree(relation); - elog(ERROR, "RelationClearRelation: relation %u deleted while still in use", - buildinfo.i.info_id); - } - RelationSetReferenceCount(relation, old_refcnt); - relation->rd_myxactonly = old_myxactonly; - if (equalTupleDescs(old_att, relation->rd_att)) - { - FreeTupleDesc(relation->rd_att); - relation->rd_att = old_att; - } - else - FreeTupleDesc(old_att); - if (equalRuleLocks(old_rules, relation->rd_rules)) - { - if (relation->rd_rulescxt) - MemoryContextDelete(relation->rd_rulescxt); - relation->rd_rules = old_rules; - relation->rd_rulescxt = old_rulescxt; - } - else - { - if (old_rulescxt) - MemoryContextDelete(old_rulescxt); - } - if (equalTriggerDescs(old_trigdesc, relation->trigdesc)) - { - FreeTriggerDesc(relation->trigdesc); - relation->trigdesc = old_trigdesc; - } - else - FreeTriggerDesc(old_trigdesc); - relation->rd_nblocks = old_nblocks; - - /* - * this is kind of expensive, but I think we must do it in case - * relation has been truncated... - */ - relation->rd_nblocks = RelationGetNumberOfBlocks(relation); - } -} - -/* - * RelationFlushRelation - * - * Rebuild the relation if it is open (refcount > 0), else blow it away. - */ -static void -RelationFlushRelation(Relation relation) -{ - bool rebuildIt; - - if (relation->rd_myxactonly) - { - /* - * Local rels should always be rebuilt, not flushed; the relcache - * entry must live until RelationPurgeLocalRelation(). - */ - rebuildIt = true; - } - else - { - /* - * Nonlocal rels can be dropped from the relcache if not open. - */ - rebuildIt = !RelationHasReferenceCountZero(relation); - } - - RelationClearRelation(relation, rebuildIt); -} - -/* - * RelationForgetRelation - - * - * RelationClearRelation + if the relation is myxactonly then - * remove the relation descriptor from the newly created - * relation list. - */ -void -RelationForgetRelation(Oid rid) -{ - Relation relation; - - RelationIdCacheLookup(rid, relation); - - if (!PointerIsValid(relation)) - return; /* not in cache, nothing to do */ - - if (!RelationHasReferenceCountZero(relation)) - elog(ERROR, "RelationForgetRelation: relation %u is still open", rid); - - /* If local, remove from list */ - if (relation->rd_myxactonly) - { - List *curr; - List *prev = NIL; - - foreach(curr, newlyCreatedRelns) - { - Relation reln = lfirst(curr); - - Assert(reln != NULL && reln->rd_myxactonly); - if (RelationGetRelid(reln) == rid) - break; - prev = curr; - } - if (curr == NIL) - elog(ERROR, "Local relation %s not found in list", - RelationGetRelationName(relation)); - if (prev == NIL) - newlyCreatedRelns = lnext(newlyCreatedRelns); - else - lnext(prev) = lnext(curr); - pfree(curr); - } - - /* Unconditionally destroy the relcache entry */ - RelationClearRelation(relation, false); -} - -/* - * RelationIdInvalidateRelationCacheByRelationId - * - * This routine is invoked for SI cache flush messages. - * - * We used to skip local relations, on the grounds that they could - * not be targets of cross-backend SI update messages; but it seems - * safer to process them, so that our *own* SI update messages will - * have the same effects during CommandCounterIncrement for both - * local and nonlocal relations. - */ -void -RelationIdInvalidateRelationCacheByRelationId(Oid relationId) -{ - Relation relation; - - RelationIdCacheLookup(relationId, relation); - - if (PointerIsValid(relation)) - { - relcacheInvalsReceived++; - RelationFlushRelation(relation); - } -} - -/* - * RelationCacheInvalidate - * Blow away cached relation descriptors that have zero reference counts, - * and rebuild those with positive reference counts. - * - * This is currently used only to recover from SI message buffer overflow, - * so we do not touch transaction-local relations; they cannot be targets - * of cross-backend SI updates (and our own updates now go through a - * separate linked list that isn't limited by the SI message buffer size). - * - * We do this in two phases: the first pass deletes deletable items, and - * the second one rebuilds the rebuildable items. This is essential for - * safety, because hash_seq_search only copes with concurrent deletion of - * the element it is currently visiting. If a second SI overflow were to - * occur while we are walking the table, resulting in recursive entry to - * this routine, we could crash because the inner invocation blows away - * the entry next to be visited by the outer scan. But this way is OK, - * because (a) during the first pass we won't process any more SI messages, - * so hash_seq_search will complete safely; (b) during the second pass we - * only hold onto pointers to nondeletable entries. - */ -void -RelationCacheInvalidate(void) -{ - HASH_SEQ_STATUS status; - RelIdCacheEnt *idhentry; - Relation relation; - List *rebuildList = NIL; - List *l; - - /* Phase 1 */ - hash_seq_init(&status, RelationIdCache); - - while ((idhentry = (RelIdCacheEnt *) hash_seq_search(&status)) != NULL) - { - relation = idhentry->reldesc; - - /* Ignore xact-local relations, since they are never SI targets */ - if (relation->rd_myxactonly) - continue; - - relcacheInvalsReceived++; - - if (RelationHasReferenceCountZero(relation)) - { - /* Delete this entry immediately */ - RelationClearRelation(relation, false); - } - else - { - /* Add entry to list of stuff to rebuild in second pass */ - rebuildList = lcons(relation, rebuildList); - } - } - - /* Phase 2: rebuild the items found to need rebuild in phase 1 */ - foreach(l, rebuildList) - { - relation = (Relation) lfirst(l); - RelationClearRelation(relation, true); - } - freeList(rebuildList); -} - -/* - * RelationCacheAbort - * - * Clean up the relcache at transaction abort. - * - * What we need to do here is reset relcache entry ref counts to - * their normal not-in-a-transaction state. A ref count may be - * too high because some routine was exited by elog() between - * incrementing and decrementing the count. - * - * XXX Maybe we should do this at transaction commit, too, in case - * someone forgets to decrement a refcount in a non-error path? - */ -void -RelationCacheAbort(void) -{ - HASH_SEQ_STATUS status; - RelIdCacheEnt *idhentry; - - hash_seq_init(&status, RelationIdCache); - - while ((idhentry = (RelIdCacheEnt *) hash_seq_search(&status)) != NULL) - { - Relation relation = idhentry->reldesc; - - if (relation->rd_isnailed) - RelationSetReferenceCount(relation, 1); - else - RelationSetReferenceCount(relation, 0); - } -} - -/* - * RelationBuildLocalRelation - * Build a relcache entry for an about-to-be-created relation, - * and enter it into the relcache. - */ -Relation -RelationBuildLocalRelation(const char *relname, - Oid relnamespace, - TupleDesc tupDesc, - Oid relid, Oid dbid, - RelFileNode rnode, - bool nailit) -{ - Relation rel; - MemoryContext oldcxt; - int natts = tupDesc->natts; - int i; - - AssertArg(natts > 0); - - /* - * switch to the cache context to create the relcache entry. - */ - if (!CacheMemoryContext) - CreateCacheMemoryContext(); - - oldcxt = MemoryContextSwitchTo(CacheMemoryContext); - - /* - * allocate a new relation descriptor. - */ - rel = (Relation) palloc(sizeof(RelationData)); - MemSet((char *) rel, 0, sizeof(RelationData)); - rel->rd_targblock = InvalidBlockNumber; - - /* make sure relation is marked as having no open file yet */ - rel->rd_fd = -1; - - RelationSetReferenceCount(rel, 1); - - /* - * nail the reldesc if this is a bootstrap create reln and we may need - * it in the cache later on in the bootstrap process so we don't ever - * want it kicked out. e.g. pg_attribute!!! - */ - if (nailit) - rel->rd_isnailed = true; - - /* - * create a new tuple descriptor from the one passed in. We do this - * partly to copy it into the cache context, and partly because the - * new relation can't have any defaults or constraints yet; they - * have to be added in later steps, because they require additions - * to multiple system catalogs. We can copy attnotnull constraints - * here, however. - */ - rel->rd_att = CreateTupleDescCopy(tupDesc); - for (i = 0; i < natts; i++) - rel->rd_att->attrs[i]->attnotnull = tupDesc->attrs[i]->attnotnull; - - /* - * initialize relation tuple form (caller may add/override data later) - */ - rel->rd_rel = (Form_pg_class) palloc(CLASS_TUPLE_SIZE); - MemSet((char *) rel->rd_rel, 0, CLASS_TUPLE_SIZE); - - namestrcpy(&rel->rd_rel->relname, relname); - rel->rd_rel->relnamespace = relnamespace; - - rel->rd_rel->relkind = RELKIND_UNCATALOGED; - rel->rd_rel->relhasoids = true; - rel->rd_rel->relnatts = natts; - rel->rd_rel->reltype = InvalidOid; - - /* - * Insert relation physical and logical identifiers (OIDs) into the - * right places. - */ - rel->rd_rel->relisshared = (dbid == InvalidOid); - - RelationGetRelid(rel) = relid; - - for (i = 0; i < natts; i++) - rel->rd_att->attrs[i]->attrelid = relid; - - rel->rd_node = rnode; - rel->rd_rel->relfilenode = rnode.relNode; - - RelationInitLockInfo(rel); /* see lmgr.c */ - - /* - * Okay to insert into the relcache hash tables. - */ - RelationCacheInsert(rel); - - /* - * we've just created the relation. It is invisible to anyone else - * before the transaction is committed. Setting rd_myxactonly allows - * us to use the local buffer manager for select/insert/etc before the - * end of transaction. (We also need to keep track of relations - * created during a transaction and do the necessary clean up at the - * end of the transaction.) - ay 3/95 - */ - rel->rd_myxactonly = true; - newlyCreatedRelns = lcons(rel, newlyCreatedRelns); - - /* - * done building relcache entry. - */ - MemoryContextSwitchTo(oldcxt); - - return rel; -} - -/* - * RelationPurgeLocalRelation - - * find all the Relation descriptors marked rd_myxactonly and reset them. - * This should be called at the end of a transaction (commit/abort) when - * the "local" relations will become visible to others and the multi-user - * buffer pool should be used. - */ -void -RelationPurgeLocalRelation(bool xactCommitted) -{ - while (newlyCreatedRelns) - { - List *l = newlyCreatedRelns; - Relation reln = lfirst(l); - - newlyCreatedRelns = lnext(newlyCreatedRelns); - pfree(l); - - Assert(reln != NULL && reln->rd_myxactonly); - - reln->rd_myxactonly = false; /* mark it not on list anymore */ - - /* - * XXX while we clearly must throw out new Relation entries at - * xact abort, it's not clear why we need to do it at commit. - * Could this be improved? - */ - if (!IsBootstrapProcessingMode()) - RelationClearRelation(reln, false); - } -} - -/* - * RelationCacheInitialize - * - * This initializes the relation descriptor cache. At the time - * that this is invoked, we can't do database access yet (mainly - * because the transaction subsystem is not up), so we can't get - * "real" info. However it's okay to read the pg_internal.init - * cache file, if one is available. Otherwise we make phony - * entries for the minimum set of nailed-in-cache relations. - */ - -#define INITRELCACHESIZE 400 - -void -RelationCacheInitialize(void) -{ - MemoryContext oldcxt; - HASHCTL ctl; - - /* - * switch to cache memory context - */ - if (!CacheMemoryContext) - CreateCacheMemoryContext(); - - oldcxt = MemoryContextSwitchTo(CacheMemoryContext); - - /* - * create hashtables that index the relcache - */ - MemSet(&ctl, 0, sizeof(ctl)); - ctl.keysize = sizeof(NameData); - ctl.entrysize = sizeof(RelNameCacheEnt); - RelationSysNameCache = hash_create("Relcache by name", INITRELCACHESIZE, - &ctl, HASH_ELEM); - - ctl.keysize = sizeof(Oid); - ctl.entrysize = sizeof(RelIdCacheEnt); - ctl.hash = tag_hash; - RelationIdCache = hash_create("Relcache by OID", INITRELCACHESIZE, - &ctl, HASH_ELEM | HASH_FUNCTION); - - ctl.keysize = sizeof(RelFileNode); - ctl.entrysize = sizeof(RelNodeCacheEnt); - ctl.hash = tag_hash; - RelationNodeCache = hash_create("Relcache by rnode", INITRELCACHESIZE, - &ctl, HASH_ELEM | HASH_FUNCTION); - - /* - * Try to load the relcache cache file. If successful, we're done - * for now. Otherwise, initialize the cache with pre-made descriptors - * for the critical "nailed-in" system catalogs. - */ - if (IsBootstrapProcessingMode() || - ! load_relcache_init_file()) - { - formrdesc(RelationRelationName, - Natts_pg_class, Desc_pg_class); - formrdesc(AttributeRelationName, - Natts_pg_attribute, Desc_pg_attribute); - formrdesc(ProcedureRelationName, - Natts_pg_proc, Desc_pg_proc); - formrdesc(TypeRelationName, - Natts_pg_type, Desc_pg_type); - -#define NUM_CRITICAL_RELS 4 /* fix if you change list above */ - } - - MemoryContextSwitchTo(oldcxt); -} - -/* - * RelationCacheInitializePhase2 - * - * This is called as soon as the catcache and transaction system - * are functional. At this point we can actually read data from - * the system catalogs. Update the relcache entries made during - * RelationCacheInitialize, and make sure we have entries for the - * critical system indexes. - */ -void -RelationCacheInitializePhase2(void) -{ - HASH_SEQ_STATUS status; - RelIdCacheEnt *idhentry; - - if (IsBootstrapProcessingMode()) - return; - - /* - * If we didn't get the critical system indexes loaded into relcache, - * do so now. These are critical because the catcache depends on them - * for catcache fetches that are done during relcache load. Thus, we - * have an infinite-recursion problem. We can break the recursion - * by doing heapscans instead of indexscans at certain key spots. - * To avoid hobbling performance, we only want to do that until we - * have the critical indexes loaded into relcache. Thus, the flag - * criticalRelcachesBuilt is used to decide whether to do heapscan - * or indexscan at the key spots, and we set it true after we've loaded - * the critical indexes. - * - * The critical indexes are marked as "nailed in cache", partly to make - * it easy for load_relcache_init_file to count them, but mainly - * because we cannot flush and rebuild them once we've set - * criticalRelcachesBuilt to true. (NOTE: perhaps it would be possible - * to reload them by temporarily setting criticalRelcachesBuilt to - * false again. For now, though, we just nail 'em in.) - */ - if (! criticalRelcachesBuilt) - { - RelationBuildDescInfo buildinfo; - Relation ird; - -#define LOAD_CRIT_INDEX(indname) \ - do { \ - buildinfo.infotype = INFO_RELNAME; \ - buildinfo.i.info_name = (indname); \ - ird = RelationBuildDesc(buildinfo, NULL); \ - ird->rd_isnailed = true; \ - RelationSetReferenceCount(ird, 1); \ - } while (0) - - LOAD_CRIT_INDEX(ClassNameNspIndex); - LOAD_CRIT_INDEX(ClassOidIndex); - LOAD_CRIT_INDEX(AttributeRelidNumIndex); - LOAD_CRIT_INDEX(IndexRelidIndex); - LOAD_CRIT_INDEX(AccessMethodStrategyIndex); - LOAD_CRIT_INDEX(AccessMethodProcedureIndex); - LOAD_CRIT_INDEX(OperatorOidIndex); - -#define NUM_CRITICAL_INDEXES 7 /* fix if you change list above */ - - criticalRelcachesBuilt = true; - } - - /* - * Now, scan all the relcache entries and update anything that might - * be wrong in the results from formrdesc or the relcache cache file. - * If we faked up relcache entries using formrdesc, then read - * the real pg_class rows and replace the fake entries with them. - * Also, if any of the relcache entries have rules or triggers, - * load that info the hard way since it isn't recorded in the cache file. - */ - hash_seq_init(&status, RelationIdCache); - - while ((idhentry = (RelIdCacheEnt *) hash_seq_search(&status)) != NULL) - { - Relation relation = idhentry->reldesc; - - /* - * If it's a faked-up entry, read the real pg_class tuple. - */ - if (needNewCacheFile && relation->rd_isnailed) - { - HeapTuple htup; - Form_pg_class relp; - - htup = SearchSysCache(RELOID, - ObjectIdGetDatum(RelationGetRelid(relation)), - 0, 0, 0); - if (!HeapTupleIsValid(htup)) - elog(FATAL, "RelationCacheInitializePhase2: no pg_class entry for %s", - RelationGetRelationName(relation)); - relp = (Form_pg_class) GETSTRUCT(htup); - /* - * Copy tuple to relation->rd_rel. (See notes in - * AllocateRelationDesc()) - */ - Assert(relation->rd_rel != NULL); - memcpy((char *) relation->rd_rel, (char *) relp, CLASS_TUPLE_SIZE); - - ReleaseSysCache(htup); - } - - /* - * Fix data that isn't saved in relcache cache file. - */ - if (relation->rd_rel->relhasrules && relation->rd_rules == NULL) - RelationBuildRuleLock(relation); - if (relation->rd_rel->reltriggers > 0 && relation->trigdesc == NULL) - RelationBuildTriggers(relation); - } -} - -/* - * RelationCacheInitializePhase3 - * - * Final step of relcache initialization: write out a new relcache - * cache file if one is needed. - */ -void -RelationCacheInitializePhase3(void) -{ - if (IsBootstrapProcessingMode()) - return; - - if (needNewCacheFile) - { - /* - * Force all the catcaches to finish initializing and thereby - * open the catalogs and indexes they use. This will preload - * the relcache with entries for all the most important system - * catalogs and indexes, so that the init file will be most - * useful for future backends. - */ - InitCatalogCachePhase2(); - - /* now write the file */ - write_relcache_init_file(); - } -} - - -/* used by XLogInitCache */ -void CreateDummyCaches(void); -void DestroyDummyCaches(void); - -void -CreateDummyCaches(void) -{ - MemoryContext oldcxt; - HASHCTL ctl; - - if (!CacheMemoryContext) - CreateCacheMemoryContext(); - - oldcxt = MemoryContextSwitchTo(CacheMemoryContext); - - MemSet(&ctl, 0, sizeof(ctl)); - ctl.keysize = sizeof(NameData); - ctl.entrysize = sizeof(RelNameCacheEnt); - RelationSysNameCache = hash_create("Relcache by name", INITRELCACHESIZE, - &ctl, HASH_ELEM); - - ctl.keysize = sizeof(Oid); - ctl.entrysize = sizeof(RelIdCacheEnt); - ctl.hash = tag_hash; - RelationIdCache = hash_create("Relcache by OID", INITRELCACHESIZE, - &ctl, HASH_ELEM | HASH_FUNCTION); - - ctl.keysize = sizeof(RelFileNode); - ctl.entrysize = sizeof(RelNodeCacheEnt); - ctl.hash = tag_hash; - RelationNodeCache = hash_create("Relcache by rnode", INITRELCACHESIZE, - &ctl, HASH_ELEM | HASH_FUNCTION); - - MemoryContextSwitchTo(oldcxt); -} - -void -DestroyDummyCaches(void) -{ - MemoryContext oldcxt; - - if (!CacheMemoryContext) - return; - - oldcxt = MemoryContextSwitchTo(CacheMemoryContext); - - if (RelationIdCache) - hash_destroy(RelationIdCache); - if (RelationSysNameCache) - hash_destroy(RelationSysNameCache); - if (RelationNodeCache) - hash_destroy(RelationNodeCache); - - RelationIdCache = RelationSysNameCache = RelationNodeCache = NULL; - - MemoryContextSwitchTo(oldcxt); -} - -static void -AttrDefaultFetch(Relation relation) -{ - AttrDefault *attrdef = relation->rd_att->constr->defval; - int ndef = relation->rd_att->constr->num_defval; - Relation adrel; - SysScanDesc adscan; - ScanKeyData skey; - HeapTuple htup; - Datum val; - bool isnull; - int found; - int i; - - ScanKeyEntryInitialize(&skey, - (bits16) 0x0, - (AttrNumber) Anum_pg_attrdef_adrelid, - (RegProcedure) F_OIDEQ, - ObjectIdGetDatum(RelationGetRelid(relation))); - - adrel = heap_openr(AttrDefaultRelationName, AccessShareLock); - adscan = systable_beginscan(adrel, AttrDefaultIndex, true, - SnapshotNow, - 1, &skey); - found = 0; - - while (HeapTupleIsValid(htup = systable_getnext(adscan))) - { - Form_pg_attrdef adform = (Form_pg_attrdef) GETSTRUCT(htup); - - found++; - for (i = 0; i < ndef; i++) - { - if (adform->adnum != attrdef[i].adnum) - continue; - if (attrdef[i].adbin != NULL) - elog(WARNING, "AttrDefaultFetch: second record found for attr %s in rel %s", - NameStr(relation->rd_att->attrs[adform->adnum - 1]->attname), - RelationGetRelationName(relation)); - - val = fastgetattr(htup, - Anum_pg_attrdef_adbin, - adrel->rd_att, &isnull); - if (isnull) - elog(WARNING, "AttrDefaultFetch: adbin IS NULL for attr %s in rel %s", - NameStr(relation->rd_att->attrs[adform->adnum - 1]->attname), - RelationGetRelationName(relation)); - else - attrdef[i].adbin = MemoryContextStrdup(CacheMemoryContext, - DatumGetCString(DirectFunctionCall1(textout, - val))); - break; - } - - if (i >= ndef) - elog(WARNING, "AttrDefaultFetch: unexpected record found for attr %d in rel %s", - adform->adnum, - RelationGetRelationName(relation)); - } - - systable_endscan(adscan); - heap_close(adrel, AccessShareLock); - - if (found != ndef) - elog(WARNING, "AttrDefaultFetch: %d record(s) not found for rel %s", - ndef - found, RelationGetRelationName(relation)); -} - -static void -RelCheckFetch(Relation relation) -{ - ConstrCheck *check = relation->rd_att->constr->check; - int ncheck = relation->rd_att->constr->num_check; - Relation rcrel; - SysScanDesc rcscan; - ScanKeyData skey; - HeapTuple htup; - Name rcname; - Datum val; - bool isnull; - int found; - - ScanKeyEntryInitialize(&skey, - (bits16) 0x0, - (AttrNumber) Anum_pg_relcheck_rcrelid, - (RegProcedure) F_OIDEQ, - ObjectIdGetDatum(RelationGetRelid(relation))); - - rcrel = heap_openr(RelCheckRelationName, AccessShareLock); - rcscan = systable_beginscan(rcrel, RelCheckIndex, true, - SnapshotNow, - 1, &skey); - found = 0; - - while (HeapTupleIsValid(htup = systable_getnext(rcscan))) - { - if (found == ncheck) - elog(ERROR, "RelCheckFetch: unexpected record found for rel %s", - RelationGetRelationName(relation)); - - rcname = (Name) fastgetattr(htup, - Anum_pg_relcheck_rcname, - rcrel->rd_att, &isnull); - if (isnull) - elog(ERROR, "RelCheckFetch: rcname IS NULL for rel %s", - RelationGetRelationName(relation)); - check[found].ccname = MemoryContextStrdup(CacheMemoryContext, - NameStr(*rcname)); - val = fastgetattr(htup, - Anum_pg_relcheck_rcbin, - rcrel->rd_att, &isnull); - if (isnull) - elog(ERROR, "RelCheckFetch: rcbin IS NULL for rel %s", - RelationGetRelationName(relation)); - check[found].ccbin = MemoryContextStrdup(CacheMemoryContext, - DatumGetCString(DirectFunctionCall1(textout, - val))); - found++; - } - - systable_endscan(rcscan); - heap_close(rcrel, AccessShareLock); - - if (found != ncheck) - elog(ERROR, "RelCheckFetch: %d record(s) not found for rel %s", - ncheck - found, RelationGetRelationName(relation)); -} - -/* - * RelationGetIndexList -- get a list of OIDs of indexes on this relation - * - * The index list is created only if someone requests it. We scan pg_index - * to find relevant indexes, and add the list to the relcache entry so that - * we won't have to compute it again. Note that shared cache inval of a - * relcache entry will delete the old list and set rd_indexfound to false, - * so that we must recompute the index list on next request. This handles - * creation or deletion of an index. - * - * The returned list is guaranteed to be sorted in order by OID. This is - * needed by the executor, since for index types that we obtain exclusive - * locks on when updating the index, all backends must lock the indexes in - * the same order or we will get deadlocks (see ExecOpenIndices()). Any - * consistent ordering would do, but ordering by OID is easy. - * - * Since shared cache inval causes the relcache's copy of the list to go away, - * we return a copy of the list palloc'd in the caller's context. The caller - * may freeList() the returned list after scanning it. This is necessary - * since the caller will typically be doing syscache lookups on the relevant - * indexes, and syscache lookup could cause SI messages to be processed! - */ -List * -RelationGetIndexList(Relation relation) -{ - Relation indrel; - SysScanDesc indscan; - ScanKeyData skey; - HeapTuple htup; - List *result; - MemoryContext oldcxt; - - /* Quick exit if we already computed the list. */ - if (relation->rd_indexfound) - return listCopy(relation->rd_indexlist); - - /* - * We build the list we intend to return (in the caller's context) - * while doing the scan. After successfully completing the scan, we - * copy that list into the relcache entry. This avoids cache-context - * memory leakage if we get some sort of error partway through. - */ - result = NIL; - - /* Prepare to scan pg_index for entries having indrelid = this rel. */ - ScanKeyEntryInitialize(&skey, - (bits16) 0x0, - (AttrNumber) Anum_pg_index_indrelid, - (RegProcedure) F_OIDEQ, - ObjectIdGetDatum(RelationGetRelid(relation))); - - indrel = heap_openr(IndexRelationName, AccessShareLock); - indscan = systable_beginscan(indrel, IndexIndrelidIndex, true, - SnapshotNow, - 1, &skey); - - while (HeapTupleIsValid(htup = systable_getnext(indscan))) - { - Form_pg_index index = (Form_pg_index) GETSTRUCT(htup); - - result = insert_ordered_oid(result, index->indexrelid); - } - - systable_endscan(indscan); - heap_close(indrel, AccessShareLock); - - /* Now save a copy of the completed list in the relcache entry. */ - oldcxt = MemoryContextSwitchTo(CacheMemoryContext); - relation->rd_indexlist = listCopy(result); - relation->rd_indexfound = true; - MemoryContextSwitchTo(oldcxt); - - return result; -} - -/* - * insert_ordered_oid - * Insert a new Oid into a sorted list of Oids, preserving ordering - * - * Building the ordered list this way is O(N^2), but with a pretty small - * constant, so for the number of entries we expect it will probably be - * faster than trying to apply qsort(). Most tables don't have very many - * indexes... - */ -static List * -insert_ordered_oid(List *list, Oid datum) -{ - List *l; - - /* Does the datum belong at the front? */ - if (list == NIL || datum < (Oid) lfirsti(list)) - return lconsi(datum, list); - /* No, so find the entry it belongs after */ - l = list; - for (;;) - { - List *n = lnext(l); - - if (n == NIL || datum < (Oid) lfirsti(n)) - break; /* it belongs before n */ - l = n; - } - /* Insert datum into list after item l */ - lnext(l) = lconsi(datum, lnext(l)); - return list; -} - - -/* - * load_relcache_init_file, write_relcache_init_file - * - * In late 1992, we started regularly having databases with more than - * a thousand classes in them. With this number of classes, it became - * critical to do indexed lookups on the system catalogs. - * - * Bootstrapping these lookups is very hard. We want to be able to - * use an index on pg_attribute, for example, but in order to do so, - * we must have read pg_attribute for the attributes in the index, - * which implies that we need to use the index. - * - * In order to get around the problem, we do the following: - * - * + When the database system is initialized (at initdb time), we - * don't use indexes. We do sequential scans. - * - * + When the backend is started up in normal mode, we load an image - * of the appropriate relation descriptors, in internal format, - * from an initialization file in the data/base/... directory. - * - * + If the initialization file isn't there, then we create the - * relation descriptors using sequential scans and write 'em to - * the initialization file for use by subsequent backends. - * - * We could dispense with the initialization file and just build the - * critical reldescs the hard way on every backend startup, but that - * slows down backend startup noticeably. - * - * We can in fact go further, and save more relcache entries than - * just the ones that are absolutely critical; this allows us to speed - * up backend startup by not having to build such entries the hard way. - * Presently, all the catalog and index entries that are referred to - * by catcaches are stored in the initialization file. - * - * As of v6.5, vacuum.c deletes the initialization file at completion - * of a VACUUM, so that it will be rebuilt at the next backend startup. - * This ensures that vacuum-collected stats for the system catalogs - * and indexes will be seen by backends started later. - */ - -/* - * load_relcache_init_file -- attempt to load cache from the init file - * - * If successful, return TRUE and set criticalRelcachesBuilt to true. - * If not successful, return FALSE and set needNewCacheFile to true. - * - * NOTE: we assume we are already switched into CacheMemoryContext. - */ -static bool -load_relcache_init_file(void) -{ - FILE *fp; - char initfilename[MAXPGPATH]; - Relation *rels; - int relno, - num_rels, - max_rels, - nailed_rels, - nailed_indexes; - int i; - - snprintf(initfilename, sizeof(initfilename), "%s/%s", - DatabasePath, RELCACHE_INIT_FILENAME); - - fp = AllocateFile(initfilename, PG_BINARY_R); - if (fp == NULL) - { - needNewCacheFile = true; - return false; - } - - /* - * Read the index relcache entries from the file. Note we will not - * enter any of them into the cache if the read fails partway through; - * this helps to guard against broken init files. - */ - max_rels = 100; - rels = (Relation *) palloc(max_rels * sizeof(Relation)); - num_rels = 0; - nailed_rels = nailed_indexes = 0; - initFileRelationIds = NIL; - - for (relno = 0; ; relno++) - { - Size len; - size_t nread; - Relation rel; - Form_pg_class relform; - - /* first read the relation descriptor length */ - if ((nread = fread(&len, 1, sizeof(len), fp)) != sizeof(len)) - { - if (nread == 0) - break; /* end of file */ - goto read_failed; - } - - /* safety check for incompatible relcache layout */ - if (len != sizeof(RelationData)) - goto read_failed; - - /* allocate another relcache header */ - if (num_rels >= max_rels) - { - max_rels *= 2; - rels = (Relation *) repalloc(rels, max_rels * sizeof(Relation)); - } - - rel = rels[num_rels++] = (Relation) palloc(len); - - /* then, read the Relation structure */ - if ((nread = fread(rel, 1, len, fp)) != len) - goto read_failed; - - /* next read the relation tuple form */ - if ((nread = fread(&len, 1, sizeof(len), fp)) != sizeof(len)) - goto read_failed; - - relform = (Form_pg_class) palloc(len); - if ((nread = fread(relform, 1, len, fp)) != len) - goto read_failed; - - rel->rd_rel = relform; - - /* initialize attribute tuple forms */ - rel->rd_att = CreateTemplateTupleDesc(relform->relnatts); - - /* next read all the attribute tuple form data entries */ - for (i = 0; i < relform->relnatts; i++) - { - if ((nread = fread(&len, 1, sizeof(len), fp)) != sizeof(len)) - goto read_failed; - - rel->rd_att->attrs[i] = (Form_pg_attribute) palloc(len); - - if ((nread = fread(rel->rd_att->attrs[i], 1, len, fp)) != len) - goto read_failed; - } - - /* If it's an index, there's more to do */ - if (rel->rd_rel->relkind == RELKIND_INDEX) - { - Form_pg_am am; - MemoryContext indexcxt; - IndexStrategy strat; - Oid *operator; - RegProcedure *support; - int nstrategies, - nsupport; - - /* Count nailed indexes to ensure we have 'em all */ - if (rel->rd_isnailed) - nailed_indexes++; - - /* next, read the pg_index tuple form */ - if ((nread = fread(&len, 1, sizeof(len), fp)) != sizeof(len)) - goto read_failed; - - rel->rd_index = (Form_pg_index) palloc(len); - if ((nread = fread(rel->rd_index, 1, len, fp)) != len) - goto read_failed; - - /* next, read the access method tuple form */ - if ((nread = fread(&len, 1, sizeof(len), fp)) != sizeof(len)) - goto read_failed; - - am = (Form_pg_am) palloc(len); - if ((nread = fread(am, 1, len, fp)) != len) - goto read_failed; - rel->rd_am = am; - - /* - * prepare index info context --- parameters should match - * RelationInitIndexAccessInfo - */ - indexcxt = AllocSetContextCreate(CacheMemoryContext, - RelationGetRelationName(rel), - 0, /* minsize */ - 512, /* initsize */ - 1024); /* maxsize */ - rel->rd_indexcxt = indexcxt; - - /* next, read the index strategy map */ - if ((nread = fread(&len, 1, sizeof(len), fp)) != sizeof(len)) - goto read_failed; - - strat = (IndexStrategy) MemoryContextAlloc(indexcxt, len); - if ((nread = fread(strat, 1, len, fp)) != len) - goto read_failed; - - /* have to invalidate any FmgrInfo data in the strategy maps */ - nstrategies = am->amstrategies * relform->relnatts; - for (i = 0; i < nstrategies; i++) - strat->strategyMapData[i].entry[0].sk_func.fn_oid = InvalidOid; - - rel->rd_istrat = strat; - - /* next, read the vector of operator OIDs */ - if ((nread = fread(&len, 1, sizeof(len), fp)) != sizeof(len)) - goto read_failed; - - operator = (Oid *) MemoryContextAlloc(indexcxt, len); - if ((nread = fread(operator, 1, len, fp)) != len) - goto read_failed; - - rel->rd_operator = operator; - - /* finally, read the vector of support procedures */ - if ((nread = fread(&len, 1, sizeof(len), fp)) != sizeof(len)) - goto read_failed; - support = (RegProcedure *) MemoryContextAlloc(indexcxt, len); - if ((nread = fread(support, 1, len, fp)) != len) - goto read_failed; - - rel->rd_support = support; - - /* add a zeroed support-fmgr-info vector */ - nsupport = relform->relnatts * am->amsupport; - rel->rd_supportinfo = (FmgrInfo *) - MemoryContextAlloc(indexcxt, nsupport * sizeof(FmgrInfo)); - MemSet(rel->rd_supportinfo, 0, nsupport * sizeof(FmgrInfo)); - } - else - { - /* Count nailed rels to ensure we have 'em all */ - if (rel->rd_isnailed) - nailed_rels++; - - Assert(rel->rd_index == NULL); - Assert(rel->rd_am == NULL); - Assert(rel->rd_indexcxt == NULL); - Assert(rel->rd_istrat == NULL); - Assert(rel->rd_operator == NULL); - Assert(rel->rd_support == NULL); - Assert(rel->rd_supportinfo == NULL); - } - - /* - * Rules and triggers are not saved (mainly because the internal - * format is complex and subject to change). They must be rebuilt - * if needed by RelationCacheInitializePhase2. This is not expected - * to be a big performance hit since few system catalogs have such. - */ - rel->rd_rules = NULL; - rel->rd_rulescxt = NULL; - rel->trigdesc = NULL; - - /* - * Reset transient-state fields in the relcache entry - */ - rel->rd_fd = -1; - rel->rd_targblock = InvalidBlockNumber; - if (rel->rd_isnailed) - RelationSetReferenceCount(rel, 1); - else - RelationSetReferenceCount(rel, 0); - rel->rd_indexfound = false; - rel->rd_indexlist = NIL; - MemSet(&rel->pgstat_info, 0, sizeof(rel->pgstat_info)); - - /* - * Make sure database ID is correct. This is needed in case the - * pg_internal.init file was copied from some other database by - * CREATE DATABASE. - */ - if (rel->rd_rel->relisshared) - rel->rd_node.tblNode = InvalidOid; - else - rel->rd_node.tblNode = MyDatabaseId; - - RelationInitLockInfo(rel); - } - - /* - * We reached the end of the init file without apparent problem. - * Did we get the right number of nailed items? (This is a useful - * crosscheck in case the set of critical rels or indexes changes.) - */ - if (nailed_rels != NUM_CRITICAL_RELS || - nailed_indexes != NUM_CRITICAL_INDEXES) - goto read_failed; - - /* - * OK, all appears well. - * - * Now insert all the new relcache entries into the cache. - */ - for (relno = 0; relno < num_rels; relno++) - { - RelationCacheInsert(rels[relno]); - /* also make a list of their OIDs, for RelationIdIsInInitFile */ - initFileRelationIds = lconsi((int) RelationGetRelid(rels[relno]), - initFileRelationIds); - } - - pfree(rels); - FreeFile(fp); - - criticalRelcachesBuilt = true; - return true; - - /* - * init file is broken, so do it the hard way. We don't bother - * trying to free the clutter we just allocated; it's not in the - * relcache so it won't hurt. - */ -read_failed: - pfree(rels); - FreeFile(fp); - - needNewCacheFile = true; - return false; -} - -/* - * Write out a new initialization file with the current contents - * of the relcache. - */ -static void -write_relcache_init_file(void) -{ - FILE *fp; - char tempfilename[MAXPGPATH]; - char finalfilename[MAXPGPATH]; - HASH_SEQ_STATUS status; - RelIdCacheEnt *idhentry; - MemoryContext oldcxt; - int i; - - /* - * We must write a temporary file and rename it into place. Otherwise, - * another backend starting at about the same time might crash trying - * to read the partially-complete file. - */ - snprintf(tempfilename, sizeof(tempfilename), "%s/%s.%d", - DatabasePath, RELCACHE_INIT_FILENAME, MyProcPid); - snprintf(finalfilename, sizeof(finalfilename), "%s/%s", - DatabasePath, RELCACHE_INIT_FILENAME); - - unlink(tempfilename); /* in case it exists w/wrong permissions */ - - fp = AllocateFile(tempfilename, PG_BINARY_W); - if (fp == NULL) - { - /* - * We used to consider this a fatal error, but we might as well - * continue with backend startup ... - */ - elog(WARNING, "Cannot create init file %s: %m\n\tContinuing anyway, but there's something wrong.", tempfilename); - return; - } - - /* - * Write all the reldescs (in no particular order). - */ - hash_seq_init(&status, RelationIdCache); - - initFileRelationIds = NIL; - - while ((idhentry = (RelIdCacheEnt *) hash_seq_search(&status)) != NULL) - { - Relation rel = idhentry->reldesc; - Form_pg_class relform = rel->rd_rel; - Size len; - - /* - * first write the relcache entry proper - */ - len = sizeof(RelationData); - - /* first, write the relation descriptor length */ - if (fwrite(&len, 1, sizeof(len), fp) != sizeof(len)) - elog(FATAL, "cannot write init file -- descriptor length"); - - /* next, write out the Relation structure */ - if (fwrite(rel, 1, len, fp) != len) - elog(FATAL, "cannot write init file -- reldesc"); - - /* next write the relation tuple form */ - len = sizeof(FormData_pg_class); - if (fwrite(&len, 1, sizeof(len), fp) != sizeof(len)) - elog(FATAL, "cannot write init file -- relation tuple form length"); - - if (fwrite(relform, 1, len, fp) != len) - elog(FATAL, "cannot write init file -- relation tuple form"); - - /* next, do all the attribute tuple form data entries */ - for (i = 0; i < relform->relnatts; i++) - { - len = ATTRIBUTE_TUPLE_SIZE; - if (fwrite(&len, 1, sizeof(len), fp) != sizeof(len)) - elog(FATAL, "cannot write init file -- length of attdesc %d", i); - if (fwrite(rel->rd_att->attrs[i], 1, len, fp) != len) - elog(FATAL, "cannot write init file -- attdesc %d", i); - } - - /* If it's an index, there's more to do */ - if (rel->rd_rel->relkind == RELKIND_INDEX) - { - Form_pg_am am = rel->rd_am; - HeapTuple tuple; - - /* - * We need to write the index tuple form, but this is a bit - * tricky since it's a variable-length struct. Rather than - * hoping to intuit the length, fetch the pg_index tuple - * afresh using the syscache, and write that. - */ - tuple = SearchSysCache(INDEXRELID, - ObjectIdGetDatum(RelationGetRelid(rel)), - 0, 0, 0); - if (!HeapTupleIsValid(tuple)) - elog(ERROR, "write_relcache_init_file: no pg_index entry for index %u", - RelationGetRelid(rel)); - len = tuple->t_len - tuple->t_data->t_hoff; - if (fwrite(&len, 1, sizeof(len), fp) != sizeof(len)) - elog(FATAL, "cannot write init file -- index tuple form length"); - if (fwrite(GETSTRUCT(tuple), 1, len, fp) != len) - elog(FATAL, "cannot write init file -- index tuple form"); - ReleaseSysCache(tuple); - - /* next, write the access method tuple form */ - len = sizeof(FormData_pg_am); - if (fwrite(&len, 1, sizeof(len), fp) != sizeof(len)) - elog(FATAL, "cannot write init file -- am tuple form length"); - - if (fwrite(am, 1, len, fp) != len) - elog(FATAL, "cannot write init file -- am tuple form"); - - /* next, write the index strategy map */ - len = AttributeNumberGetIndexStrategySize(relform->relnatts, - am->amstrategies); - if (fwrite(&len, 1, sizeof(len), fp) != sizeof(len)) - elog(FATAL, "cannot write init file -- strategy map length"); - - if (fwrite(rel->rd_istrat, 1, len, fp) != len) - elog(FATAL, "cannot write init file -- strategy map"); - - /* next, write the vector of operator OIDs */ - len = relform->relnatts * (am->amstrategies * sizeof(Oid)); - if (fwrite(&len, 1, sizeof(len), fp) != sizeof(len)) - elog(FATAL, "cannot write init file -- operator vector length"); - - if (fwrite(rel->rd_operator, 1, len, fp) != len) - elog(FATAL, "cannot write init file -- operator vector"); - - /* finally, write the vector of support procedures */ - len = relform->relnatts * (am->amsupport * sizeof(RegProcedure)); - if (fwrite(&len, 1, sizeof(len), fp) != sizeof(len)) - elog(FATAL, "cannot write init file -- support vector length"); - - if (fwrite(rel->rd_support, 1, len, fp) != len) - elog(FATAL, "cannot write init file -- support vector"); - } - - /* also make a list of their OIDs, for RelationIdIsInInitFile */ - oldcxt = MemoryContextSwitchTo(CacheMemoryContext); - initFileRelationIds = lconsi((int) RelationGetRelid(rel), - initFileRelationIds); - MemoryContextSwitchTo(oldcxt); - } - - FreeFile(fp); - - /* - * Now we have to check whether the data we've so painstakingly - * accumulated is already obsolete due to someone else's just-committed - * catalog changes. If so, we just delete the temp file and leave it - * to the next backend to try again. (Our own relcache entries will be - * updated by SI message processing, but we can't be sure whether what - * we wrote out was up-to-date.) - * - * This mustn't run concurrently with RelationCacheInitFileInvalidate, - * so grab a serialization lock for the duration. - */ - LWLockAcquire(RelCacheInitLock, LW_EXCLUSIVE); - - /* Make sure we have seen all incoming SI messages */ - AcceptInvalidationMessages(); - - /* - * If we have received any SI relcache invals since backend start, - * assume we may have written out-of-date data. - */ - if (relcacheInvalsReceived == 0L) - { - /* - * OK, rename the temp file to its final name, deleting any - * previously-existing init file. - * - * Note: a failure here is possible under Cygwin, if some other - * backend is holding open an unlinked-but-not-yet-gone init file. - * So treat this as a noncritical failure. - */ - if (rename(tempfilename, finalfilename) < 0) - { - elog(WARNING, "Cannot rename init file %s to %s: %m\n\tContinuing anyway, but there's something wrong.", tempfilename, finalfilename); - /* - * If we fail, try to clean up the useless temp file; don't bother - * to complain if this fails too. - */ - unlink(tempfilename); - } - } - else - { - /* Delete the already-obsolete temp file */ - unlink(tempfilename); - } - - LWLockRelease(RelCacheInitLock); -} - -/* - * Detect whether a given relation (identified by OID) is one of the ones - * we store in the init file. - * - * Note that we effectively assume that all backends running in a database - * would choose to store the same set of relations in the init file; - * otherwise there are cases where we'd fail to detect the need for an init - * file invalidation. This does not seem likely to be a problem in practice. - */ -bool -RelationIdIsInInitFile(Oid relationId) -{ - return intMember((int) relationId, initFileRelationIds); -} - -/* - * Invalidate (remove) the init file during commit of a transaction that - * changed one or more of the relation cache entries that are kept in the - * init file. - * - * We actually need to remove the init file twice: once just before sending - * the SI messages that include relcache inval for such relations, and once - * just after sending them. The unlink before ensures that a backend that's - * currently starting cannot read the now-obsolete init file and then miss - * the SI messages that will force it to update its relcache entries. (This - * works because the backend startup sequence gets into the PROC array before - * trying to load the init file.) The unlink after is to synchronize with a - * backend that may currently be trying to write an init file based on data - * that we've just rendered invalid. Such a backend will see the SI messages, - * but we can't leave the init file sitting around to fool later backends. - * - * Ignore any failure to unlink the file, since it might not be there if - * no backend has been started since the last removal. - */ -void -RelationCacheInitFileInvalidate(bool beforeSend) -{ - char initfilename[MAXPGPATH]; - - snprintf(initfilename, sizeof(initfilename), "%s/%s", - DatabasePath, RELCACHE_INIT_FILENAME); - - if (beforeSend) - { - /* no interlock needed here */ - unlink(initfilename); - } - else - { - /* - * We need to interlock this against write_relcache_init_file, - * to guard against possibility that someone renames a new-but- - * already-obsolete init file into place just after we unlink. - * With the interlock, it's certain that write_relcache_init_file - * will notice our SI inval message before renaming into place, - * or else that we will execute second and successfully unlink - * the file. - */ - LWLockAcquire(RelCacheInitLock, LW_EXCLUSIVE); - unlink(initfilename); - LWLockRelease(RelCacheInitLock); - } -} diff --git a/src/backend/utils/cache/syscache.c b/src/backend/utils/cache/syscache.c deleted file mode 100644 index e409ab7bc8e..00000000000 --- a/src/backend/utils/cache/syscache.c +++ /dev/null @@ -1,633 +0,0 @@ -/*------------------------------------------------------------------------- - * - * syscache.c - * System cache management routines - * - * Portions Copyright (c) 1996-2002, PostgreSQL Global Development Group - * Portions Copyright (c) 1994, Regents of the University of California - * - * - * IDENTIFICATION - * $Header: /cvsroot/pgsql/src/backend/utils/cache/syscache.c,v 1.80 2002/06/20 20:29:39 momjian Exp $ - * - * NOTES - * These routines allow the parser/planner/executor to perform - * rapid lookups on the contents of the system catalogs. - * - * see catalog/syscache.h for a list of the cache id's - * - *------------------------------------------------------------------------- - */ -#include "postgres.h" - -#include "access/heapam.h" -#include "access/transam.h" -#include "utils/builtins.h" -#include "catalog/catname.h" -#include "catalog/indexing.h" -#include "catalog/pg_aggregate.h" -#include "catalog/pg_amop.h" -#include "catalog/pg_amproc.h" -#include "catalog/pg_group.h" -#include "catalog/pg_index.h" -#include "catalog/pg_inherits.h" -#include "catalog/pg_language.h" -#include "catalog/pg_namespace.h" -#include "catalog/pg_opclass.h" -#include "catalog/pg_operator.h" -#include "catalog/pg_proc.h" -#include "catalog/pg_rewrite.h" -#include "catalog/pg_shadow.h" -#include "catalog/pg_statistic.h" -#include "catalog/pg_type.h" -#include "utils/catcache.h" -#include "utils/syscache.h" -#include "miscadmin.h" - - -/*--------------------------------------------------------------------------- - - Adding system caches: - - Add your new cache to the list in include/utils/syscache.h. Keep - the list sorted alphabetically and adjust the cache numbers - accordingly. - - Add your entry to the cacheinfo[] array below. All cache lists are - alphabetical, so add it in the proper place. Specify the relation - name, index name, number of keys, and key attribute numbers. If the - relation contains tuples that are associated with a particular relation - (for example, its attributes, rules, triggers, etc) then specify the - attribute number that contains the OID of the associated relation. - This is used by CatalogCacheFlushRelation() to remove the correct - tuples during a table drop or relcache invalidation event. - - In include/catalog/indexing.h, add a define for the number of indexes - on the relation, add define(s) for the index name(s), add an extern - array to hold the index names, and use DECLARE_UNIQUE_INDEX to define - the index. Cache lookups return only one row, so the index should be - unique in most cases. - - In backend/catalog/indexing.c, initialize the relation array with - the index names for the relation. - - Finally, any place your relation gets heap_insert() or - heap_update calls, include code to do a CatalogIndexInsert() to update - the system indexes. The heap_* calls do not update indexes. - - bjm 1999/11/22 - - --------------------------------------------------------------------------- -*/ - -/* - * struct cachedesc: information defining a single syscache - */ -struct cachedesc -{ - const char *name; /* name of the relation being cached */ - const char *indname; /* name of index relation for this cache */ - int reloidattr; /* attr number of rel OID reference, or 0 */ - int nkeys; /* # of keys needed for cache lookup */ - int key[4]; /* attribute numbers of key attrs */ -}; - -static const struct cachedesc cacheinfo[] = { - {AggregateRelationName, /* AGGFNOID */ - AggregateFnoidIndex, - 0, - 1, - { - Anum_pg_aggregate_aggfnoid, - 0, - 0, - 0 - }}, - {AccessMethodRelationName, /* AMNAME */ - AmNameIndex, - 0, - 1, - { - Anum_pg_am_amname, - 0, - 0, - 0 - }}, - {AccessMethodRelationName, /* AMOID */ - AmOidIndex, - 0, - 1, - { - ObjectIdAttributeNumber, - 0, - 0, - 0 - }}, - {AccessMethodOperatorRelationName, /* AMOPOPID */ - AccessMethodOperatorIndex, - 0, - 2, - { - Anum_pg_amop_amopclaid, - Anum_pg_amop_amopopr, - 0, - 0 - }}, - {AccessMethodOperatorRelationName, /* AMOPSTRATEGY */ - AccessMethodStrategyIndex, - 0, - 2, - { - Anum_pg_amop_amopclaid, - Anum_pg_amop_amopstrategy, - 0, - 0 - }}, - {AccessMethodProcedureRelationName, /* AMPROCNUM */ - AccessMethodProcedureIndex, - 0, - 2, - { - Anum_pg_amproc_amopclaid, - Anum_pg_amproc_amprocnum, - 0, - 0 - }}, - {AttributeRelationName, /* ATTNAME */ - AttributeRelidNameIndex, - Anum_pg_attribute_attrelid, - 2, - { - Anum_pg_attribute_attrelid, - Anum_pg_attribute_attname, - 0, - 0 - }}, - {AttributeRelationName, /* ATTNUM */ - AttributeRelidNumIndex, - Anum_pg_attribute_attrelid, - 2, - { - Anum_pg_attribute_attrelid, - Anum_pg_attribute_attnum, - 0, - 0 - }}, - {OperatorClassRelationName, /* CLAAMNAMENSP */ - OpclassAmNameNspIndex, - 0, - 3, - { - Anum_pg_opclass_opcamid, - Anum_pg_opclass_opcname, - Anum_pg_opclass_opcnamespace, - 0 - }}, - {OperatorClassRelationName, /* CLAOID */ - OpclassOidIndex, - 0, - 1, - { - ObjectIdAttributeNumber, - 0, - 0, - 0 - }}, - {GroupRelationName, /* GRONAME */ - GroupNameIndex, - 0, - 1, - { - Anum_pg_group_groname, - 0, - 0, - 0 - }}, - {GroupRelationName, /* GROSYSID */ - GroupSysidIndex, - 0, - 1, - { - Anum_pg_group_grosysid, - 0, - 0, - 0 - }}, - {IndexRelationName, /* INDEXRELID */ - IndexRelidIndex, - Anum_pg_index_indrelid, - 1, - { - Anum_pg_index_indexrelid, - 0, - 0, - 0 - }}, - {InheritsRelationName, /* INHRELID */ - InheritsRelidSeqnoIndex, - Anum_pg_inherits_inhrelid, - 2, - { - Anum_pg_inherits_inhrelid, - Anum_pg_inherits_inhseqno, - 0, - 0 - }}, - {LanguageRelationName, /* LANGNAME */ - LanguageNameIndex, - 0, - 1, - { - Anum_pg_language_lanname, - 0, - 0, - 0 - }}, - {LanguageRelationName, /* LANGOID */ - LanguageOidIndex, - 0, - 1, - { - ObjectIdAttributeNumber, - 0, - 0, - 0 - }}, - {NamespaceRelationName, /* NAMESPACENAME */ - NamespaceNameIndex, - 0, - 1, - { - Anum_pg_namespace_nspname, - 0, - 0, - 0 - }}, - {NamespaceRelationName, /* NAMESPACEOID */ - NamespaceOidIndex, - 0, - 1, - { - ObjectIdAttributeNumber, - 0, - 0, - 0 - }}, - {OperatorRelationName, /* OPERNAMENSP */ - OperatorNameNspIndex, - 0, - 4, - { - Anum_pg_operator_oprname, - Anum_pg_operator_oprleft, - Anum_pg_operator_oprright, - Anum_pg_operator_oprnamespace - }}, - {OperatorRelationName, /* OPEROID */ - OperatorOidIndex, - 0, - 1, - { - ObjectIdAttributeNumber, - 0, - 0, - 0 - }}, - {ProcedureRelationName, /* PROCNAMENSP */ - ProcedureNameNspIndex, - 0, - 4, - { - Anum_pg_proc_proname, - Anum_pg_proc_pronargs, - Anum_pg_proc_proargtypes, - Anum_pg_proc_pronamespace - }}, - {ProcedureRelationName, /* PROCOID */ - ProcedureOidIndex, - 0, - 1, - { - ObjectIdAttributeNumber, - 0, - 0, - 0 - }}, - {RelationRelationName, /* RELNAMENSP */ - ClassNameNspIndex, - ObjectIdAttributeNumber, - 2, - { - Anum_pg_class_relname, - Anum_pg_class_relnamespace, - 0, - 0 - }}, - {RelationRelationName, /* RELOID */ - ClassOidIndex, - ObjectIdAttributeNumber, - 1, - { - ObjectIdAttributeNumber, - 0, - 0, - 0 - }}, - {RewriteRelationName, /* RULERELNAME */ - RewriteRelRulenameIndex, - Anum_pg_rewrite_ev_class, - 2, - { - Anum_pg_rewrite_ev_class, - Anum_pg_rewrite_rulename, - 0, - 0 - }}, - {ShadowRelationName, /* SHADOWNAME */ - ShadowNameIndex, - 0, - 1, - { - Anum_pg_shadow_usename, - 0, - 0, - 0 - }}, - {ShadowRelationName, /* SHADOWSYSID */ - ShadowSysidIndex, - 0, - 1, - { - Anum_pg_shadow_usesysid, - 0, - 0, - 0 - }}, - {StatisticRelationName, /* STATRELATT */ - StatisticRelidAttnumIndex, - Anum_pg_statistic_starelid, - 2, - { - Anum_pg_statistic_starelid, - Anum_pg_statistic_staattnum, - 0, - 0 - }}, - {TypeRelationName, /* TYPENAMENSP */ - TypeNameNspIndex, - Anum_pg_type_typrelid, - 2, - { - Anum_pg_type_typname, - Anum_pg_type_typnamespace, - 0, - 0 - }}, - {TypeRelationName, /* TYPEOID */ - TypeOidIndex, - Anum_pg_type_typrelid, - 1, - { - ObjectIdAttributeNumber, - 0, - 0, - 0 - }} -}; - -static CatCache *SysCache[lengthof(cacheinfo)]; -static int SysCacheSize = lengthof(cacheinfo); -static bool CacheInitialized = false; - - -bool -IsCacheInitialized(void) -{ - return CacheInitialized; -} - - -/* - * InitCatalogCache - initialize the caches - * - * Note that no database access is done here; we only allocate memory - * and initialize the cache structure. Interrogation of the database - * to complete initialization of a cache happens upon first use - * of that cache. - */ -void -InitCatalogCache(void) -{ - int cacheId; - - Assert(!CacheInitialized); - - MemSet((char *) SysCache, 0, sizeof(SysCache)); - - for (cacheId = 0; cacheId < SysCacheSize; cacheId++) - { - SysCache[cacheId] = InitCatCache(cacheId, - cacheinfo[cacheId].name, - cacheinfo[cacheId].indname, - cacheinfo[cacheId].reloidattr, - cacheinfo[cacheId].nkeys, - cacheinfo[cacheId].key); - if (!PointerIsValid(SysCache[cacheId])) - elog(ERROR, "InitCatalogCache: Can't init cache %s (%d)", - cacheinfo[cacheId].name, cacheId); - } - CacheInitialized = true; -} - - -/* - * InitCatalogCachePhase2 - finish initializing the caches - * - * Finish initializing all the caches, including necessary database - * access. - * - * This is *not* essential; normally we allow syscaches to be initialized - * on first use. However, it is useful as a mechanism to preload the - * relcache with entries for the most-commonly-used system catalogs. - * Therefore, we invoke this routine when we need to write a new relcache - * init file. - */ -void -InitCatalogCachePhase2(void) -{ - int cacheId; - - Assert(CacheInitialized); - - for (cacheId = 0; cacheId < SysCacheSize; cacheId++) - { - InitCatCachePhase2(SysCache[cacheId]); - } -} - - -/* - * SearchSysCache - * - * A layer on top of SearchCatCache that does the initialization and - * key-setting for you. - * - * Returns the cache copy of the tuple if one is found, NULL if not. - * The tuple is the 'cache' copy and must NOT be modified! - * - * When the caller is done using the tuple, call ReleaseSysCache() - * to release the reference count grabbed by SearchSysCache(). If this - * is not done, the tuple will remain locked in cache until end of - * transaction, which is tolerable but not desirable. - * - * CAUTION: The tuple that is returned must NOT be freed by the caller! - */ -HeapTuple -SearchSysCache(int cacheId, - Datum key1, - Datum key2, - Datum key3, - Datum key4) -{ - if (cacheId < 0 || cacheId >= SysCacheSize || - ! PointerIsValid(SysCache[cacheId])) - elog(ERROR, "SearchSysCache: Bad cache id %d", cacheId); - - return SearchCatCache(SysCache[cacheId], key1, key2, key3, key4); -} - -/* - * ReleaseSysCache - * Release previously grabbed reference count on a tuple - */ -void -ReleaseSysCache(HeapTuple tuple) -{ - ReleaseCatCache(tuple); -} - -/* - * SearchSysCacheCopy - * - * A convenience routine that does SearchSysCache and (if successful) - * returns a modifiable copy of the syscache entry. The original - * syscache entry is released before returning. The caller should - * heap_freetuple() the result when done with it. - */ -HeapTuple -SearchSysCacheCopy(int cacheId, - Datum key1, - Datum key2, - Datum key3, - Datum key4) -{ - HeapTuple tuple, - newtuple; - - tuple = SearchSysCache(cacheId, key1, key2, key3, key4); - if (!HeapTupleIsValid(tuple)) - return tuple; - newtuple = heap_copytuple(tuple); - ReleaseSysCache(tuple); - return newtuple; -} - -/* - * SearchSysCacheExists - * - * A convenience routine that just probes to see if a tuple can be found. - * No lock is retained on the syscache entry. - */ -bool -SearchSysCacheExists(int cacheId, - Datum key1, - Datum key2, - Datum key3, - Datum key4) -{ - HeapTuple tuple; - - tuple = SearchSysCache(cacheId, key1, key2, key3, key4); - if (!HeapTupleIsValid(tuple)) - return false; - ReleaseSysCache(tuple); - return true; -} - -/* - * GetSysCacheOid - * - * A convenience routine that does SearchSysCache and returns the OID - * of the found tuple, or InvalidOid if no tuple could be found. - * No lock is retained on the syscache entry. - */ -Oid -GetSysCacheOid(int cacheId, - Datum key1, - Datum key2, - Datum key3, - Datum key4) -{ - HeapTuple tuple; - Oid result; - - tuple = SearchSysCache(cacheId, key1, key2, key3, key4); - if (!HeapTupleIsValid(tuple)) - return InvalidOid; - result = tuple->t_data->t_oid; - ReleaseSysCache(tuple); - return result; -} - -/* - * SysCacheGetAttr - * - * Given a tuple previously fetched by SearchSysCache(), - * extract a specific attribute. - * - * This is equivalent to using heap_getattr() on a tuple fetched - * from a non-cached relation. Usually, this is only used for attributes - * that could be NULL or variable length; the fixed-size attributes in - * a system table are accessed just by mapping the tuple onto the C struct - * declarations from include/catalog/. - * - * As with heap_getattr(), if the attribute is of a pass-by-reference type - * then a pointer into the tuple data area is returned --- the caller must - * not modify or pfree the datum! - */ -Datum -SysCacheGetAttr(int cacheId, HeapTuple tup, - AttrNumber attributeNumber, - bool *isNull) -{ - /* - * We just need to get the TupleDesc out of the cache entry, and then - * we can apply heap_getattr(). We expect that the cache control data - * is currently valid --- if the caller recently fetched the tuple, - * then it should be. - */ - if (cacheId < 0 || cacheId >= SysCacheSize) - elog(ERROR, "SysCacheGetAttr: Bad cache id %d", cacheId); - if (!PointerIsValid(SysCache[cacheId]) || - !PointerIsValid(SysCache[cacheId]->cc_tupdesc)) - elog(ERROR, "SysCacheGetAttr: missing cache data for id %d", cacheId); - - return heap_getattr(tup, attributeNumber, - SysCache[cacheId]->cc_tupdesc, - isNull); -} - -/* - * List-search interface - */ -struct catclist * -SearchSysCacheList(int cacheId, int nkeys, - Datum key1, Datum key2, Datum key3, Datum key4) -{ - if (cacheId < 0 || cacheId >= SysCacheSize || - ! PointerIsValid(SysCache[cacheId])) - elog(ERROR, "SearchSysCacheList: Bad cache id %d", cacheId); - - return SearchCatCacheList(SysCache[cacheId], nkeys, - key1, key2, key3, key4); -} |