#include "postgres.h"
#include <sys/file.h>
#include <fcntl.h>
#include <unistd.h>
#include "access/htup_details.h"
#include "access/multixact.h"
#include "access/nbtree.h"
#include "access/reloptions.h"
#include "access/sysattr.h"
#include "access/table.h"
#include "access/tableam.h"
#include "access/tupdesc_details.h"
#include "access/xact.h"
#include "access/xlog.h"
#include "catalog/catalog.h"
#include "catalog/indexing.h"
#include "catalog/namespace.h"
#include "catalog/pg_am.h"
#include "catalog/pg_amproc.h"
#include "catalog/pg_attrdef.h"
#include "catalog/pg_auth_members.h"
#include "catalog/pg_authid.h"
#include "catalog/pg_constraint.h"
#include "catalog/pg_database.h"
#include "catalog/pg_namespace.h"
#include "catalog/pg_opclass.h"
#include "catalog/pg_proc.h"
#include "catalog/pg_publication.h"
#include "catalog/pg_rewrite.h"
#include "catalog/pg_shseclabel.h"
#include "catalog/pg_statistic_ext.h"
#include "catalog/pg_subscription.h"
#include "catalog/pg_tablespace.h"
#include "catalog/pg_trigger.h"
#include "catalog/pg_type.h"
#include "catalog/schemapg.h"
#include "catalog/storage.h"
#include "commands/policy.h"
#include "commands/trigger.h"
#include "miscadmin.h"
#include "nodes/makefuncs.h"
#include "nodes/nodeFuncs.h"
#include "optimizer/optimizer.h"
#include "rewrite/rewriteDefine.h"
#include "rewrite/rowsecurity.h"
#include "storage/lmgr.h"
#include "storage/smgr.h"
#include "utils/array.h"
#include "utils/builtins.h"
#include "utils/datum.h"
#include "utils/fmgroids.h"
#include "utils/inval.h"
#include "utils/lsyscache.h"
#include "utils/memutils.h"
#include "utils/relmapper.h"
#include "utils/resowner_private.h"
#include "utils/snapmgr.h"
#include "utils/syscache.h"

Include dependency graph for relcache.c:

Data Structures
struct	relidcacheent

struct	opclasscacheent

Macros
#define	RELCACHE_INIT_FILEMAGIC 0x573266 /* version ID value */

#define	RECOVER_RELATION_BUILD_MEMORY 0

#define	MAX_EOXACT_LIST 32

#define	EOXactListAdd(rel)

#define	RelationCacheInsert(RELATION, replace_allowed)

#define	RelationIdCacheLookup(ID, RELATION)

#define	RelationCacheDelete(RELATION)

#define	SWAPFIELD(fldtype, fldname)

#define	INITRELCACHESIZE 400

#define	NUM_CRITICAL_SHARED_RELS 5 /* fix if you change list above */

#define	NUM_CRITICAL_LOCAL_RELS 4 /* fix if you change list above */

#define	NUM_CRITICAL_LOCAL_INDEXES 7 /* fix if you change list above */

#define	NUM_CRITICAL_SHARED_INDEXES 6 /* fix if you change list above */

Typedefs
typedef struct relidcacheent	RelIdCacheEnt

typedef struct opclasscacheent	OpClassCacheEnt

Functions
static void	RelationDestroyRelation (Relation relation, bool remember_tupdesc)

static void	RelationClearRelation (Relation relation, bool rebuild)

static void	RelationReloadIndexInfo (Relation relation)

static void	RelationReloadNailed (Relation relation)

static void	RelationFlushRelation (Relation relation)

static void	RememberToFreeTupleDescAtEOX (TupleDesc td)

static void	AtEOXact_cleanup (Relation relation, bool isCommit)

static void	AtEOSubXact_cleanup (Relation relation, bool isCommit, SubTransactionId mySubid, SubTransactionId parentSubid)

static bool	load_relcache_init_file (bool shared)

static void	write_relcache_init_file (bool shared)

static void	write_item (const void data, Size len, FILE fp)

static void	formrdesc (const char relationName, Oid relationReltype, bool isshared, int natts, const FormData_pg_attribute attrs)

static HeapTuple	ScanPgRelation (Oid targetRelId, bool indexOK, bool force_non_historic)

static Relation	AllocateRelationDesc (Form_pg_class relp)

static void	RelationParseRelOptions (Relation relation, HeapTuple tuple)

static void	RelationBuildTupleDesc (Relation relation)

static Relation	RelationBuildDesc (Oid targetRelId, bool insertIt)

static void	RelationInitPhysicalAddr (Relation relation)

static void	load_critical_index (Oid indexoid, Oid heapoid)

static TupleDesc	GetPgClassDescriptor (void)

static TupleDesc	GetPgIndexDescriptor (void)

static void	AttrDefaultFetch (Relation relation)

static void	CheckConstraintFetch (Relation relation)

static int	CheckConstraintCmp (const void a, const void b)

static void	InitIndexAmRoutine (Relation relation)

static void	IndexSupportInitialize (oidvector indclass, RegProcedure indexSupport, Oid opFamily, Oid opcInType, StrategyNumber maxSupportNumber, AttrNumber maxAttributeNumber)

static OpClassCacheEnt *	LookupOpclassInfo (Oid operatorClassOid, StrategyNumber numSupport)

static void	RelationCacheInitFileRemoveInDir (const char *tblspcpath)

static void	unlink_initfile (const char *initfilename, int elevel)

static void	RelationBuildRuleLock (Relation relation)

static bool	equalRuleLocks (RuleLock rlock1, RuleLock rlock2)

static bool	equalPolicy (RowSecurityPolicy policy1, RowSecurityPolicy policy2)

static bool	equalRSDesc (RowSecurityDesc rsdesc1, RowSecurityDesc rsdesc2)

void	RelationInitIndexAccessInfo (Relation relation)

static void	InitTableAmRoutine (Relation relation)

void	RelationInitTableAccessMethod (Relation relation)

Relation	RelationIdGetRelation (Oid relationId)

void	RelationIncrementReferenceCount (Relation rel)

void	RelationDecrementReferenceCount (Relation rel)

void	RelationClose (Relation relation)

void	RelationForgetRelation (Oid rid)

void	RelationCacheInvalidateEntry (Oid relationId)

void	RelationCacheInvalidate (void)

void	RelationCloseSmgrByOid (Oid relationId)

void	AtEOXact_RelationCache (bool isCommit)

void	AtEOSubXact_RelationCache (bool isCommit, SubTransactionId mySubid, SubTransactionId parentSubid)

Relation	RelationBuildLocalRelation (const char *relname, Oid relnamespace, TupleDesc tupDesc, Oid relid, Oid accessmtd, Oid relfilenode, Oid reltablespace, bool shared_relation, bool mapped_relation, char relpersistence, char relkind)

void	RelationSetNewRelfilenode (Relation relation, char persistence)

void	RelationCacheInitialize (void)

void	RelationCacheInitializePhase2 (void)

void	RelationCacheInitializePhase3 (void)

static TupleDesc	BuildHardcodedDescriptor (int natts, const FormData_pg_attribute *attrs)

List *	RelationGetFKeyList (Relation relation)

List *	RelationGetIndexList (Relation relation)

List *	RelationGetStatExtList (Relation relation)

Oid	RelationGetPrimaryKeyIndex (Relation relation)

Oid	RelationGetReplicaIndex (Relation relation)

List *	RelationGetIndexExpressions (Relation relation)

List *	RelationGetDummyIndexExpressions (Relation relation)

List *	RelationGetIndexPredicate (Relation relation)

Bitmapset *	RelationGetIndexAttrBitmap (Relation relation, IndexAttrBitmapKind attrKind)

void	RelationGetExclusionInfo (Relation indexRelation, Oid operators, Oid procs, uint16 **strategies)

struct PublicationActions *	GetRelationPublicationActions (Relation relation)

int	errtable (Relation rel)

int	errtablecol (Relation rel, int attnum)

int	errtablecolname (Relation rel, const char *colname)

int	errtableconstraint (Relation rel, const char *conname)

bool	RelationIdIsInInitFile (Oid relationId)

void	RelationCacheInitFilePreInvalidate (void)

void	RelationCacheInitFilePostInvalidate (void)

void	RelationCacheInitFileRemove (void)

Variables
static const FormData_pg_attribute	Desc_pg_class [Natts_pg_class] = {Schema_pg_class}

static const FormData_pg_attribute	Desc_pg_attribute [Natts_pg_attribute] = {Schema_pg_attribute}

static const FormData_pg_attribute	Desc_pg_proc [Natts_pg_proc] = {Schema_pg_proc}

static const FormData_pg_attribute	Desc_pg_type [Natts_pg_type] = {Schema_pg_type}

static const FormData_pg_attribute	Desc_pg_database [Natts_pg_database] = {Schema_pg_database}

static const FormData_pg_attribute	Desc_pg_authid [Natts_pg_authid] = {Schema_pg_authid}

static const FormData_pg_attribute	Desc_pg_auth_members [Natts_pg_auth_members] = {Schema_pg_auth_members}

static const FormData_pg_attribute	Desc_pg_index [Natts_pg_index] = {Schema_pg_index}

static const FormData_pg_attribute	Desc_pg_shseclabel [Natts_pg_shseclabel] = {Schema_pg_shseclabel}

static const FormData_pg_attribute	Desc_pg_subscription [Natts_pg_subscription] = {Schema_pg_subscription}

static HTAB *	RelationIdCache

bool	criticalRelcachesBuilt = false

bool	criticalSharedRelcachesBuilt = false

static long	relcacheInvalsReceived = 0L

static Oid	eoxact_list [MAX_EOXACT_LIST]

static int	eoxact_list_len = 0

static bool	eoxact_list_overflowed = false

static TupleDesc *	EOXactTupleDescArray

static int	NextEOXactTupleDescNum = 0

static int	EOXactTupleDescArrayLen = 0

static HTAB *	OpClassCache = NULL

Macro Definition Documentation

◆ EOXactListAdd

#define EOXactListAdd ( rel )

Value:

do { \
        if (eoxact_list_len < MAX_EOXACT_LIST) \
            eoxact_list[eoxact_list_len++] = (rel)->rd_id; \
        else \
            eoxact_list_overflowed = true; \
    } while (0)

Definition at line 166 of file relcache.c.

Referenced by RelationBuildLocalRelation(), and RelationSetNewRelfilenode().

◆ INITRELCACHESIZE

#define INITRELCACHESIZE 400

Definition at line 3579 of file relcache.c.

Referenced by RelationCacheInitialize().

◆ MAX_EOXACT_LIST

#define MAX_EOXACT_LIST 32

Definition at line 161 of file relcache.c.

◆ NUM_CRITICAL_LOCAL_INDEXES

#define NUM_CRITICAL_LOCAL_INDEXES 7 /* fix if you change list above */

Referenced by load_relcache_init_file().

◆ NUM_CRITICAL_LOCAL_RELS

#define NUM_CRITICAL_LOCAL_RELS 4 /* fix if you change list above */

Referenced by load_relcache_init_file().

◆ NUM_CRITICAL_SHARED_INDEXES

#define NUM_CRITICAL_SHARED_INDEXES 6 /* fix if you change list above */

Referenced by load_relcache_init_file().

◆ NUM_CRITICAL_SHARED_RELS

#define NUM_CRITICAL_SHARED_RELS 5 /* fix if you change list above */

Referenced by load_relcache_init_file().

◆ RECOVER_RELATION_BUILD_MEMORY

#define RECOVER_RELATION_BUILD_MEMORY 0

Definition at line 99 of file relcache.c.

◆ RelationCacheDelete

#define RelationCacheDelete ( RELATION )

Value:

do { \
    RelIdCacheEnt *hentry; \
    hentry = (RelIdCacheEnt *) hash_search(RelationIdCache, \
                                           (void *) &((RELATION)->rd_id), \
                                           HASH_REMOVE, NULL); \
    if (hentry == NULL) \
        elog(WARNING, "failed to delete relcache entry for OID %u", \
             (RELATION)->rd_id); \
} while(0)

Definition at line 220 of file relcache.c.

Referenced by RelationClearRelation().

◆ RelationCacheInsert

#define RelationCacheInsert	(	RELATION,
		replace_allowed
	)

Value:

do { \
    RelIdCacheEnt *hentry; bool found; \
    hentry = (RelIdCacheEnt *) hash_search(RelationIdCache, \
                                           (void *) &((RELATION)->rd_id), \
                                           HASH_ENTER, &found); \
    if (found) \
    { \
        /* see comments in RelationBuildDesc and RelationBuildLocalRelation */ \
        Relation _old_rel = hentry->reldesc; \
        Assert(replace_allowed); \
        hentry->reldesc = (RELATION); \
        if (RelationHasReferenceCountZero(_old_rel)) \
            RelationDestroyRelation(_old_rel, false); \
        else if (!IsBootstrapProcessingMode()) \
            elog(WARNING, "leaking still-referenced relcache entry for \"%s\"", \
                 RelationGetRelationName(_old_rel)); \
    } \
    else \
        hentry->reldesc = (RELATION); \
} while(0)

Definition at line 186 of file relcache.c.

Referenced by formrdesc(), load_relcache_init_file(), RelationBuildDesc(), and RelationBuildLocalRelation().

◆ RelationIdCacheLookup

#define RelationIdCacheLookup	(	ID,
		RELATION
	)

Value:

do { \
    RelIdCacheEnt *hentry; \
    hentry = (RelIdCacheEnt *) hash_search(RelationIdCache, \
                                           (void *) &(ID), \
                                           HASH_FIND, NULL); \
    if (hentry) \
        RELATION = hentry->reldesc; \
    else \
        RELATION = NULL; \
} while(0)

Definition at line 208 of file relcache.c.

Referenced by RelationCacheInvalidateEntry(), RelationCloseSmgrByOid(), RelationForgetRelation(), and RelationIdGetRelation().

◆ RELCACHE_INIT_FILEMAGIC

#define RELCACHE_INIT_FILEMAGIC 0x573266 /* version ID value */

Definition at line 88 of file relcache.c.

Referenced by load_relcache_init_file(), and write_relcache_init_file().

◆ SWAPFIELD

#define SWAPFIELD	(	fldtype,
		fldname
	)

Value:

do { \
            fldtype _tmp = newrel->fldname; \
            newrel->fldname = relation->fldname; \
            relation->fldname = _tmp; \
        } while (0)

Referenced by RelationClearRelation().

Typedef Documentation

◆ OpClassCacheEnt

typedef struct opclasscacheent OpClassCacheEnt

◆ RelIdCacheEnt

typedef struct relidcacheent RelIdCacheEnt

Function Documentation

◆ AllocateRelationDesc()

static Relation AllocateRelationDesc ( Form_pg_class relp )

static

Definition at line 380 of file relcache.c.

References CacheMemoryContext, CLASS_TUPLE_SIZE, CreateTemplateTupleDesc(), MemoryContextSwitchTo(), palloc(), palloc0(), RelationData::rd_att, RelationData::rd_rel, RelationData::rd_smgr, and TupleDescData::tdrefcount.

Referenced by RelationBuildDesc().

 {
     Relation    relation;
     MemoryContext oldcxt;
     Form_pg_class relationForm;
 
     /* Relcache entries must live in CacheMemoryContext */
     oldcxt = MemoryContextSwitchTo(CacheMemoryContext);
 
     /*
      * allocate and zero space for new relation descriptor
      */
     relation = (Relation) palloc0(sizeof(RelationData));
 
     /* make sure relation is marked as having no open file yet */
     relation->rd_smgr = NULL;
 
     /*
      * Copy the relation tuple form
      *
      * We only allocate space for the fixed fields, ie, CLASS_TUPLE_SIZE. The
      * variable-length fields (relacl, reloptions) are NOT stored in the
      * relcache --- there'd be little point in it, since we don't copy the
      * tuple's nulls bitmap and hence wouldn't know if the values are valid.
      * Bottom line is that relacl *cannot* be retrieved from the relcache. Get
      * it from the syscache if you need it.  The same goes for the original
      * form of reloptions (however, we do store the parsed form of reloptions
      * in rd_options).
      */
     relationForm = (Form_pg_class) palloc(CLASS_TUPLE_SIZE);
 
     memcpy(relationForm, relp, CLASS_TUPLE_SIZE);
 
     /* initialize relation tuple form */
     relation->rd_rel = relationForm;
 
     /* and allocate attribute tuple form storage */
     relation->rd_att = CreateTemplateTupleDesc(relationForm->relnatts);
     /* which we mark as a reference-counted tupdesc */
     relation->rd_att->tdrefcount = 1;
 
     MemoryContextSwitchTo(oldcxt);
 
     return relation;
 }

◆ AtEOSubXact_cleanup()

static void AtEOSubXact_cleanup	(	Relation	relation,
		bool	isCommit,
		SubTransactionId	mySubid,
		SubTransactionId	parentSubid
	)

static

Definition at line 3126 of file relcache.c.

References elog, InvalidSubTransactionId, RelationData::rd_createSubid, RelationData::rd_newRelfilenodeSubid, RelationClearRelation(), RelationGetRelationName, RelationHasReferenceCountZero, and WARNING.

Referenced by AtEOSubXact_RelationCache().

 {
     /*
      * Is it a relation created in the current subtransaction?
      *
      * During subcommit, mark it as belonging to the parent, instead. During
      * subabort, simply delete the relcache entry.
      */
     if (relation->rd_createSubid == mySubid)
     {
         if (isCommit)
             relation->rd_createSubid = parentSubid;
         else if (RelationHasReferenceCountZero(relation))
         {
             RelationClearRelation(relation, false);
             return;
         }
         else
         {
             /*
              * Hmm, somewhere there's a (leaked?) reference to the relation.
              * We daren't remove the entry for fear of dereferencing a
              * dangling pointer later.  Bleat, and transfer it to the parent
              * subtransaction so we can try again later.  This must be just a
              * WARNING to avoid error-during-error-recovery loops.
              */
             relation->rd_createSubid = parentSubid;
             elog(WARNING, "cannot remove relcache entry for \"%s\" because it has nonzero refcount",
                  RelationGetRelationName(relation));
         }
     }
 
     /*
      * Likewise, update or drop any new-relfilenode-in-subtransaction hint.
      */
     if (relation->rd_newRelfilenodeSubid == mySubid)
     {
         if (isCommit)
             relation->rd_newRelfilenodeSubid = parentSubid;
         else
             relation->rd_newRelfilenodeSubid = InvalidSubTransactionId;
     }
 }

◆ AtEOSubXact_RelationCache()

void AtEOSubXact_RelationCache	(	bool	isCommit,
		SubTransactionId	mySubid,
		SubTransactionId	parentSubid
	)

Definition at line 3079 of file relcache.c.

References AtEOSubXact_cleanup(), eoxact_list, eoxact_list_len, eoxact_list_overflowed, HASH_FIND, hash_search(), hash_seq_init(), hash_seq_search(), i, relidcacheent::reldesc, and status().

Referenced by AbortSubTransaction(), and CommitSubTransaction().

 {
     HASH_SEQ_STATUS status;
     RelIdCacheEnt *idhentry;
     int         i;
 
     /*
      * Unless the eoxact_list[] overflowed, we only need to examine the rels
      * listed in it.  Otherwise fall back on a hash_seq_search scan.  Same
      * logic as in AtEOXact_RelationCache.
      */
     if (eoxact_list_overflowed)
     {
         hash_seq_init(&status, RelationIdCache);
         while ((idhentry = (RelIdCacheEnt *) hash_seq_search(&status)) != NULL)
         {
             AtEOSubXact_cleanup(idhentry->reldesc, isCommit,
                                 mySubid, parentSubid);
         }
     }
     else
     {
         for (i = 0; i < eoxact_list_len; i++)
         {
             idhentry = (RelIdCacheEnt *) hash_search(RelationIdCache,
                                                      (void *) &eoxact_list[i],
                                                      HASH_FIND,
                                                      NULL);
             if (idhentry != NULL)
                 AtEOSubXact_cleanup(idhentry->reldesc, isCommit,
                                     mySubid, parentSubid);
         }
     }
 
     /* Don't reset the list; we still need more cleanup later */
 }

◆ AtEOXact_cleanup()

static void AtEOXact_cleanup	(	Relation	relation,
		bool	isCommit
	)

static

Definition at line 3004 of file relcache.c.

References Assert, elog, InvalidSubTransactionId, IsBootstrapProcessingMode, RelationData::rd_createSubid, RelationData::rd_isnailed, RelationData::rd_newRelfilenodeSubid, RelationData::rd_refcnt, RelationClearRelation(), RelationGetRelationName, RelationHasReferenceCountZero, and WARNING.

Referenced by AtEOXact_RelationCache().

 {
     /*
      * The relcache entry's ref count should be back to its normal
      * not-in-a-transaction state: 0 unless it's nailed in cache.
      *
      * In bootstrap mode, this is NOT true, so don't check it --- the
      * bootstrap code expects relations to stay open across start/commit
      * transaction calls.  (That seems bogus, but it's not worth fixing.)
      *
      * Note: ideally this check would be applied to every relcache entry, not
      * just those that have eoxact work to do.  But it's not worth forcing a
      * scan of the whole relcache just for this.  (Moreover, doing so would
      * mean that assert-enabled testing never tests the hash_search code path
      * above, which seems a bad idea.)
      */
 #ifdef USE_ASSERT_CHECKING
     if (!IsBootstrapProcessingMode())
     {
         int         expected_refcnt;
 
         expected_refcnt = relation->rd_isnailed ? 1 : 0;
         Assert(relation->rd_refcnt == expected_refcnt);
     }
 #endif
 
     /*
      * Is it a relation created in the current transaction?
      *
      * During commit, reset the flag to zero, since we are now out of the
      * creating transaction.  During abort, simply delete the relcache entry
      * --- it isn't interesting any longer.  (NOTE: if we have forgotten the
      * new-ness of a new relation due to a forced cache flush, the entry will
      * get deleted anyway by shared-cache-inval processing of the aborted
      * pg_class insertion.)
      */
     if (relation->rd_createSubid != InvalidSubTransactionId)
     {
         if (isCommit)
             relation->rd_createSubid = InvalidSubTransactionId;
         else if (RelationHasReferenceCountZero(relation))
         {
             RelationClearRelation(relation, false);
             return;
         }
         else
         {
             /*
              * Hmm, somewhere there's a (leaked?) reference to the relation.
              * We daren't remove the entry for fear of dereferencing a
              * dangling pointer later.  Bleat, and mark it as not belonging to
              * the current transaction.  Hopefully it'll get cleaned up
              * eventually.  This must be just a WARNING to avoid
              * error-during-error-recovery loops.
              */
             relation->rd_createSubid = InvalidSubTransactionId;
             elog(WARNING, "cannot remove relcache entry for \"%s\" because it has nonzero refcount",
                  RelationGetRelationName(relation));
         }
     }
 
     /*
      * Likewise, reset the hint about the relfilenode being new.
      */
     relation->rd_newRelfilenodeSubid = InvalidSubTransactionId;
 }

◆ AtEOXact_RelationCache()

void AtEOXact_RelationCache ( bool isCommit )

Definition at line 2941 of file relcache.c.

References Assert, AtEOXact_cleanup(), eoxact_list, eoxact_list_len, eoxact_list_overflowed, EOXactTupleDescArrayLen, FreeTupleDesc(), HASH_FIND, hash_search(), hash_seq_init(), hash_seq_search(), i, NextEOXactTupleDescNum, pfree(), relidcacheent::reldesc, and status().

Referenced by AbortTransaction(), CommitTransaction(), and PrepareTransaction().

 {
     HASH_SEQ_STATUS status;
     RelIdCacheEnt *idhentry;
     int         i;
 
     /*
      * Unless the eoxact_list[] overflowed, we only need to examine the rels
      * listed in it.  Otherwise fall back on a hash_seq_search scan.
      *
      * For simplicity, eoxact_list[] entries are not deleted till end of
      * top-level transaction, even though we could remove them at
      * subtransaction end in some cases, or remove relations from the list if
      * they are cleared for other reasons.  Therefore we should expect the
      * case that list entries are not found in the hashtable; if not, there's
      * nothing to do for them.
      */
     if (eoxact_list_overflowed)
     {
         hash_seq_init(&status, RelationIdCache);
         while ((idhentry = (RelIdCacheEnt *) hash_seq_search(&status)) != NULL)
         {
             AtEOXact_cleanup(idhentry->reldesc, isCommit);
         }
     }
     else
     {
         for (i = 0; i < eoxact_list_len; i++)
         {
             idhentry = (RelIdCacheEnt *) hash_search(RelationIdCache,
                                                      (void *) &eoxact_list[i],
                                                      HASH_FIND,
                                                      NULL);
             if (idhentry != NULL)
                 AtEOXact_cleanup(idhentry->reldesc, isCommit);
         }
     }
 
     if (EOXactTupleDescArrayLen > 0)
     {
         Assert(EOXactTupleDescArray != NULL);
         for (i = 0; i < NextEOXactTupleDescNum; i++)
             FreeTupleDesc(EOXactTupleDescArray[i]);
         pfree(EOXactTupleDescArray);
         EOXactTupleDescArray = NULL;
     }
 
     /* Now we're out of the transaction and can clear the lists */
     eoxact_list_len = 0;
     eoxact_list_overflowed = false;
     NextEOXactTupleDescNum = 0;
     EOXactTupleDescArrayLen = 0;
 }

◆ AttrDefaultFetch()

static void AttrDefaultFetch ( Relation relation )

static

Definition at line 4057 of file relcache.c.

References AccessShareLock, AttrDefault::adbin, AttrDefault::adnum, AttrDefaultIndexId, BTEqualStrategyNumber, CacheMemoryContext, TupleDescData::constr, TupleConstr::defval, elog, fastgetattr, GETSTRUCT, HeapTupleIsValid, i, MemoryContextStrdup(), NameStr, TupleConstr::num_defval, ObjectIdGetDatum, pfree(), RelationData::rd_att, RelationGetRelationName, RelationGetRelid, ScanKeyInit(), systable_beginscan(), systable_endscan(), systable_getnext(), table_close(), table_open(), TextDatumGetCString, TupleDescAttr, val, and WARNING.

Referenced by RelationBuildTupleDesc().

 {
     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;
 
     ScanKeyInit(&skey,
                 Anum_pg_attrdef_adrelid,
                 BTEqualStrategyNumber, F_OIDEQ,
                 ObjectIdGetDatum(RelationGetRelid(relation)));
 
     adrel = table_open(AttrDefaultRelationId, AccessShareLock);
     adscan = systable_beginscan(adrel, AttrDefaultIndexId, true,
                                 NULL, 1, &skey);
     found = 0;
 
     while (HeapTupleIsValid(htup = systable_getnext(adscan)))
     {
         Form_pg_attrdef adform = (Form_pg_attrdef) GETSTRUCT(htup);
         Form_pg_attribute attr = TupleDescAttr(relation->rd_att, adform->adnum - 1);
 
         for (i = 0; i < ndef; i++)
         {
             if (adform->adnum != attrdef[i].adnum)
                 continue;
             if (attrdef[i].adbin != NULL)
                 elog(WARNING, "multiple attrdef records found for attr %s of rel %s",
                      NameStr(attr->attname),
                      RelationGetRelationName(relation));
             else
                 found++;
 
             val = fastgetattr(htup,
                               Anum_pg_attrdef_adbin,
                               adrel->rd_att, &isnull);
             if (isnull)
                 elog(WARNING, "null adbin for attr %s of rel %s",
                      NameStr(attr->attname),
                      RelationGetRelationName(relation));
             else
             {
                 /* detoast and convert to cstring in caller's context */
                 char       *s = TextDatumGetCString(val);
 
                 attrdef[i].adbin = MemoryContextStrdup(CacheMemoryContext, s);
                 pfree(s);
             }
             break;
         }
 
         if (i >= ndef)
             elog(WARNING, "unexpected attrdef record found for attr %d of rel %s",
                  adform->adnum, RelationGetRelationName(relation));
     }
 
     systable_endscan(adscan);
     table_close(adrel, AccessShareLock);
 }

◆ BuildHardcodedDescriptor()

static TupleDesc BuildHardcodedDescriptor	(	int	natts,
		const FormData_pg_attribute *	attrs
	)

static

Definition at line 3998 of file relcache.c.

References ATTRIBUTE_FIXED_PART_SIZE, CacheMemoryContext, CreateTemplateTupleDesc(), i, MemoryContextSwitchTo(), TupleDescData::tdtypeid, TupleDescData::tdtypmod, and TupleDescAttr.

Referenced by GetPgClassDescriptor(), and GetPgIndexDescriptor().

 {
     TupleDesc   result;
     MemoryContext oldcxt;
     int         i;
 
     oldcxt = MemoryContextSwitchTo(CacheMemoryContext);
 
     result = CreateTemplateTupleDesc(natts);
     result->tdtypeid = RECORDOID;   /* not right, but we don't care */
     result->tdtypmod = -1;
 
     for (i = 0; i < natts; i++)
     {
         memcpy(TupleDescAttr(result, i), &attrs[i], ATTRIBUTE_FIXED_PART_SIZE);
         /* make sure attcacheoff is valid */
         TupleDescAttr(result, i)->attcacheoff = -1;
     }
 
     /* initialize first attribute's attcacheoff, cf RelationBuildTupleDesc */
     TupleDescAttr(result, 0)->attcacheoff = 0;
 
     /* Note: we don't bother to set up a TupleConstr entry */
 
     MemoryContextSwitchTo(oldcxt);
 
     return result;
 }

◆ CheckConstraintCmp()

static int CheckConstraintCmp	(	const void *	a,
		const void *	b
	)

static

Definition at line 4198 of file relcache.c.

References ConstrCheck::ccname.

Referenced by CheckConstraintFetch().

 {
     const ConstrCheck *ca = (const ConstrCheck *) a;
     const ConstrCheck *cb = (const ConstrCheck *) b;
 
     return strcmp(ca->ccname, cb->ccname);
 }

◆ CheckConstraintFetch()

static void CheckConstraintFetch ( Relation relation )

static

Definition at line 4127 of file relcache.c.

References AccessShareLock, BTEqualStrategyNumber, CacheMemoryContext, ConstrCheck::ccbin, ConstrCheck::ccname, ConstrCheck::ccnoinherit, ConstrCheck::ccvalid, TupleConstr::check, CheckConstraintCmp(), TupleDescData::constr, ConstraintRelidTypidNameIndexId, elog, ERROR, fastgetattr, GETSTRUCT, HeapTupleIsValid, MemoryContextStrdup(), NameStr, TupleConstr::num_check, ObjectIdGetDatum, pfree(), qsort, RelationData::rd_att, RelationGetRelationName, RelationGetRelid, ScanKeyInit(), systable_beginscan(), systable_endscan(), systable_getnext(), table_close(), table_open(), TextDatumGetCString, and val.

Referenced by RelationBuildTupleDesc().

 {
     ConstrCheck *check = relation->rd_att->constr->check;
     int         ncheck = relation->rd_att->constr->num_check;
     Relation    conrel;
     SysScanDesc conscan;
     ScanKeyData skey[1];
     HeapTuple   htup;
     int         found = 0;
 
     ScanKeyInit(&skey[0],
                 Anum_pg_constraint_conrelid,
                 BTEqualStrategyNumber, F_OIDEQ,
                 ObjectIdGetDatum(RelationGetRelid(relation)));
 
     conrel = table_open(ConstraintRelationId, AccessShareLock);
     conscan = systable_beginscan(conrel, ConstraintRelidTypidNameIndexId, true,
                                  NULL, 1, skey);
 
     while (HeapTupleIsValid(htup = systable_getnext(conscan)))
     {
         Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(htup);
         Datum       val;
         bool        isnull;
         char       *s;
 
         /* We want check constraints only */
         if (conform->contype != CONSTRAINT_CHECK)
             continue;
 
         if (found >= ncheck)
             elog(ERROR, "unexpected constraint record found for rel %s",
                  RelationGetRelationName(relation));
 
         check[found].ccvalid = conform->convalidated;
         check[found].ccnoinherit = conform->connoinherit;
         check[found].ccname = MemoryContextStrdup(CacheMemoryContext,
                                                   NameStr(conform->conname));
 
         /* Grab and test conbin is actually set */
         val = fastgetattr(htup,
                           Anum_pg_constraint_conbin,
                           conrel->rd_att, &isnull);
         if (isnull)
             elog(ERROR, "null conbin for rel %s",
                  RelationGetRelationName(relation));
 
         /* detoast and convert to cstring in caller's context */
         s = TextDatumGetCString(val);
         check[found].ccbin = MemoryContextStrdup(CacheMemoryContext, s);
         pfree(s);
 
         found++;
     }
 
     systable_endscan(conscan);
     table_close(conrel, AccessShareLock);
 
     if (found != ncheck)
         elog(ERROR, "%d constraint record(s) missing for rel %s",
              ncheck - found, RelationGetRelationName(relation));
 
     /* Sort the records so that CHECKs are applied in a deterministic order */
     if (ncheck > 1)
         qsort(check, ncheck, sizeof(ConstrCheck), CheckConstraintCmp);
 }

◆ equalPolicy()

static bool equalPolicy	(	RowSecurityPolicy *	policy1,
		RowSecurityPolicy *	policy2
	)

static

Definition at line 932 of file relcache.c.

References ARR_DATA_PTR, ARR_DIMS, equal(), RowSecurityPolicy::hassublinks, i, RowSecurityPolicy::polcmd, RowSecurityPolicy::policy_name, RowSecurityPolicy::qual, RowSecurityPolicy::roles, and RowSecurityPolicy::with_check_qual.

Referenced by equalRSDesc().

 {
     int         i;
     Oid        *r1,
                *r2;
 
     if (policy1 != NULL)
     {
         if (policy2 == NULL)
             return false;
 
         if (policy1->polcmd != policy2->polcmd)
             return false;
         if (policy1->hassublinks != policy2->hassublinks)
             return false;
         if (strcmp(policy1->policy_name, policy2->policy_name) != 0)
             return false;
         if (ARR_DIMS(policy1->roles)[0] != ARR_DIMS(policy2->roles)[0])
             return false;
 
         r1 = (Oid *) ARR_DATA_PTR(policy1->roles);
         r2 = (Oid *) ARR_DATA_PTR(policy2->roles);
 
         for (i = 0; i < ARR_DIMS(policy1->roles)[0]; i++)
         {
             if (r1[i] != r2[i])
                 return false;
         }
 
         if (!equal(policy1->qual, policy2->qual))
             return false;
         if (!equal(policy1->with_check_qual, policy2->with_check_qual))
             return false;
     }
     else if (policy2 != NULL)
         return false;
 
     return true;
 }

◆ equalRSDesc()

static bool equalRSDesc	(	RowSecurityDesc *	rsdesc1,
		RowSecurityDesc *	rsdesc2
	)

static

Definition at line 978 of file relcache.c.

References equalPolicy(), forboth, lfirst, list_length(), and RowSecurityDesc::policies.

Referenced by RelationClearRelation().

 {
     ListCell   *lc,
                *rc;
 
     if (rsdesc1 == NULL && rsdesc2 == NULL)
         return true;
 
     if ((rsdesc1 != NULL && rsdesc2 == NULL) ||
         (rsdesc1 == NULL && rsdesc2 != NULL))
         return false;
 
     if (list_length(rsdesc1->policies) != list_length(rsdesc2->policies))
         return false;
 
     /* RelationBuildRowSecurity should build policies in order */
     forboth(lc, rsdesc1->policies, rc, rsdesc2->policies)
     {
         RowSecurityPolicy *l = (RowSecurityPolicy *) lfirst(lc);
         RowSecurityPolicy *r = (RowSecurityPolicy *) lfirst(rc);
 
         if (!equalPolicy(l, r))
             return false;
     }
 
     return true;
 }

◆ equalRuleLocks()

static bool equalRuleLocks	(	RuleLock *	rlock1,
		RuleLock *	rlock2
	)

static

Definition at line 887 of file relcache.c.

References RewriteRule::actions, RewriteRule::enabled, equal(), RewriteRule::event, i, RewriteRule::isInstead, RuleLock::numLocks, RewriteRule::qual, RewriteRule::ruleId, and RuleLock::rules.

Referenced by RelationClearRelation().

 {
     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->enabled != rule2->enabled)
                 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;
 }

◆ errtable()

int errtable ( Relation rel )

Definition at line 5201 of file relcache.c.

References err_generic_string(), get_namespace_name(), PG_DIAG_SCHEMA_NAME, PG_DIAG_TABLE_NAME, RelationGetNamespace, and RelationGetRelationName.

Referenced by ATPrepChangePersistence(), BuildRelationExtStatistics(), errtablecolname(), and errtableconstraint().

 {
     err_generic_string(PG_DIAG_SCHEMA_NAME,
                        get_namespace_name(RelationGetNamespace(rel)));
     err_generic_string(PG_DIAG_TABLE_NAME, RelationGetRelationName(rel));
 
     return 0;                   /* return value does not matter */
 }

◆ errtablecol()

int errtablecol	(	Relation	rel,
		int	attnum
	)

Definition at line 5218 of file relcache.c.

References attname, errtablecolname(), get_attname(), NameStr, RelationGetDescr, RelationGetRelid, relidcacheent::reldesc, and TupleDescAttr.

Referenced by AlterDomainNotNull(), ATRewriteTable(), ExecConstraints(), and validateDomainConstraint().

 {
     TupleDesc   reldesc = RelationGetDescr(rel);
     const char *colname;
 
     /* Use reldesc if it's a user attribute, else consult the catalogs */
     if (attnum > 0 && attnum <= reldesc->natts)
         colname = NameStr(TupleDescAttr(reldesc, attnum - 1)->attname);
     else
         colname = get_attname(RelationGetRelid(rel), attnum, false);
 
     return errtablecolname(rel, colname);
 }

◆ errtablecolname()

int errtablecolname	(	Relation	rel,
		const char *	colname
	)

Definition at line 5242 of file relcache.c.

References err_generic_string(), errtable(), and PG_DIAG_COLUMN_NAME.

Referenced by errtablecol().

 {
     errtable(rel);
     err_generic_string(PG_DIAG_COLUMN_NAME, colname);
 
     return 0;                   /* return value does not matter */
 }

◆ errtableconstraint()

int errtableconstraint	(	Relation	rel,
		const char *	conname
	)

Definition at line 5255 of file relcache.c.

References err_generic_string(), errtable(), and PG_DIAG_CONSTRAINT_NAME.

Referenced by _bt_check_third_page(), _bt_check_unique(), ATPrepChangePersistence(), ATRewriteTable(), check_exclusion_or_unique_constraint(), comparetup_index_btree(), ExecCheckIndexConstraints(), ExecConstraints(), RI_FKey_check(), RI_Initial_Check(), ri_ReportViolation(), and validateCheckConstraint().

 {
     errtable(rel);
     err_generic_string(PG_DIAG_CONSTRAINT_NAME, conname);
 
     return 0;                   /* return value does not matter */
 }

◆ formrdesc()

static void formrdesc	(	const char *	relationName,
		Oid	relationReltype,
		bool	isshared,
		int	natts,
		const FormData_pg_attribute *	attrs
	)

static

Definition at line 1789 of file relcache.c.

References ATTRIBUTE_FIXED_PART_SIZE, CLASS_TUPLE_SIZE, TupleDescData::constr, CreateTemplateTupleDesc(), GetHeapamTableAmRoutine(), TupleConstr::has_not_null, i, InvalidBackendId, InvalidOid, InvalidSubTransactionId, IsBootstrapProcessingMode, namestrcpy(), palloc0(), RelationData::rd_att, RelationData::rd_backend, RelationData::rd_createSubid, RelationData::rd_islocaltemp, RelationData::rd_isnailed, RelationData::rd_isvalid, RelationData::rd_newRelfilenodeSubid, RelationData::rd_refcnt, RelationData::rd_rel, RelationData::rd_smgr, RelationData::rd_tableam, RelationCacheInsert, RelationGetRelid, RelationInitLockInfo(), RelationInitPhysicalAddr(), RelationMapUpdateMap(), TupleDescData::tdrefcount, TupleDescData::tdtypeid, TupleDescData::tdtypmod, and TupleDescAttr.

Referenced by RelationCacheInitializePhase2(), and RelationCacheInitializePhase3().

 {
     Relation    relation;
     int         i;
     bool        has_not_null;
 
     /*
      * allocate new relation desc, clear all fields of reldesc
      */
     relation = (Relation) palloc0(sizeof(RelationData));
 
     /* make sure relation is marked as having no open file yet */
     relation->rd_smgr = NULL;
 
     /*
      * initialize reference count: 1 because it is nailed in cache
      */
     relation->rd_refcnt = 1;
 
     /*
      * all entries built with this routine are nailed-in-cache; none are for
      * new or temp relations.
      */
     relation->rd_isnailed = true;
     relation->rd_createSubid = InvalidSubTransactionId;
     relation->rd_newRelfilenodeSubid = InvalidSubTransactionId;
     relation->rd_backend = InvalidBackendId;
     relation->rd_islocaltemp = false;
 
     /*
      * initialize relation tuple form
      *
      * The data we insert here is pretty incomplete/bogus, but it'll serve to
      * get us launched.  RelationCacheInitializePhase3() will read the real
      * data from pg_class and replace what we've done here.  Note in
      * particular that relowner is left as zero; this cues
      * RelationCacheInitializePhase3 that the real data isn't there yet.
      */
     relation->rd_rel = (Form_pg_class) palloc0(CLASS_TUPLE_SIZE);
 
     namestrcpy(&relation->rd_rel->relname, relationName);
     relation->rd_rel->relnamespace = PG_CATALOG_NAMESPACE;
     relation->rd_rel->reltype = relationReltype;
 
     /*
      * It's important to distinguish between shared and non-shared relations,
      * even at bootstrap time, to make sure we know where they are stored.
      */
     relation->rd_rel->relisshared = isshared;
     if (isshared)
         relation->rd_rel->reltablespace = GLOBALTABLESPACE_OID;
 
     /* formrdesc is used only for permanent relations */
     relation->rd_rel->relpersistence = RELPERSISTENCE_PERMANENT;
 
     /* ... and they're always populated, too */
     relation->rd_rel->relispopulated = true;
 
     relation->rd_rel->relreplident = REPLICA_IDENTITY_NOTHING;
     relation->rd_rel->relpages = 0;
     relation->rd_rel->reltuples = 0;
     relation->rd_rel->relallvisible = 0;
     relation->rd_rel->relkind = RELKIND_RELATION;
     relation->rd_rel->relnatts = (int16) natts;
     relation->rd_rel->relam = HEAP_TABLE_AM_OID;
 
     /*
      * initialize attribute tuple form
      *
      * Unlike the case with the relation tuple, this data had better be right
      * because it will never be replaced.  The data comes from
      * src/include/catalog/ headers via genbki.pl.
      */
     relation->rd_att = CreateTemplateTupleDesc(natts);
     relation->rd_att->tdrefcount = 1;   /* mark as refcounted */
 
     relation->rd_att->tdtypeid = relationReltype;
     relation->rd_att->tdtypmod = -1;    /* unnecessary, but... */
 
     /*
      * initialize tuple desc info
      */
     has_not_null = false;
     for (i = 0; i < natts; i++)
     {
         memcpy(TupleDescAttr(relation->rd_att, i),
                &attrs[i],
                ATTRIBUTE_FIXED_PART_SIZE);
         has_not_null |= attrs[i].attnotnull;
         /* make sure attcacheoff is valid */
         TupleDescAttr(relation->rd_att, i)->attcacheoff = -1;
     }
 
     /* initialize first attribute's attcacheoff, cf RelationBuildTupleDesc */
     TupleDescAttr(relation->rd_att, 0)->attcacheoff = 0;
 
     /* mark not-null status */
     if (has_not_null)
     {
         TupleConstr *constr = (TupleConstr *) palloc0(sizeof(TupleConstr));
 
         constr->has_not_null = true;
         relation->rd_att->constr = constr;
     }
 
     /*
      * initialize relation id from info in att array (my, this is ugly)
      */
     RelationGetRelid(relation) = TupleDescAttr(relation->rd_att, 0)->attrelid;
 
     /*
      * All relations made with formrdesc are mapped.  This is necessarily so
      * because there is no other way to know what filenode they currently
      * have.  In bootstrap mode, add them to the initial relation mapper data,
      * specifying that the initial filenode is the same as the OID.
      */
     relation->rd_rel->relfilenode = InvalidOid;
     if (IsBootstrapProcessingMode())
         RelationMapUpdateMap(RelationGetRelid(relation),
                              RelationGetRelid(relation),
                              isshared, true);
 
     /*
      * initialize the relation lock manager information
      */
     RelationInitLockInfo(relation); /* see lmgr.c */
 
     /*
      * initialize physical addressing information for the relation
      */
     RelationInitPhysicalAddr(relation);
 
     /*
      * initialize the table am handler
      */
     relation->rd_rel->relam = HEAP_TABLE_AM_OID;
     relation->rd_tableam = GetHeapamTableAmRoutine();
 
     /*
      * initialize the rel-has-index flag, using hardwired knowledge
      */
     if (IsBootstrapProcessingMode())
     {
         /* In bootstrap mode, we have no indexes */
         relation->rd_rel->relhasindex = false;
     }
     else
     {
         /* Otherwise, all the rels formrdesc is used for have indexes */
         relation->rd_rel->relhasindex = true;
     }
 
     /*
      * add new reldesc to relcache
      */
     RelationCacheInsert(relation, false);
 
     /* It's fully valid */
     relation->rd_isvalid = true;
 }

◆ GetPgClassDescriptor()

static TupleDesc GetPgClassDescriptor ( void )

static

Definition at line 4028 of file relcache.c.

References BuildHardcodedDescriptor(), and Desc_pg_class.

Referenced by RelationParseRelOptions().

 {
     static TupleDesc pgclassdesc = NULL;
 
     /* Already done? */
     if (pgclassdesc == NULL)
         pgclassdesc = BuildHardcodedDescriptor(Natts_pg_class,
                                                Desc_pg_class);
 
     return pgclassdesc;
 }

◆ GetPgIndexDescriptor()

static TupleDesc GetPgIndexDescriptor ( void )

static

Definition at line 4041 of file relcache.c.

References BuildHardcodedDescriptor(), and Desc_pg_index.

Referenced by RelationGetDummyIndexExpressions(), RelationGetIndexAttrBitmap(), RelationGetIndexExpressions(), RelationGetIndexPredicate(), and RelationInitIndexAccessInfo().

 {
     static TupleDesc pgindexdesc = NULL;
 
     /* Already done? */
     if (pgindexdesc == NULL)
         pgindexdesc = BuildHardcodedDescriptor(Natts_pg_index,
                                                Desc_pg_index);
 
     return pgindexdesc;
 }

◆ GetRelationPublicationActions()

struct PublicationActions* GetRelationPublicationActions ( Relation relation )

Definition at line 5122 of file relcache.c.

References CacheMemoryContext, elog, ERROR, GetAllTablesPublications(), GetRelationPublications(), GETSTRUCT, HeapTupleIsValid, is_publishable_relation(), lfirst_oid, list_concat_unique_oid(), MemoryContextSwitchTo(), ObjectIdGetDatum, palloc(), palloc0(), pfree(), PublicationActions::pubdelete, PublicationActions::pubinsert, PUBLICATIONOID, PublicationActions::pubtruncate, PublicationActions::pubupdate, RelationData::rd_pubactions, RelationGetRelid, ReleaseSysCache(), and SearchSysCache1().

Referenced by CheckCmdReplicaIdentity().

 {
     List       *puboids;
     ListCell   *lc;
     MemoryContext oldcxt;
     PublicationActions *pubactions = palloc0(sizeof(PublicationActions));
 
     /*
      * If not publishable, it publishes no actions.  (pgoutput_change() will
      * ignore it.)
      */
     if (!is_publishable_relation(relation))
         return pubactions;
 
     if (relation->rd_pubactions)
         return memcpy(pubactions, relation->rd_pubactions,
                       sizeof(PublicationActions));
 
     /* Fetch the publication membership info. */
     puboids = GetRelationPublications(RelationGetRelid(relation));
     puboids = list_concat_unique_oid(puboids, GetAllTablesPublications());
 
     foreach(lc, puboids)
     {
         Oid         pubid = lfirst_oid(lc);
         HeapTuple   tup;
         Form_pg_publication pubform;
 
         tup = SearchSysCache1(PUBLICATIONOID, ObjectIdGetDatum(pubid));
 
         if (!HeapTupleIsValid(tup))
             elog(ERROR, "cache lookup failed for publication %u", pubid);
 
         pubform = (Form_pg_publication) GETSTRUCT(tup);
 
         pubactions->pubinsert |= pubform->pubinsert;
         pubactions->pubupdate |= pubform->pubupdate;
         pubactions->pubdelete |= pubform->pubdelete;
         pubactions->pubtruncate |= pubform->pubtruncate;
 
         ReleaseSysCache(tup);
 
         /*
          * If we know everything is replicated, there is no point to check for
          * other publications.
          */
         if (pubactions->pubinsert && pubactions->pubupdate &&
             pubactions->pubdelete && pubactions->pubtruncate)
             break;
     }
 
     if (relation->rd_pubactions)
     {
         pfree(relation->rd_pubactions);
         relation->rd_pubactions = NULL;
     }
 
     /* Now save copy of the actions in the relcache entry. */
     oldcxt = MemoryContextSwitchTo(CacheMemoryContext);
     relation->rd_pubactions = palloc(sizeof(PublicationActions));
     memcpy(relation->rd_pubactions, pubactions, sizeof(PublicationActions));
     MemoryContextSwitchTo(oldcxt);
 
     return pubactions;
 }

◆ IndexSupportInitialize()

static void IndexSupportInitialize	(	oidvector *	indclass,
		RegProcedure *	indexSupport,
		Oid *	opFamily,
		Oid *	opcInType,
		StrategyNumber	maxSupportNumber,
		AttrNumber	maxAttributeNumber
	)

static

Definition at line 1515 of file relcache.c.

References elog, ERROR, LookupOpclassInfo(), OidIsValid, opclasscacheent::opcfamily, opclasscacheent::opcintype, opclasscacheent::supportProcs, and oidvector::values.

Referenced by RelationInitIndexAccessInfo().

 {
     int         attIndex;
 
     for (attIndex = 0; attIndex < maxAttributeNumber; attIndex++)
     {
         OpClassCacheEnt *opcentry;
 
         if (!OidIsValid(indclass->values[attIndex]))
             elog(ERROR, "bogus pg_index tuple");
 
         /* look up the info for this opclass, using a cache */
         opcentry = LookupOpclassInfo(indclass->values[attIndex],
                                      maxSupportNumber);
 
         /* copy cached data into relcache entry */
         opFamily[attIndex] = opcentry->opcfamily;
         opcInType[attIndex] = opcentry->opcintype;
         if (maxSupportNumber > 0)
             memcpy(&indexSupport[attIndex * maxSupportNumber],
                    opcentry->supportProcs,
                    maxSupportNumber * sizeof(RegProcedure));
     }
 }

◆ InitIndexAmRoutine()

static void InitIndexAmRoutine ( Relation relation )

static

Definition at line 1323 of file relcache.c.

References GetIndexAmRoutine(), MemoryContextAlloc(), pfree(), RelationData::rd_amhandler, RelationData::rd_indam, and RelationData::rd_indexcxt.

Referenced by load_relcache_init_file(), and RelationInitIndexAccessInfo().

 {
     IndexAmRoutine *cached,
                *tmp;
 
     /*
      * Call the amhandler in current, short-lived memory context, just in case
      * it leaks anything (it probably won't, but let's be paranoid).
      */
     tmp = GetIndexAmRoutine(relation->rd_amhandler);
 
     /* OK, now transfer the data into relation's rd_indexcxt. */
     cached = (IndexAmRoutine *) MemoryContextAlloc(relation->rd_indexcxt,
                                                    sizeof(IndexAmRoutine));
     memcpy(cached, tmp, sizeof(IndexAmRoutine));
     relation->rd_indam = cached;
 
     pfree(tmp);
 }

◆ InitTableAmRoutine()

static void InitTableAmRoutine ( Relation relation )

static

Definition at line 1716 of file relcache.c.

References GetTableAmRoutine(), RelationData::rd_amhandler, and RelationData::rd_tableam.

Referenced by RelationInitTableAccessMethod().

 {
     relation->rd_tableam = GetTableAmRoutine(relation->rd_amhandler);
 }

◆ load_critical_index()

static void load_critical_index	(	Oid	indexoid,
		Oid	heapoid
	)

static

Definition at line 3964 of file relcache.c.

References AccessShareLock, elog, LockRelationOid(), PANIC, RelationData::rd_isnailed, RelationData::rd_refcnt, RelationBuildDesc(), and UnlockRelationOid().

Referenced by RelationCacheInitializePhase3().

 {
     Relation    ird;
 
     /*
      * We must lock the underlying catalog before locking the index to avoid
      * deadlock, since RelationBuildDesc might well need to read the catalog,
      * and if anyone else is exclusive-locking this catalog and index they'll
      * be doing it in that order.
      */
     LockRelationOid(heapoid, AccessShareLock);
     LockRelationOid(indexoid, AccessShareLock);
     ird = RelationBuildDesc(indexoid, true);
     if (ird == NULL)
         elog(PANIC, "could not open critical system index %u", indexoid);
     ird->rd_isnailed = true;
     ird->rd_refcnt = 1;
     UnlockRelationOid(indexoid, AccessShareLock);
     UnlockRelationOid(heapoid, AccessShareLock);
 }

◆ load_relcache_init_file()

static bool load_relcache_init_file ( bool shared )

static

Definition at line 5319 of file relcache.c.

Referenced by RelationCacheInitializePhase2(), and RelationCacheInitializePhase3().

 {
     FILE       *fp;
     char        initfilename[MAXPGPATH];
     Relation   *rels;
     int         relno,
                 num_rels,
                 max_rels,
                 nailed_rels,
                 nailed_indexes,
                 magic;
     int         i;
 
     if (shared)
         snprintf(initfilename, sizeof(initfilename), "global/%s",
                  RELCACHE_INIT_FILENAME);
     else
         snprintf(initfilename, sizeof(initfilename), "%s/%s",
                  DatabasePath, RELCACHE_INIT_FILENAME);
 
     fp = AllocateFile(initfilename, PG_BINARY_R);
     if (fp == NULL)
         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;
 
     /* check for correct magic number (compatible version) */
     if (fread(&magic, 1, sizeof(magic), fp) != sizeof(magic))
         goto read_failed;
     if (magic != RELCACHE_INIT_FILEMAGIC)
         goto read_failed;
 
     for (relno = 0;; relno++)
     {
         Size        len;
         size_t      nread;
         Relation    rel;
         Form_pg_class relform;
         bool        has_not_null;
 
         /* first read the relation descriptor length */
         nread = fread(&len, 1, sizeof(len), fp);
         if (nread != 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 (fread(rel, 1, len, fp) != len)
             goto read_failed;
 
         /* next read the relation tuple form */
         if (fread(&len, 1, sizeof(len), fp) != sizeof(len))
             goto read_failed;
 
         relform = (Form_pg_class) palloc(len);
         if (fread(relform, 1, len, fp) != len)
             goto read_failed;
 
         rel->rd_rel = relform;
 
         /* initialize attribute tuple forms */
         rel->rd_att = CreateTemplateTupleDesc(relform->relnatts);
         rel->rd_att->tdrefcount = 1;    /* mark as refcounted */
 
         rel->rd_att->tdtypeid = relform->reltype;
         rel->rd_att->tdtypmod = -1; /* unnecessary, but... */
 
         /* next read all the attribute tuple form data entries */
         has_not_null = false;
         for (i = 0; i < relform->relnatts; i++)
         {
             Form_pg_attribute attr = TupleDescAttr(rel->rd_att, i);
 
             if (fread(&len, 1, sizeof(len), fp) != sizeof(len))
                 goto read_failed;
             if (len != ATTRIBUTE_FIXED_PART_SIZE)
                 goto read_failed;
             if (fread(attr, 1, len, fp) != len)
                 goto read_failed;
 
             has_not_null |= attr->attnotnull;
         }
 
         /* next read the access method specific field */
         if (fread(&len, 1, sizeof(len), fp) != sizeof(len))
             goto read_failed;
         if (len > 0)
         {
             rel->rd_options = palloc(len);
             if (fread(rel->rd_options, 1, len, fp) != len)
                 goto read_failed;
             if (len != VARSIZE(rel->rd_options))
                 goto read_failed;   /* sanity check */
         }
         else
         {
             rel->rd_options = NULL;
         }
 
         /* mark not-null status */
         if (has_not_null)
         {
             TupleConstr *constr = (TupleConstr *) palloc0(sizeof(TupleConstr));
 
             constr->has_not_null = true;
             rel->rd_att->constr = constr;
         }
 
         /*
          * If it's an index, there's more to do.  Note we explicitly ignore
          * partitioned indexes here.
          */
         if (rel->rd_rel->relkind == RELKIND_INDEX)
         {
             MemoryContext indexcxt;
             Oid        *opfamily;
             Oid        *opcintype;
             RegProcedure *support;
             int         nsupport;
             int16      *indoption;
             Oid        *indcollation;
 
             /* Count nailed indexes to ensure we have 'em all */
             if (rel->rd_isnailed)
                 nailed_indexes++;
 
             /* next, read the pg_index tuple */
             if (fread(&len, 1, sizeof(len), fp) != sizeof(len))
                 goto read_failed;
 
             rel->rd_indextuple = (HeapTuple) palloc(len);
             if (fread(rel->rd_indextuple, 1, len, fp) != len)
                 goto read_failed;
 
             /* Fix up internal pointers in the tuple -- see heap_copytuple */
             rel->rd_indextuple->t_data = (HeapTupleHeader) ((char *) rel->rd_indextuple + HEAPTUPLESIZE);
             rel->rd_index = (Form_pg_index) GETSTRUCT(rel->rd_indextuple);
 
             /*
              * prepare index info context --- parameters should match
              * RelationInitIndexAccessInfo
              */
             indexcxt = AllocSetContextCreate(CacheMemoryContext,
                                              "index info",
                                              ALLOCSET_SMALL_SIZES);
             rel->rd_indexcxt = indexcxt;
             MemoryContextCopyAndSetIdentifier(indexcxt,
                                               RelationGetRelationName(rel));
 
             /*
              * Now we can fetch the index AM's API struct.  (We can't store
              * that in the init file, since it contains function pointers that
              * might vary across server executions.  Fortunately, it should be
              * safe to call the amhandler even while bootstrapping indexes.)
              */
             InitIndexAmRoutine(rel);
 
             /* next, read the vector of opfamily OIDs */
             if (fread(&len, 1, sizeof(len), fp) != sizeof(len))
                 goto read_failed;
 
             opfamily = (Oid *) MemoryContextAlloc(indexcxt, len);
             if (fread(opfamily, 1, len, fp) != len)
                 goto read_failed;
 
             rel->rd_opfamily = opfamily;
 
             /* next, read the vector of opcintype OIDs */
             if (fread(&len, 1, sizeof(len), fp) != sizeof(len))
                 goto read_failed;
 
             opcintype = (Oid *) MemoryContextAlloc(indexcxt, len);
             if (fread(opcintype, 1, len, fp) != len)
                 goto read_failed;
 
             rel->rd_opcintype = opcintype;
 
             /* next, read the vector of support procedure OIDs */
             if (fread(&len, 1, sizeof(len), fp) != sizeof(len))
                 goto read_failed;
             support = (RegProcedure *) MemoryContextAlloc(indexcxt, len);
             if (fread(support, 1, len, fp) != len)
                 goto read_failed;
 
             rel->rd_support = support;
 
             /* next, read the vector of collation OIDs */
             if (fread(&len, 1, sizeof(len), fp) != sizeof(len))
                 goto read_failed;
 
             indcollation = (Oid *) MemoryContextAlloc(indexcxt, len);
             if (fread(indcollation, 1, len, fp) != len)
                 goto read_failed;
 
             rel->rd_indcollation = indcollation;
 
             /* finally, read the vector of indoption values */
             if (fread(&len, 1, sizeof(len), fp) != sizeof(len))
                 goto read_failed;
 
             indoption = (int16 *) MemoryContextAlloc(indexcxt, len);
             if (fread(indoption, 1, len, fp) != len)
                 goto read_failed;
 
             rel->rd_indoption = indoption;
 
             /* set up zeroed fmgr-info vector */
             nsupport = relform->relnatts * rel->rd_indam->amsupport;
             rel->rd_supportinfo = (FmgrInfo *)
                 MemoryContextAllocZero(indexcxt, nsupport * sizeof(FmgrInfo));
         }
         else
         {
             /* Count nailed rels to ensure we have 'em all */
             if (rel->rd_isnailed)
                 nailed_rels++;
 
             /* Load table AM data */
             if (rel->rd_rel->relkind == RELKIND_RELATION ||
                 rel->rd_rel->relkind == RELKIND_SEQUENCE ||
                 rel->rd_rel->relkind == RELKIND_TOASTVALUE ||
                 rel->rd_rel->relkind == RELKIND_MATVIEW)
                 RelationInitTableAccessMethod(rel);
 
             Assert(rel->rd_index == NULL);
             Assert(rel->rd_indextuple == NULL);
             Assert(rel->rd_indexcxt == NULL);
             Assert(rel->rd_indam == NULL);
             Assert(rel->rd_opfamily == NULL);
             Assert(rel->rd_opcintype == NULL);
             Assert(rel->rd_support == NULL);
             Assert(rel->rd_supportinfo == NULL);
             Assert(rel->rd_indoption == NULL);
             Assert(rel->rd_indcollation == 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 RelationCacheInitializePhase3.  This is not expected to
          * be a big performance hit since few system catalogs have such. Ditto
          * for RLS policy data, partition info, index expressions, predicates,
          * exclusion info, and FDW info.
          */
         rel->rd_rules = NULL;
         rel->rd_rulescxt = NULL;
         rel->trigdesc = NULL;
         rel->rd_rsdesc = NULL;
         rel->rd_partkey = NULL;
         rel->rd_partkeycxt = NULL;
         rel->rd_partdesc = NULL;
         rel->rd_pdcxt = NULL;
         rel->rd_partcheck = NIL;
         rel->rd_partcheckvalid = false;
         rel->rd_partcheckcxt = NULL;
         rel->rd_indexprs = NIL;
         rel->rd_indpred = NIL;
         rel->rd_exclops = NULL;
         rel->rd_exclprocs = NULL;
         rel->rd_exclstrats = NULL;
         rel->rd_fdwroutine = NULL;
 
         /*
          * Reset transient-state fields in the relcache entry
          */
         rel->rd_smgr = NULL;
         if (rel->rd_isnailed)
             rel->rd_refcnt = 1;
         else
             rel->rd_refcnt = 0;
         rel->rd_indexvalid = false;
         rel->rd_indexlist = NIL;
         rel->rd_pkindex = InvalidOid;
         rel->rd_replidindex = InvalidOid;
         rel->rd_indexattr = NULL;
         rel->rd_keyattr = NULL;
         rel->rd_pkattr = NULL;
         rel->rd_idattr = NULL;
         rel->rd_pubactions = NULL;
         rel->rd_statvalid = false;
         rel->rd_statlist = NIL;
         rel->rd_fkeyvalid = false;
         rel->rd_fkeylist = NIL;
         rel->rd_createSubid = InvalidSubTransactionId;
         rel->rd_newRelfilenodeSubid = InvalidSubTransactionId;
         rel->rd_amcache = NULL;
         MemSet(&rel->pgstat_info, 0, sizeof(rel->pgstat_info));
 
         /*
          * Recompute lock and physical addressing info.  This is needed in
          * case the pg_internal.init file was copied from some other database
          * by CREATE DATABASE.
          */
         RelationInitLockInfo(rel);
         RelationInitPhysicalAddr(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.  However, that should
      * not happen in a normally-running system, so let's bleat if it does.
      *
      * For the shared init file, we're called before client authentication is
      * done, which means that elog(WARNING) will go only to the postmaster
      * log, where it's easily missed.  To ensure that developers notice bad
      * values of NUM_CRITICAL_SHARED_RELS/NUM_CRITICAL_SHARED_INDEXES, we put
      * an Assert(false) there.
      */
     if (shared)
     {
         if (nailed_rels != NUM_CRITICAL_SHARED_RELS ||
             nailed_indexes != NUM_CRITICAL_SHARED_INDEXES)
         {
             elog(WARNING, "found %d nailed shared rels and %d nailed shared indexes in init file, but expected %d and %d respectively",
                  nailed_rels, nailed_indexes,
                  NUM_CRITICAL_SHARED_RELS, NUM_CRITICAL_SHARED_INDEXES);
             /* Make sure we get developers' attention about this */
             Assert(false);
             /* In production builds, recover by bootstrapping the relcache */
             goto read_failed;
         }
     }
     else
     {
         if (nailed_rels != NUM_CRITICAL_LOCAL_RELS ||
             nailed_indexes != NUM_CRITICAL_LOCAL_INDEXES)
         {
             elog(WARNING, "found %d nailed rels and %d nailed indexes in init file, but expected %d and %d respectively",
                  nailed_rels, nailed_indexes,
                  NUM_CRITICAL_LOCAL_RELS, NUM_CRITICAL_LOCAL_INDEXES);
             /* We don't need an Assert() in this case */
             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], false);
     }
 
     pfree(rels);
     FreeFile(fp);
 
     if (shared)
         criticalSharedRelcachesBuilt = true;
     else
         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);
 
     return false;
 }

◆ LookupOpclassInfo()

static OpClassCacheEnt * LookupOpclassInfo	(	Oid	operatorClassOid,
		StrategyNumber	numSupport
	)

static

Definition at line 1566 of file relcache.c.

References AccessMethodProcedureIndexId, AccessShareLock, Assert, BTEqualStrategyNumber, CacheMemoryContext, CreateCacheMemoryContext(), criticalRelcachesBuilt, elog, HASHCTL::entrysize, ERROR, GETSTRUCT, HASH_BLOBS, hash_create(), HASH_ELEM, HASH_ENTER, hash_search(), HeapTupleIsValid, HASHCTL::keysize, MemoryContextAllocZero(), MemSet, opclasscacheent::numSupport, ObjectIdGetDatum, opclasscacheent::opcfamily, opclasscacheent::opcintype, OpclassOidIndexId, ScanKeyInit(), opclasscacheent::supportProcs, systable_beginscan(), systable_endscan(), systable_getnext(), table_close(), table_open(), and opclasscacheent::valid.

Referenced by IndexSupportInitialize().

 {
     OpClassCacheEnt *opcentry;
     bool        found;
     Relation    rel;
     SysScanDesc scan;
     ScanKeyData skey[3];
     HeapTuple   htup;
     bool        indexOK;
 
     if (OpClassCache == NULL)
     {
         /* First time through: initialize the opclass cache */
         HASHCTL     ctl;
 
         MemSet(&ctl, 0, sizeof(ctl));
         ctl.keysize = sizeof(Oid);
         ctl.entrysize = sizeof(OpClassCacheEnt);
         OpClassCache = hash_create("Operator class cache", 64,
                                    &ctl, HASH_ELEM | HASH_BLOBS);
 
         /* Also make sure CacheMemoryContext exists */
         if (!CacheMemoryContext)
             CreateCacheMemoryContext();
     }
 
     opcentry = (OpClassCacheEnt *) hash_search(OpClassCache,
                                                (void *) &operatorClassOid,
                                                HASH_ENTER, &found);
 
     if (!found)
     {
         /* Need to allocate memory for new entry */
         opcentry->valid = false;    /* until known OK */
         opcentry->numSupport = numSupport;
 
         if (numSupport > 0)
             opcentry->supportProcs = (RegProcedure *)
                 MemoryContextAllocZero(CacheMemoryContext,
                                        numSupport * sizeof(RegProcedure));
         else
             opcentry->supportProcs = NULL;
     }
     else
     {
         Assert(numSupport == opcentry->numSupport);
     }
 
     /*
      * When testing for cache-flush hazards, we intentionally disable the
      * operator class cache and force reloading of the info on each call. This
      * is helpful because we want to test the case where a cache flush occurs
      * while we are loading the info, and it's very hard to provoke that if
      * this happens only once per opclass per backend.
      */
 #if defined(CLOBBER_CACHE_ALWAYS)
     opcentry->valid = false;
 #endif
 
     if (opcentry->valid)
         return opcentry;
 
     /*
      * Need to fill in new entry.
      *
      * To avoid infinite recursion during startup, force heap scans 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);
 
     /*
      * We have to fetch the pg_opclass row to determine its opfamily and
      * opcintype, which are needed to look up related operators and functions.
      * It'd be convenient to use the syscache here, but that probably doesn't
      * work while bootstrapping.
      */
     ScanKeyInit(&skey[0],
                 Anum_pg_opclass_oid,
                 BTEqualStrategyNumber, F_OIDEQ,
                 ObjectIdGetDatum(operatorClassOid));
     rel = table_open(OperatorClassRelationId, AccessShareLock);
     scan = systable_beginscan(rel, OpclassOidIndexId, indexOK,
                               NULL, 1, skey);
 
     if (HeapTupleIsValid(htup = systable_getnext(scan)))
     {
         Form_pg_opclass opclassform = (Form_pg_opclass) GETSTRUCT(htup);
 
         opcentry->opcfamily = opclassform->opcfamily;
         opcentry->opcintype = opclassform->opcintype;
     }
     else
         elog(ERROR, "could not find tuple for opclass %u", operatorClassOid);
 
     systable_endscan(scan);
     table_close(rel, AccessShareLock);
 
     /*
      * Scan pg_amproc to obtain support procs for the opclass.  We only fetch
      * the default ones (those with lefttype = righttype = opcintype).
      */
     if (numSupport > 0)
     {
         ScanKeyInit(&skey[0],
                     Anum_pg_amproc_amprocfamily,
                     BTEqualStrategyNumber, F_OIDEQ,
                     ObjectIdGetDatum(opcentry->opcfamily));
         ScanKeyInit(&skey[1],
                     Anum_pg_amproc_amproclefttype,
                     BTEqualStrategyNumber, F_OIDEQ,
                     ObjectIdGetDatum(opcentry->opcintype));
         ScanKeyInit(&skey[2],
                     Anum_pg_amproc_amprocrighttype,
                     BTEqualStrategyNumber, F_OIDEQ,
                     ObjectIdGetDatum(opcentry->opcintype));
         rel = table_open(AccessMethodProcedureRelationId, AccessShareLock);
         scan = systable_beginscan(rel, AccessMethodProcedureIndexId, indexOK,
                                   NULL, 3, skey);
 
         while (HeapTupleIsValid(htup = systable_getnext(scan)))
         {
             Form_pg_amproc amprocform = (Form_pg_amproc) GETSTRUCT(htup);
 
             if (amprocform->amprocnum <= 0 ||
                 (StrategyNumber) amprocform->amprocnum > numSupport)
                 elog(ERROR, "invalid amproc number %d for opclass %u",
                      amprocform->amprocnum, operatorClassOid);
 
             opcentry->supportProcs[amprocform->amprocnum - 1] =
                 amprocform->amproc;
         }
 
         systable_endscan(scan);
         table_close(rel, AccessShareLock);
     }
 
     opcentry->valid = true;
     return opcentry;
 }

◆ RelationBuildDesc()

static Relation RelationBuildDesc	(	Oid	targetRelId,
		bool	insertIt
	)

static

Definition at line 1019 of file relcache.c.

References AllocateRelationDesc(), ALLOCSET_DEFAULT_SIZES, AllocSetContextCreate, Assert, BackendIdForTempRelations, CurrentMemoryContext, elog, ERROR, GETSTRUCT, GetTempNamespaceBackendId(), heap_freetuple(), HeapTupleIsValid, InvalidBackendId, InvalidOid, InvalidSubTransactionId, isTempOrTempToastNamespace(), MemoryContextDelete(), MemoryContextSwitchTo(), NIL, RelationData::rd_backend, RelationData::rd_createSubid, RelationData::rd_fkeylist, RelationData::rd_fkeyvalid, RelationData::rd_islocaltemp, RelationData::rd_isnailed, RelationData::rd_isvalid, RelationData::rd_newRelfilenodeSubid, RelationData::rd_partcheck, RelationData::rd_partcheckcxt, RelationData::rd_partcheckvalid, RelationData::rd_partdesc, RelationData::rd_partkey, RelationData::rd_partkeycxt, RelationData::rd_pdcxt, RelationData::rd_refcnt, RelationData::rd_rel, RelationData::rd_rsdesc, RelationData::rd_rules, RelationData::rd_rulescxt, RelationData::rd_smgr, RelationBuildRowSecurity(), RelationBuildRuleLock(), RelationBuildTriggers(), RelationBuildTupleDesc(), RelationCacheInsert, RelationGetRelid, RelationInitIndexAccessInfo(), RelationInitLockInfo(), RelationInitPhysicalAddr(), RelationInitTableAccessMethod(), RelationParseRelOptions(), ScanPgRelation(), and RelationData::trigdesc.

Referenced by load_critical_index(), RelationClearRelation(), and RelationIdGetRelation().

 {
     Relation    relation;
     Oid         relid;
     HeapTuple   pg_class_tuple;
     Form_pg_class relp;
 
     /*
      * This function and its subroutines can allocate a good deal of transient
      * data in CurrentMemoryContext.  Traditionally we've just leaked that
      * data, reasoning that the caller's context is at worst of transaction
      * scope, and relcache loads shouldn't happen so often that it's essential
      * to recover transient data before end of statement/transaction.  However
      * that's definitely not true in clobber-cache test builds, and perhaps
      * it's not true in other cases.  If RECOVER_RELATION_BUILD_MEMORY is not
      * zero, arrange to allocate the junk in a temporary context that we'll
      * free before returning.  Make it a child of caller's context so that it
      * will get cleaned up appropriately if we error out partway through.
      */
 #if RECOVER_RELATION_BUILD_MEMORY
     MemoryContext tmpcxt;
     MemoryContext oldcxt;
 
     tmpcxt = AllocSetContextCreate(CurrentMemoryContext,
                                    "RelationBuildDesc workspace",
                                    ALLOCSET_DEFAULT_SIZES);
     oldcxt = MemoryContextSwitchTo(tmpcxt);
 #endif
 
     /*
      * find the tuple in pg_class corresponding to the given relation id
      */
     pg_class_tuple = ScanPgRelation(targetRelId, true, false);
 
     /*
      * if no such tuple exists, return NULL
      */
     if (!HeapTupleIsValid(pg_class_tuple))
     {
 #if RECOVER_RELATION_BUILD_MEMORY
         /* Return to caller's context, and blow away the temporary context */
         MemoryContextSwitchTo(oldcxt);
         MemoryContextDelete(tmpcxt);
 #endif
         return NULL;
     }
 
     /*
      * get information from the pg_class_tuple
      */
     relp = (Form_pg_class) GETSTRUCT(pg_class_tuple);
     relid = relp->oid;
     Assert(relid == targetRelId);
 
     /*
      * allocate storage for the relation descriptor, and copy pg_class_tuple
      * to relation->rd_rel.
      */
     relation = AllocateRelationDesc(relp);
 
     /*
      * initialize the relation's relation id (relation->rd_id)
      */
     RelationGetRelid(relation) = relid;
 
     /*
      * normal relations are not nailed into the cache; nor can a pre-existing
      * relation be new.  It could be temp though.  (Actually, it could be new
      * too, but it's okay to forget that fact if forced to flush the entry.)
      */
     relation->rd_refcnt = 0;
     relation->rd_isnailed = false;
     relation->rd_createSubid = InvalidSubTransactionId;
     relation->rd_newRelfilenodeSubid = InvalidSubTransactionId;
     switch (relation->rd_rel->relpersistence)
     {
         case RELPERSISTENCE_UNLOGGED:
         case RELPERSISTENCE_PERMANENT:
             relation->rd_backend = InvalidBackendId;
             relation->rd_islocaltemp = false;
             break;
         case RELPERSISTENCE_TEMP:
             if (isTempOrTempToastNamespace(relation->rd_rel->relnamespace))
             {
                 relation->rd_backend = BackendIdForTempRelations();
                 relation->rd_islocaltemp = true;
             }
             else
             {
                 /*
                  * If it's a temp table, but not one of ours, we have to use
                  * the slow, grotty method to figure out the owning backend.
                  *
                  * Note: it's possible that rd_backend gets set to MyBackendId
                  * here, in case we are looking at a pg_class entry left over
                  * from a crashed backend that coincidentally had the same
                  * BackendId we're using.  We should *not* consider such a
                  * table to be "ours"; this is why we need the separate
                  * rd_islocaltemp flag.  The pg_class entry will get flushed
                  * if/when we clean out the corresponding temp table namespace
                  * in preparation for using it.
                  */
                 relation->rd_backend =
                     GetTempNamespaceBackendId(relation->rd_rel->relnamespace);
                 Assert(relation->rd_backend != InvalidBackendId);
                 relation->rd_islocaltemp = false;
             }
             break;
         default:
             elog(ERROR, "invalid relpersistence: %c",
                  relation->rd_rel->relpersistence);
             break;
     }
 
     /*
      * initialize the tuple descriptor (relation->rd_att).
      */
     RelationBuildTupleDesc(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->relhastriggers)
         RelationBuildTriggers(relation);
     else
         relation->trigdesc = NULL;
 
     if (relation->rd_rel->relrowsecurity)
         RelationBuildRowSecurity(relation);
     else
         relation->rd_rsdesc = NULL;
 
     /* foreign key data is not loaded till asked for */
     relation->rd_fkeylist = NIL;
     relation->rd_fkeyvalid = false;
 
     /* partitioning data is not loaded till asked for */
     relation->rd_partkey = NULL;
     relation->rd_partkeycxt = NULL;
     relation->rd_partdesc = NULL;
     relation->rd_pdcxt = NULL;
     relation->rd_partcheck = NIL;
     relation->rd_partcheckvalid = false;
     relation->rd_partcheckcxt = NULL;
 
     /*
      * initialize access method information
      */
     switch (relation->rd_rel->relkind)
     {
         case RELKIND_INDEX:
         case RELKIND_PARTITIONED_INDEX:
             Assert(relation->rd_rel->relam != InvalidOid);
             RelationInitIndexAccessInfo(relation);
             break;
         case RELKIND_RELATION:
         case RELKIND_TOASTVALUE:
         case RELKIND_MATVIEW:
             Assert(relation->rd_rel->relam != InvalidOid);
             RelationInitTableAccessMethod(relation);
             break;
         case RELKIND_SEQUENCE:
             Assert(relation->rd_rel->relam == InvalidOid);
             RelationInitTableAccessMethod(relation);
             break;
         case RELKIND_VIEW:
         case RELKIND_COMPOSITE_TYPE:
         case RELKIND_FOREIGN_TABLE:
         case RELKIND_PARTITIONED_TABLE:
             Assert(relation->rd_rel->relam == InvalidOid);
             break;
     }
 
     /* extract reloptions if any */
     RelationParseRelOptions(relation, pg_class_tuple);
 
     /*
      * initialize the relation lock manager information
      */
     RelationInitLockInfo(relation); /* see lmgr.c */
 
     /*
      * initialize physical addressing information for the relation
      */
     RelationInitPhysicalAddr(relation);
 
     /* make sure relation is marked as having no open file yet */
     relation->rd_smgr = NULL;
 
     /*
      * now we can free the memory allocated for pg_class_tuple
      */
     heap_freetuple(pg_class_tuple);
 
     /*
      * Insert newly created relation into relcache hash table, if requested.
      *
      * There is one scenario in which we might find a hashtable entry already
      * present, even though our caller failed to find it: if the relation is a
      * system catalog or index that's used during relcache load, we might have
      * recursively created the same relcache entry during the preceding steps.
      * So allow RelationCacheInsert to delete any already-present relcache
      * entry for the same OID.  The already-present entry should have refcount
      * zero (else somebody forgot to close it); in the event that it doesn't,
      * we'll elog a WARNING and leak the already-present entry.
      */
     if (insertIt)
         RelationCacheInsert(relation, true);
 
     /* It's fully valid */
     relation->rd_isvalid = true;
 
 #if RECOVER_RELATION_BUILD_MEMORY
     /* Return to caller's context, and blow away the temporary context */
     MemoryContextSwitchTo(oldcxt);
     MemoryContextDelete(tmpcxt);
 #endif
 
     return relation;
 }

◆ RelationBuildLocalRelation()

Relation RelationBuildLocalRelation	(	const char *	relname,
		Oid	relnamespace,
		TupleDesc	tupDesc,
		Oid	relid,
		Oid	accessmtd,
		Oid	relfilenode,
		Oid	reltablespace,
		bool	shared_relation,
		bool	mapped_relation,
		char	relpersistence,
		char	relkind
	)

Definition at line 3178 of file relcache.c.

References Assert, AssertArg, BackendIdForTempRelations, CacheMemoryContext, CLASS_TUPLE_SIZE, TupleDescData::constr, CreateCacheMemoryContext(), CreateTupleDescCopy(), elog, EOXactListAdd, ERROR, GetCurrentSubTransactionId(), TupleConstr::has_not_null, i, InvalidBackendId, InvalidOid, InvalidSubTransactionId, IsCatalogNamespace(), IsSharedRelation(), isTempOrTempToastNamespace(), MemoryContextSwitchTo(), namestrcpy(), TupleDescData::natts, palloc0(), RelationData::rd_att, RelationData::rd_backend, RelationData::rd_createSubid, RelationData::rd_islocaltemp, RelationData::rd_isnailed, RelationData::rd_isvalid, RelationData::rd_newRelfilenodeSubid, RelationData::rd_refcnt, RelationData::rd_rel, RelationData::rd_smgr, RelationCacheInsert, RelationGetRelid, RelationIncrementReferenceCount(), RelationInitLockInfo(), RelationInitPhysicalAddr(), RelationInitTableAccessMethod(), RelationMapUpdateMap(), relfilenode, relkind, relpersistence, TupleDescData::tdrefcount, and TupleDescAttr.

Referenced by heap_create().

 {
     Relation    rel;
     MemoryContext oldcxt;
     int         natts = tupDesc->natts;
     int         i;
     bool        has_not_null;
     bool        nailit;
 
     AssertArg(natts >= 0);
 
     /*
      * check for creation of a rel that must be nailed in cache.
      *
      * XXX this list had better match the relations specially handled in
      * RelationCacheInitializePhase2/3.
      */
     switch (relid)
     {
         case DatabaseRelationId:
         case AuthIdRelationId:
         case AuthMemRelationId:
         case RelationRelationId:
         case AttributeRelationId:
         case ProcedureRelationId:
         case TypeRelationId:
             nailit = true;
             break;
         default:
             nailit = false;
             break;
     }
 
     /*
      * check that hardwired list of shared rels matches what's in the
      * bootstrap .bki file.  If you get a failure here during initdb, you
      * probably need to fix IsSharedRelation() to match whatever you've done
      * to the set of shared relations.
      */
     if (shared_relation != IsSharedRelation(relid))
         elog(ERROR, "shared_relation flag for \"%s\" does not match IsSharedRelation(%u)",
              relname, relid);
 
     /* Shared relations had better be mapped, too */
     Assert(mapped_relation || !shared_relation);
 
     /*
      * switch to the cache context to create the relcache entry.
      */
     if (!CacheMemoryContext)
         CreateCacheMemoryContext();
 
     oldcxt = MemoryContextSwitchTo(CacheMemoryContext);
 
     /*
      * allocate a new relation descriptor and fill in basic state fields.
      */
     rel = (Relation) palloc0(sizeof(RelationData));
 
     /* make sure relation is marked as having no open file yet */
     rel->rd_smgr = NULL;
 
     /* mark it nailed if appropriate */
     rel->rd_isnailed = nailit;
 
     rel->rd_refcnt = nailit ? 1 : 0;
 
     /* it's being created in this transaction */
     rel->rd_createSubid = GetCurrentSubTransactionId();
     rel->rd_newRelfilenodeSubid = InvalidSubTransactionId;
 
     /*
      * 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);
     rel->rd_att->tdrefcount = 1;    /* mark as refcounted */
     has_not_null = false;
     for (i = 0; i < natts; i++)
     {
         Form_pg_attribute satt = TupleDescAttr(tupDesc, i);
         Form_pg_attribute datt = TupleDescAttr(rel->rd_att, i);
 
         datt->attidentity = satt->attidentity;
         datt->attgenerated = satt->attgenerated;
         datt->attnotnull = satt->attnotnull;
         has_not_null |= satt->attnotnull;
     }
 
     if (has_not_null)
     {
         TupleConstr *constr = (TupleConstr *) palloc0(sizeof(TupleConstr));
 
         constr->has_not_null = true;
         rel->rd_att->constr = constr;
     }
 
     /*
      * initialize relation tuple form (caller may add/override data later)
      */
     rel->rd_rel = (Form_pg_class) palloc0(CLASS_TUPLE_SIZE);
 
     namestrcpy(&rel->rd_rel->relname, relname);
     rel->rd_rel->relnamespace = relnamespace;
 
     rel->rd_rel->relkind = relkind;
     rel->rd_rel->relnatts = natts;
     rel->rd_rel->reltype = InvalidOid;
     /* needed when bootstrapping: */
     rel->rd_rel->relowner = BOOTSTRAP_SUPERUSERID;
 
     /* set up persistence and relcache fields dependent on it */
     rel->rd_rel->relpersistence = relpersistence;
     switch (relpersistence)
     {
         case RELPERSISTENCE_UNLOGGED:
         case RELPERSISTENCE_PERMANENT:
             rel->rd_backend = InvalidBackendId;
             rel->rd_islocaltemp = false;
             break;
         case RELPERSISTENCE_TEMP:
             Assert(isTempOrTempToastNamespace(relnamespace));
             rel->rd_backend = BackendIdForTempRelations();
             rel->rd_islocaltemp = true;
             break;
         default:
             elog(ERROR, "invalid relpersistence: %c", relpersistence);
             break;
     }
 
     /* if it's a materialized view, it's not populated initially */
     if (relkind == RELKIND_MATVIEW)
         rel->rd_rel->relispopulated = false;
     else
         rel->rd_rel->relispopulated = true;
 
     /* set replica identity -- system catalogs and non-tables don't have one */
     if (!IsCatalogNamespace(relnamespace) &&
         (relkind == RELKIND_RELATION ||
          relkind == RELKIND_MATVIEW ||
          relkind == RELKIND_PARTITIONED_TABLE))
         rel->rd_rel->relreplident = REPLICA_IDENTITY_DEFAULT;
     else
         rel->rd_rel->relreplident = REPLICA_IDENTITY_NOTHING;
 
     /*
      * Insert relation physical and logical identifiers (OIDs) into the right
      * places.  For a mapped relation, we set relfilenode to zero and rely on
      * RelationInitPhysicalAddr to consult the map.
      */
     rel->rd_rel->relisshared = shared_relation;
 
     RelationGetRelid(rel) = relid;
 
     for (i = 0; i < natts; i++)
         TupleDescAttr(rel->rd_att, i)->attrelid = relid;
 
     rel->rd_rel->reltablespace = reltablespace;
 
     if (mapped_relation)
     {
         rel->rd_rel->relfilenode = InvalidOid;
         /* Add it to the active mapping information */
         RelationMapUpdateMap(relid, relfilenode, shared_relation, true);
     }
     else
         rel->rd_rel->relfilenode = relfilenode;
 
     RelationInitLockInfo(rel);  /* see lmgr.c */
 
     RelationInitPhysicalAddr(rel);
 
     rel->rd_rel->relam = accessmtd;
 
     if (relkind == RELKIND_RELATION ||
         relkind == RELKIND_SEQUENCE ||
         relkind == RELKIND_TOASTVALUE ||
         relkind == RELKIND_MATVIEW)
         RelationInitTableAccessMethod(rel);
 
     /*
      * Okay to insert into the relcache hash table.
      *
      * Ordinarily, there should certainly not be an existing hash entry for
      * the same OID; but during bootstrap, when we create a "real" relcache
      * entry for one of the bootstrap relations, we'll be overwriting the
      * phony one created with formrdesc.  So allow that to happen for nailed
      * rels.
      */
     RelationCacheInsert(rel, nailit);
 
     /*
      * Flag relation as needing eoxact cleanup (to clear rd_createSubid). We
      * can't do this before storing relid in it.
      */
     EOXactListAdd(rel);
 
     /*
      * done building relcache entry.
      */
     MemoryContextSwitchTo(oldcxt);
 
     /* It's fully valid */
     rel->rd_isvalid = true;
 
     /*
      * Caller expects us to pin the returned entry.
      */
     RelationIncrementReferenceCount(rel);
 
     return rel;
 }

◆ RelationBuildRuleLock()

static void RelationBuildRuleLock ( Relation relation )

static

Definition at line 726 of file relcache.c.

References AccessShareLock, RewriteRule::actions, ALLOCSET_SMALL_SIZES, AllocSetContextCreate, Assert, BTEqualStrategyNumber, CacheMemoryContext, RewriteRule::enabled, RewriteRule::event, GETSTRUCT, heap_getattr, HeapTupleIsValid, RewriteRule::isInstead, sort-test::key, MemoryContextAlloc(), MemoryContextCopyAndSetIdentifier, MemoryContextDelete(), MemoryContextSwitchTo(), RuleLock::numLocks, ObjectIdGetDatum, pfree(), RewriteRule::qual, RelationData::rd_rel, RelationData::rd_rules, RelationData::rd_rulescxt, RelationGetDescr, RelationGetRelationName, RelationGetRelid, repalloc(), RewriteRelRulenameIndexId, RewriteRule::ruleId, RuleLock::rules, rules, ScanKeyInit(), setRuleCheckAsUser(), stringToNode(), systable_beginscan(), systable_endscan(), systable_getnext(), table_close(), table_open(), and TextDatumGetCString.

Referenced by RelationBuildDesc(), and RelationCacheInitializePhase3().

 {
     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.  Assume it'll not contain much data.
      */
     rulescxt = AllocSetContextCreate(CacheMemoryContext,
                                      "relation rules",
                                      ALLOCSET_SMALL_SIZES);
     relation->rd_rulescxt = rulescxt;
     MemoryContextCopyAndSetIdentifier(rulescxt,
                                       RelationGetRelationName(relation));
 
     /*
      * 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
      */
     ScanKeyInit(&key,
                 Anum_pg_rewrite_ev_class,
                 BTEqualStrategyNumber, F_OIDEQ,
                 ObjectIdGetDatum(RelationGetRelid(relation)));
 
     /*
      * open pg_rewrite and begin a scan
      *
      * Note: since we scan the rules using RewriteRelRulenameIndexId, we will
      * be reading the rules in name order, except possibly during
      * emergency-recovery operations (ie, IgnoreSystemIndexes). This in turn
      * ensures that rules will be fired in name order.
      */
     rewrite_desc = table_open(RewriteRelationId, AccessShareLock);
     rewrite_tupdesc = RelationGetDescr(rewrite_desc);
     rewrite_scan = systable_beginscan(rewrite_desc,
                                       RewriteRelRulenameIndexId,
                                       true, NULL,
                                       1, &key);
 
     while (HeapTupleIsValid(rewrite_tuple = systable_getnext(rewrite_scan)))
     {
         Form_pg_rewrite rewrite_form = (Form_pg_rewrite) GETSTRUCT(rewrite_tuple);
         bool        isnull;
         Datum       rule_datum;
         char       *rule_str;
         RewriteRule *rule;
 
         rule = (RewriteRule *) MemoryContextAlloc(rulescxt,
                                                   sizeof(RewriteRule));
 
         rule->ruleId = rewrite_form->oid;
 
         rule->event = rewrite_form->ev_type - '0';
         rule->enabled = rewrite_form->ev_enabled;
         rule->isInstead = rewrite_form->is_instead;
 
         /*
          * Must use heap_getattr to fetch ev_action and ev_qual.  Also, the
          * rule strings are often large enough to be toasted.  To avoid
          * leaking memory in the caller's context, do the detoasting here so
          * we can free the detoasted version.
          */
         rule_datum = heap_getattr(rewrite_tuple,
                                   Anum_pg_rewrite_ev_action,
                                   rewrite_tupdesc,
                                   &isnull);
         Assert(!isnull);
         rule_str = TextDatumGetCString(rule_datum);
         oldcxt = MemoryContextSwitchTo(rulescxt);
         rule->actions = (List *) stringToNode(rule_str);
         MemoryContextSwitchTo(oldcxt);
         pfree(rule_str);
 
         rule_datum = heap_getattr(rewrite_tuple,
                                   Anum_pg_rewrite_ev_qual,
                                   rewrite_tupdesc,
                                   &isnull);
         Assert(!isnull);
         rule_str = TextDatumGetCString(rule_datum);
         oldcxt = MemoryContextSwitchTo(rulescxt);
         rule->qual = (Node *) stringToNode(rule_str);
         MemoryContextSwitchTo(oldcxt);
         pfree(rule_str);
 
         /*
          * We want the rule's table references to be checked as though by the
          * table owner, not the user referencing the rule.  Therefore, scan
          * through the rule's actions and set the checkAsUser field on all
          * rtable entries.  We have to look at the qual as well, in case it
          * contains sublinks.
          *
          * The reason for doing this when the rule is loaded, rather than when
          * it is stored, is that otherwise ALTER TABLE OWNER would have to
          * grovel through stored rules to update checkAsUser fields. Scanning
          * the rule tree during load is relatively cheap (compared to
          * constructing it in the first place), so we do it here.
          */
         setRuleCheckAsUser((Node *) rule->actions, relation->rd_rel->relowner);
         setRuleCheckAsUser(rule->qual, relation->rd_rel->relowner);
 
         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);
     table_close(rewrite_desc, AccessShareLock);
 
     /*
      * there might not be any rules (if relhasrules is out-of-date)
      */
     if (numlocks == 0)
     {
         relation->rd_rules = NULL;
         relation->rd_rulescxt = NULL;
         MemoryContextDelete(rulescxt);
         return;
     }
 
     /*
      * form a RuleLock and insert into relation
      */
     rulelock = (RuleLock *) MemoryContextAlloc(rulescxt, sizeof(RuleLock));
     rulelock->numLocks = numlocks;
     rulelock->rules = rules;
 
     relation->rd_rules = rulelock;
 }

◆ RelationBuildTupleDesc()

static void RelationBuildTupleDesc ( Relation relation )

static

Definition at line 492 of file relcache.c.

References AccessShareLock, AttrDefault::adbin, AttrDefault::adnum, AttrMissing::am_present, AttrMissing::am_value, array_get_element(), Assert, attnum, AttrDefaultFetch(), ATTRIBUTE_FIXED_PART_SIZE, AttributeRelidNumIndexId, BTEqualStrategyNumber, BTGreaterStrategyNumber, CacheMemoryContext, TupleConstr::check, CheckConstraintFetch(), TupleDescData::constr, criticalRelcachesBuilt, datumCopy(), TupleConstr::defval, elog, ERROR, GETSTRUCT, TupleConstr::has_generated_stored, TupleConstr::has_not_null, heap_getattr, HeapTupleIsValid, i, Int16GetDatum, MemoryContextAlloc(), MemoryContextAllocZero(), MemoryContextSwitchTo(), TupleConstr::missing, TupleConstr::num_check, TupleConstr::num_defval, ObjectIdGetDatum, pfree(), RelationData::rd_att, RelationData::rd_rel, RelationGetNumberOfAttributes, RelationGetRelationName, RelationGetRelid, repalloc(), ScanKeyInit(), systable_beginscan(), systable_endscan(), systable_getnext(), table_close(), table_open(), TupleDescData::tdtypeid, TupleDescData::tdtypmod, and TupleDescAttr.

Referenced by RelationBuildDesc().

 {
     HeapTuple   pg_attribute_tuple;
     Relation    pg_attribute_desc;
     SysScanDesc pg_attribute_scan;
     ScanKeyData skey[2];
     int         need;
     TupleConstr *constr;
     AttrDefault *attrdef = NULL;
     AttrMissing *attrmiss = NULL;
     int         ndef = 0;
 
     /* copy some fields from pg_class row to rd_att */
     relation->rd_att->tdtypeid = relation->rd_rel->reltype;
     relation->rd_att->tdtypmod = -1;    /* unnecessary, but... */
 
     constr = (TupleConstr *) MemoryContextAlloc(CacheMemoryContext,
                                                 sizeof(TupleConstr));
     constr->has_not_null = false;
     constr->has_generated_stored = 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.)
      */
     ScanKeyInit(&skey[0],
                 Anum_pg_attribute_attrelid,
                 BTEqualStrategyNumber, F_OIDEQ,
                 ObjectIdGetDatum(RelationGetRelid(relation)));
     ScanKeyInit(&skey[1],
                 Anum_pg_attribute_attnum,
                 BTGreaterStrategyNumber, 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 = table_open(AttributeRelationId, AccessShareLock);
     pg_attribute_scan = systable_beginscan(pg_attribute_desc,
                                            AttributeRelidNumIndexId,
                                            criticalRelcachesBuilt,
                                            NULL,
                                            2, skey);
 
     /*
      * add attribute data to relation->rd_att
      */
     need = RelationGetNumberOfAttributes(relation);
 
     while (HeapTupleIsValid(pg_attribute_tuple = systable_getnext(pg_attribute_scan)))
     {
         Form_pg_attribute attp;
         int         attnum;
 
         attp = (Form_pg_attribute) GETSTRUCT(pg_attribute_tuple);
 
         attnum = attp->attnum;
         if (attnum <= 0 || attnum > RelationGetNumberOfAttributes(relation))
             elog(ERROR, "invalid attribute number %d for %s",
                  attp->attnum, RelationGetRelationName(relation));
 
 
         memcpy(TupleDescAttr(relation->rd_att, attnum - 1),
                attp,
                ATTRIBUTE_FIXED_PART_SIZE);
 
         /* Update constraint/default info */
         if (attp->attnotnull)
             constr->has_not_null = true;
         if (attp->attgenerated == ATTRIBUTE_GENERATED_STORED)
             constr->has_generated_stored = true;
 
         /* If the column has a default, fill it into the attrdef array */
         if (attp->atthasdef)
         {
             if (attrdef == NULL)
                 attrdef = (AttrDefault *)
                     MemoryContextAllocZero(CacheMemoryContext,
                                            RelationGetNumberOfAttributes(relation) *
                                            sizeof(AttrDefault));
             attrdef[ndef].adnum = attnum;
             attrdef[ndef].adbin = NULL;
 
             ndef++;
         }
 
         /* Likewise for a missing value */
         if (attp->atthasmissing)
         {
             Datum       missingval;
             bool        missingNull;
 
             /* Do we have a missing value? */
             missingval = heap_getattr(pg_attribute_tuple,
                                       Anum_pg_attribute_attmissingval,
                                       pg_attribute_desc->rd_att,
                                       &missingNull);
             if (!missingNull)
             {
                 /* Yes, fetch from the array */
                 MemoryContext oldcxt;
                 bool        is_null;
                 int         one = 1;
                 Datum       missval;
 
                 if (attrmiss == NULL)
                     attrmiss = (AttrMissing *)
                         MemoryContextAllocZero(CacheMemoryContext,
                                                relation->rd_rel->relnatts *
                                                sizeof(AttrMissing));
 
                 missval = array_get_element(missingval,
                                             1,
                                             &one,
                                             -1,
                                             attp->attlen,
                                             attp->attbyval,
                                             attp->attalign,
                                             &is_null);
                 Assert(!is_null);
                 if (attp->attbyval)
                 {
                     /* for copy by val just copy the datum direct */
                     attrmiss[attnum - 1].am_value = missval;
                 }
                 else
                 {
                     /* otherwise copy in the correct context */
                     oldcxt = MemoryContextSwitchTo(CacheMemoryContext);
                     attrmiss[attnum - 1].am_value = datumCopy(missval,
                                                               attp->attbyval,
                                                               attp->attlen);
                     MemoryContextSwitchTo(oldcxt);
                 }
                 attrmiss[attnum - 1].am_present = true;
             }
         }
         need--;
         if (need == 0)
             break;
     }
 
     /*
      * end the scan and close the attribute relation
      */
     systable_endscan(pg_attribute_scan);
     table_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 < RelationGetNumberOfAttributes(relation); i++)
             Assert(TupleDescAttr(relation->rd_att, 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().
      */
     if (RelationGetNumberOfAttributes(relation) > 0)
         TupleDescAttr(relation->rd_att, 0)->attcacheoff = 0;
 
     /*
      * Set up constraint/default info
      */
     if (constr->has_not_null || ndef > 0 ||
         attrmiss || relation->rd_rel->relchecks)
     {
         relation->rd_att->constr = constr;
 
         if (ndef > 0)           /* DEFAULTs */
         {
             if (ndef < RelationGetNumberOfAttributes(relation))
                 constr->defval = (AttrDefault *)
                     repalloc(attrdef, ndef * sizeof(AttrDefault));
             else
                 constr->defval = attrdef;
             constr->num_defval = ndef;
             AttrDefaultFetch(relation);
         }
         else
             constr->num_defval = 0;
 
         constr->missing = attrmiss;
 
         if (relation->rd_rel->relchecks > 0)    /* CHECKs */
         {
             constr->num_check = relation->rd_rel->relchecks;
             constr->check = (ConstrCheck *)
                 MemoryContextAllocZero(CacheMemoryContext,
                                        constr->num_check * sizeof(ConstrCheck));
             CheckConstraintFetch(relation);
         }
         else
             constr->num_check = 0;
     }
     else
     {
         pfree(constr);
         relation->rd_att->constr = NULL;
     }
 }

◆ RelationCacheInitFilePostInvalidate()

void RelationCacheInitFilePostInvalidate ( void )

Definition at line 5997 of file relcache.c.

References LWLockRelease().

Referenced by AtEOXact_Inval(), FinishPreparedTransaction(), and ProcessCommittedInvalidationMessages().

 {
     LWLockRelease(RelCacheInitLock);
 }

◆ RelationCacheInitFilePreInvalidate()

void RelationCacheInitFilePreInvalidate ( void )

Definition at line 5972 of file relcache.c.

References DatabasePath, ERROR, LW_EXCLUSIVE, LWLockAcquire(), MAXPGPATH, RELCACHE_INIT_FILENAME, snprintf, and unlink_initfile().

Referenced by AtEOXact_Inval(), FinishPreparedTransaction(), and ProcessCommittedInvalidationMessages().

 {
     char        localinitfname[MAXPGPATH];
     char        sharedinitfname[MAXPGPATH];
 
     if (DatabasePath)
         snprintf(localinitfname, sizeof(localinitfname), "%s/%s",
                  DatabasePath, RELCACHE_INIT_FILENAME);
     snprintf(sharedinitfname, sizeof(sharedinitfname), "global/%s",
              RELCACHE_INIT_FILENAME);
 
     LWLockAcquire(RelCacheInitLock, LW_EXCLUSIVE);
 
     /*
      * The files might not be there if no backend has been started since the
      * last removal.  But complain about failures other than ENOENT with
      * ERROR.  Fortunately, it's not too late to abort the transaction if we
      * can't get rid of the would-be-obsolete init file.
      */
     if (DatabasePath)
         unlink_initfile(localinitfname, ERROR);
     unlink_initfile(sharedinitfname, ERROR);
 }

◆ RelationCacheInitFileRemove()

void RelationCacheInitFileRemove ( void )

Definition at line 6012 of file relcache.c.

References AllocateDir(), dirent::d_name, FreeDir(), LOG, MAXPGPATH, ReadDirExtended(), RelationCacheInitFileRemoveInDir(), RELCACHE_INIT_FILENAME, snprintf, TABLESPACE_VERSION_DIRECTORY, and unlink_initfile().

Referenced by StartupXLOG().

 {
     const char *tblspcdir = "pg_tblspc";
     DIR        *dir;
     struct dirent *de;
     char        path[MAXPGPATH + 10 + sizeof(TABLESPACE_VERSION_DIRECTORY)];
 
     snprintf(path, sizeof(path), "global/%s",
              RELCACHE_INIT_FILENAME);
     unlink_initfile(path, LOG);
 
     /* Scan everything in the default tablespace */
     RelationCacheInitFileRemoveInDir("base");
 
     /* Scan the tablespace link directory to find non-default tablespaces */
     dir = AllocateDir(tblspcdir);
 
     while ((de = ReadDirExtended(dir, tblspcdir, LOG)) != NULL)
     {
         if (strspn(de->d_name, "0123456789") == strlen(de->d_name))
         {
             /* Scan the tablespace dir for per-database dirs */
             snprintf(path, sizeof(path), "%s/%s/%s",
                      tblspcdir, de->d_name, TABLESPACE_VERSION_DIRECTORY);
             RelationCacheInitFileRemoveInDir(path);
         }
     }
 
     FreeDir(dir);
 }

◆ RelationCacheInitFileRemoveInDir()

static void RelationCacheInitFileRemoveInDir ( const char * tblspcpath )

static

Definition at line 6045 of file relcache.c.

References AllocateDir(), dirent::d_name, FreeDir(), LOG, MAXPGPATH, ReadDirExtended(), RELCACHE_INIT_FILENAME, snprintf, and unlink_initfile().

Referenced by RelationCacheInitFileRemove().

 {
     DIR        *dir;
     struct dirent *de;
     char        initfilename[MAXPGPATH * 2];
 
     /* Scan the tablespace directory to find per-database directories */
     dir = AllocateDir(tblspcpath);
 
     while ((de = ReadDirExtended(dir, tblspcpath, LOG)) != NULL)
     {
         if (strspn(de->d_name, "0123456789") == strlen(de->d_name))
         {
             /* Try to remove the init file in each database */
             snprintf(initfilename, sizeof(initfilename), "%s/%s/%s",
                      tblspcpath, de->d_name, RELCACHE_INIT_FILENAME);
             unlink_initfile(initfilename, LOG);
         }
     }
 
     FreeDir(dir);
 }

◆ RelationCacheInitialize()

void RelationCacheInitialize ( void )

Definition at line 3582 of file relcache.c.

References CacheMemoryContext, CreateCacheMemoryContext(), HASHCTL::entrysize, HASH_BLOBS, hash_create(), HASH_ELEM, INITRELCACHESIZE, HASHCTL::keysize, MemSet, and RelationMapInitialize().

Referenced by InitPostgres().

 {
     HASHCTL     ctl;
 
     /*
      * make sure cache memory context exists
      */
     if (!CacheMemoryContext)
         CreateCacheMemoryContext();
 
     /*
      * create hashtable that indexes the relcache
      */
     MemSet(&ctl, 0, sizeof(ctl));
     ctl.keysize = sizeof(Oid);
     ctl.entrysize = sizeof(RelIdCacheEnt);
     RelationIdCache = hash_create("Relcache by OID", INITRELCACHESIZE,
                                   &ctl, HASH_ELEM | HASH_BLOBS);
 
     /*
      * relation mapper needs to be initialized too
      */
     RelationMapInitialize();
 }

◆ RelationCacheInitializePhase2()

void RelationCacheInitializePhase2 ( void )

Definition at line 3619 of file relcache.c.

References CacheMemoryContext, Desc_pg_auth_members, Desc_pg_authid, Desc_pg_database, Desc_pg_shseclabel, Desc_pg_subscription, formrdesc(), IsBootstrapProcessingMode, load_relcache_init_file(), MemoryContextSwitchTo(), and RelationMapInitializePhase2().

Referenced by InitPostgres().

 {
     MemoryContext oldcxt;
 
     /*
      * relation mapper needs initialized too
      */
     RelationMapInitializePhase2();
 
     /*
      * In bootstrap mode, the shared catalogs aren't there yet anyway, so do
      * nothing.
      */
     if (IsBootstrapProcessingMode())
         return;
 
     /*
      * switch to cache memory context
      */
     oldcxt = MemoryContextSwitchTo(CacheMemoryContext);
 
     /*
      * Try to load the shared relcache cache file.  If unsuccessful, bootstrap
      * the cache with pre-made descriptors for the critical shared catalogs.
      */
     if (!load_relcache_init_file(true))
     {
         formrdesc("pg_database", DatabaseRelation_Rowtype_Id, true,
                   Natts_pg_database, Desc_pg_database);
         formrdesc("pg_authid", AuthIdRelation_Rowtype_Id, true,
                   Natts_pg_authid, Desc_pg_authid);
         formrdesc("pg_auth_members", AuthMemRelation_Rowtype_Id, true,
                   Natts_pg_auth_members, Desc_pg_auth_members);
         formrdesc("pg_shseclabel", SharedSecLabelRelation_Rowtype_Id, true,
                   Natts_pg_shseclabel, Desc_pg_shseclabel);
         formrdesc("pg_subscription", SubscriptionRelation_Rowtype_Id, true,
                   Natts_pg_subscription, Desc_pg_subscription);
 
 #define NUM_CRITICAL_SHARED_RELS    5   /* fix if you change list above */
     }
 
     MemoryContextSwitchTo(oldcxt);
 }

◆ RelationCacheInitializePhase3()

void RelationCacheInitializePhase3 ( void )

Definition at line 3678 of file relcache.c.

References AccessMethodProcedureIndexId, Assert, AttributeRelidNumIndexId, AuthIdOidIndexId, AuthIdRolnameIndexId, AuthMemMemRoleIndexId, CacheMemoryContext, CLASS_TUPLE_SIZE, ClassOidIndexId, criticalRelcachesBuilt, criticalSharedRelcachesBuilt, DatabaseNameIndexId, DatabaseOidIndexId, Desc_pg_attribute, Desc_pg_class, Desc_pg_proc, Desc_pg_type, elog, ERROR, FATAL, formrdesc(), GETSTRUCT, hash_seq_init(), hash_seq_search(), hash_seq_term(), HeapTupleIsValid, IndexRelidIndexId, InitCatalogCachePhase2(), InvalidOid, IsBootstrapProcessingMode, load_critical_index(), load_relcache_init_file(), MemoryContextSwitchTo(), ObjectIdGetDatum, OpclassOidIndexId, pfree(), RelationData::rd_att, RelationData::rd_options, RelationData::rd_rel, RelationData::rd_rsdesc, RelationData::rd_rules, RelationData::rd_tableam, RelationBuildRowSecurity(), RelationBuildRuleLock(), RelationBuildTriggers(), RelationDecrementReferenceCount(), RelationGetRelationName, RelationGetRelid, RelationIncrementReferenceCount(), RelationInitTableAccessMethod(), RelationMapInitializePhase3(), RelationParseRelOptions(), relidcacheent::reldesc, ReleaseSysCache(), RELOID, RewriteRelRulenameIndexId, SearchSysCache1(), SharedSecLabelObjectIndexId, status(), TupleDescData::tdtypeid, TupleDescData::tdtypmod, RelationData::trigdesc, TriggerRelidNameIndexId, and write_relcache_init_file().

Referenced by InitPostgres().

 {
     HASH_SEQ_STATUS status;
     RelIdCacheEnt *idhentry;
     MemoryContext oldcxt;
     bool        needNewCacheFile = !criticalSharedRelcachesBuilt;
 
     /*
      * relation mapper needs initialized too
      */
     RelationMapInitializePhase3();
 
     /*
      * switch to cache memory context
      */
     oldcxt = MemoryContextSwitchTo(CacheMemoryContext);
 
     /*
      * Try to load the local relcache cache file.  If unsuccessful, bootstrap
      * the cache with pre-made descriptors for the critical "nailed-in" system
      * catalogs.
      */
     if (IsBootstrapProcessingMode() ||
         !load_relcache_init_file(false))
     {
         needNewCacheFile = true;
 
         formrdesc("pg_class", RelationRelation_Rowtype_Id, false,
                   Natts_pg_class, Desc_pg_class);
         formrdesc("pg_attribute", AttributeRelation_Rowtype_Id, false,
                   Natts_pg_attribute, Desc_pg_attribute);
         formrdesc("pg_proc", ProcedureRelation_Rowtype_Id, false,
                   Natts_pg_proc, Desc_pg_proc);
         formrdesc("pg_type", TypeRelation_Rowtype_Id, false,
                   Natts_pg_type, Desc_pg_type);
 
 #define NUM_CRITICAL_LOCAL_RELS 4   /* fix if you change list above */
     }
 
     MemoryContextSwitchTo(oldcxt);
 
     /* In bootstrap mode, the faked-up formrdesc info is all we'll have */
     if (IsBootstrapProcessingMode())
         return;
 
     /*
      * If we didn't get the critical system indexes loaded into relcache, do
      * so now.  These are critical because the catcache and/or opclass cache
      * depend on them for fetches 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.)
      *
      * RewriteRelRulenameIndexId and TriggerRelidNameIndexId are not critical
      * in the same way as the others, because the critical catalogs don't
      * (currently) have any rules or triggers, and so these indexes can be
      * rebuilt without inducing recursion.  However they are used during
      * relcache load when a rel does have rules or triggers, so we choose to
      * nail them for performance reasons.
      */
     if (!criticalRelcachesBuilt)
     {
         load_critical_index(ClassOidIndexId,
                             RelationRelationId);
         load_critical_index(AttributeRelidNumIndexId,
                             AttributeRelationId);
         load_critical_index(IndexRelidIndexId,
                             IndexRelationId);
         load_critical_index(OpclassOidIndexId,
                             OperatorClassRelationId);
         load_critical_index(AccessMethodProcedureIndexId,
                             AccessMethodProcedureRelationId);
         load_critical_index(RewriteRelRulenameIndexId,
                             RewriteRelationId);
         load_critical_index(TriggerRelidNameIndexId,
                             TriggerRelationId);
 
 #define NUM_CRITICAL_LOCAL_INDEXES  7   /* fix if you change list above */
 
         criticalRelcachesBuilt = true;
     }
 
     /*
      * Process critical shared indexes too.
      *
      * DatabaseNameIndexId isn't critical for relcache loading, but rather for
      * initial lookup of MyDatabaseId, without which we'll never find any
      * non-shared catalogs at all.  Autovacuum calls InitPostgres with a
      * database OID, so it instead depends on DatabaseOidIndexId.  We also
      * need to nail up some indexes on pg_authid and pg_auth_members for use
      * during client authentication.  SharedSecLabelObjectIndexId isn't
      * critical for the core system, but authentication hooks might be
      * interested in it.
      */
     if (!criticalSharedRelcachesBuilt)
     {
         load_critical_index(DatabaseNameIndexId,
                             DatabaseRelationId);
         load_critical_index(DatabaseOidIndexId,
                             DatabaseRelationId);
         load_critical_index(AuthIdRolnameIndexId,
                             AuthIdRelationId);
         load_critical_index(AuthIdOidIndexId,
                             AuthIdRelationId);
         load_critical_index(AuthMemMemRoleIndexId,
                             AuthMemRelationId);
         load_critical_index(SharedSecLabelObjectIndexId,
                             SharedSecLabelRelationId);
 
 #define NUM_CRITICAL_SHARED_INDEXES 6   /* fix if you change list above */
 
         criticalSharedRelcachesBuilt = 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, triggers, or security policies, load that
      * info the hard way since it isn't recorded in the cache file.
      *
      * Whenever we access the catalogs to read data, there is a possibility of
      * a shared-inval cache flush causing relcache entries to be removed.
      * Since hash_seq_search only guarantees to still work after the *current*
      * entry is removed, it's unsafe to continue the hashtable scan afterward.
      * We handle this by restarting the scan from scratch after each access.
      * This is theoretically O(N^2), but the number of entries that actually
      * need to be fixed is small enough that it doesn't matter.
      */
     hash_seq_init(&status, RelationIdCache);
 
     while ((idhentry = (RelIdCacheEnt *) hash_seq_search(&status)) != NULL)
     {
         Relation    relation = idhentry->reldesc;
         bool        restart = false;
 
         /*
          * Make sure *this* entry doesn't get flushed while we work with it.
          */
         RelationIncrementReferenceCount(relation);
 
         /*
          * If it's a faked-up entry, read the real pg_class tuple.
          */
         if (relation->rd_rel->relowner == InvalidOid)
         {
             HeapTuple   htup;
             Form_pg_class relp;
 
             htup = SearchSysCache1(RELOID,
                                    ObjectIdGetDatum(RelationGetRelid(relation)));
             if (!HeapTupleIsValid(htup))
                 elog(FATAL, "cache lookup failed for relation %u",
                      RelationGetRelid(relation));
             relp = (Form_pg_class) GETSTRUCT(htup);
 
             /*
              * Copy tuple to relation->rd_rel. (See notes in
              * AllocateRelationDesc())
              */
             memcpy((char *) relation->rd_rel, (char *) relp, CLASS_TUPLE_SIZE);
 
             /* Update rd_options while we have the tuple */
             if (relation->rd_options)
                 pfree(relation->rd_options);
             RelationParseRelOptions(relation, htup);
 
             /*
              * Check the values in rd_att were set up correctly.  (We cannot
              * just copy them over now: formrdesc must have set up the rd_att
              * data correctly to start with, because it may already have been
              * copied into one or more catcache entries.)
              */
             Assert(relation->rd_att->tdtypeid == relp->reltype);
             Assert(relation->rd_att->tdtypmod == -1);
 
             ReleaseSysCache(htup);
 
             /* relowner had better be OK now, else we'll loop forever */
             if (relation->rd_rel->relowner == InvalidOid)
                 elog(ERROR, "invalid relowner in pg_class entry for \"%s\"",
                      RelationGetRelationName(relation));
 
             restart = true;
         }
 
         /*
          * Fix data that isn't saved in relcache cache file.
          *
          * relhasrules or relhastriggers could possibly be wrong or out of
          * date.  If we don't actually find any rules or triggers, clear the
          * local copy of the flag so that we don't get into an infinite loop
          * here.  We don't make any attempt to fix the pg_class entry, though.
          */
         if (relation->rd_rel->relhasrules && relation->rd_rules == NULL)
         {
             RelationBuildRuleLock(relation);
             if (relation->rd_rules == NULL)
                 relation->rd_rel->relhasrules = false;
             restart = true;
         }
         if (relation->rd_rel->relhastriggers && relation->trigdesc == NULL)
         {
             RelationBuildTriggers(relation);
             if (relation->trigdesc == NULL)
                 relation->rd_rel->relhastriggers = false;
             restart = true;
         }
 
         /*
          * Re-load the row security policies if the relation has them, since
          * they are not preserved in the cache.  Note that we can never NOT
          * have a policy while relrowsecurity is true,
          * RelationBuildRowSecurity will create a single default-deny policy
          * if there is no policy defined in pg_policy.
          */
         if (relation->rd_rel->relrowsecurity && relation->rd_rsdesc == NULL)
         {
             RelationBuildRowSecurity(relation);
 
             Assert(relation->rd_rsdesc != NULL);
             restart = true;
         }
 
         /* Reload tableam data if needed */
         if (relation->rd_tableam == NULL &&
             (relation->rd_rel->relkind == RELKIND_RELATION ||
              relation->rd_rel->relkind == RELKIND_SEQUENCE ||
              relation->rd_rel->relkind == RELKIND_TOASTVALUE ||
              relation->rd_rel->relkind == RELKIND_MATVIEW))
         {
             RelationInitTableAccessMethod(relation);
             Assert(relation->rd_tableam != NULL);
 
             restart = true;
         }
 
         /* Release hold on the relation */
         RelationDecrementReferenceCount(relation);
 
         /* Now, restart the hashtable scan if needed */
         if (restart)
         {
             hash_seq_term(&status);
             hash_seq_init(&status, RelationIdCache);
         }
     }
 
     /*
      * Lastly, write out new relcache cache files if needed.  We don't bother
      * to distinguish cases where only one of the two needs an update.
      */
     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 files will be most useful for future backends.
          */
         InitCatalogCachePhase2();
 
         /* now write the files */
         write_relcache_init_file(true);
         write_relcache_init_file(false);
     }
 }

◆ RelationCacheInvalidate()

void RelationCacheInvalidate ( void )

Definition at line 2781 of file relcache.c.

References Assert, ClassOidIndexId, hash_seq_init(), hash_seq_search(), InvalidSubTransactionId, lappend(), lcons(), lfirst, list_free(), NIL, RelationData::rd_createSubid, RelationData::rd_isnailed, RelationData::rd_newRelfilenodeSubid, RelationClearRelation(), RelationCloseSmgr, RelationGetRelid, RelationHasReferenceCountZero, RelationInitPhysicalAddr(), RelationIsMapped, RelationMapInvalidateAll(), relcacheInvalsReceived, relidcacheent::reldesc, smgrcloseall(), and status().

Referenced by InvalidateSystemCaches(), and LocalExecuteInvalidationMessage().

 {
     HASH_SEQ_STATUS status;
     RelIdCacheEnt *idhentry;
     Relation    relation;
     List       *rebuildFirstList = NIL;
     List       *rebuildList = NIL;
     ListCell   *l;
 
     /*
      * Reload relation mapping data before starting to reconstruct cache.
      */
     RelationMapInvalidateAll();
 
     /* Phase 1 */
     hash_seq_init(&status, RelationIdCache);
 
     while ((idhentry = (RelIdCacheEnt *) hash_seq_search(&status)) != NULL)
     {
         relation = idhentry->reldesc;
 
         /* Must close all smgr references to avoid leaving dangling ptrs */
         RelationCloseSmgr(relation);
 
         /*
          * Ignore new relations; no other backend will manipulate them before
          * we commit.  Likewise, before replacing a relation's relfilenode, we
          * shall have acquired AccessExclusiveLock and drained any applicable
          * pending invalidations.
          */
         if (relation->rd_createSubid != InvalidSubTransactionId ||
             relation->rd_newRelfilenodeSubid != InvalidSubTransactionId)
             continue;
 
         relcacheInvalsReceived++;
 
         if (RelationHasReferenceCountZero(relation))
         {
             /* Delete this entry immediately */
             Assert(!relation->rd_isnailed);
             RelationClearRelation(relation, false);
         }
         else
         {
             /*
              * If it's a mapped relation, immediately update its rd_node in
              * case its relfilenode changed.  We must do this during phase 1
              * in case the relation is consulted during rebuild of other
              * relcache entries in phase 2.  It's safe since consulting the
              * map doesn't involve any access to relcache entries.
              */
             if (RelationIsMapped(relation))
                 RelationInitPhysicalAddr(relation);
 
             /*
              * Add this entry to list of stuff to rebuild in second pass.
              * pg_class goes to the front of rebuildFirstList while
              * pg_class_oid_index goes to the back of rebuildFirstList, so
              * they are done first and second respectively.  Other nailed
              * relations go to the front of rebuildList, so they'll be done
              * next in no particular order; and everything else goes to the
              * back of rebuildList.
              */
             if (RelationGetRelid(relation) == RelationRelationId)
                 rebuildFirstList = lcons(relation, rebuildFirstList);
             else if (RelationGetRelid(relation) == ClassOidIndexId)
                 rebuildFirstList = lappend(rebuildFirstList, relation);
             else if (relation->rd_isnailed)
                 rebuildList = lcons(relation, rebuildList);
             else
                 rebuildList = lappend(rebuildList, relation);
         }
     }
 
     /*
      * Now zap any remaining smgr cache entries.  This must happen before we
      * start to rebuild entries, since that may involve catalog fetches which
      * will re-open catalog files.
      */
     smgrcloseall();
 
     /* Phase 2: rebuild the items found to need rebuild in phase 1 */
     foreach(l, rebuildFirstList)
     {
         relation = (Relation) lfirst(l);
         RelationClearRelation(relation, true);
     }
     list_free(rebuildFirstList);
     foreach(l, rebuildList)
     {
         relation = (Relation) lfirst(l);
         RelationClearRelation(relation, true);
     }
     list_free(rebuildList);
 }

◆ RelationCacheInvalidateEntry()

void RelationCacheInvalidateEntry ( Oid relationId )

Definition at line 2737 of file relcache.c.

References PointerIsValid, RelationFlushRelation(), RelationIdCacheLookup, and relcacheInvalsReceived.

Referenced by LocalExecuteInvalidationMessage().

 {
     Relation    relation;
 
     RelationIdCacheLookup(relationId, relation);
 
     if (PointerIsValid(relation))
     {
         relcacheInvalsReceived++;
         RelationFlushRelation(relation);
     }
 }

◆ RelationClearRelation()

static void RelationClearRelation	(	Relation	relation,
		bool	rebuild
	)

static

Definition at line 2394 of file relcache.c.

References Assert, CLASS_TUPLE_SIZE, elog, equalRSDesc(), equalRuleLocks(), equalTupleDescs(), ERROR, HistoricSnapshotActive(), IsTransactionState(), MemoryContextSetParent(), pfree(), RelationData::rd_amcache, RelationData::rd_att, RelationData::rd_indexcxt, RelationData::rd_isnailed, RelationData::rd_isvalid, RelationData::rd_partdesc, RelationData::rd_partkey, RelationData::rd_pdcxt, RelationData::rd_refcnt, RelationData::rd_rel, RelationData::rd_rsdesc, RelationData::rd_rules, RelationBuildDesc(), RelationCacheDelete, RelationCloseSmgr, RelationDestroyRelation(), RelationGetRelid, RelationHasReferenceCountZero, RelationReloadIndexInfo(), RelationReloadNailed(), and SWAPFIELD.

Referenced by AtEOSubXact_cleanup(), AtEOXact_cleanup(), RelationCacheInvalidate(), RelationClose(), RelationFlushRelation(), RelationForgetRelation(), and RelationIdGetRelation().

 {
     /*
      * As per notes above, a rel to be rebuilt MUST have refcnt > 0; while of
      * course it would be an equally bad idea to blow away one with nonzero
      * refcnt, since that would leave someone somewhere with a dangling
      * pointer.  All callers are expected to have verified that this holds.
      */
     Assert(rebuild ?
            !RelationHasReferenceCountZero(relation) :
            RelationHasReferenceCountZero(relation));
 
     /*
      * 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.
      */
     RelationCloseSmgr(relation);
 
     /* Free AM cached data, if any */
     if (relation->rd_amcache)
         pfree(relation->rd_amcache);
     relation->rd_amcache = NULL;
 
     /*
      * Treat nailed-in system relations separately, they always need to be
      * accessible, so we can't blow them away.
      */
     if (relation->rd_isnailed)
     {
         RelationReloadNailed(relation);
         return;
     }
 
     /*
      * Even non-system indexes should not be blown away if they are open and
      * have valid index support information.  This avoids problems with active
      * use of the index support information.  As with nailed indexes, we
      * re-read the pg_class row to handle possible physical relocation of the
      * index, and we check for pg_index updates too.
      */
     if ((relation->rd_rel->relkind == RELKIND_INDEX ||
          relation->rd_rel->relkind == RELKIND_PARTITIONED_INDEX) &&
         relation->rd_refcnt > 0 &&
         relation->rd_indexcxt != NULL)
     {
         relation->rd_isvalid = false;   /* needs to be revalidated */
         if (IsTransactionState())
             RelationReloadIndexInfo(relation);
         return;
     }
 
     /* Mark it invalid until we've finished rebuild */
     relation->rd_isvalid = false;
 
     /*
      * 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 (!rebuild)
     {
         /* Remove it from the hash table */
         RelationCacheDelete(relation);
 
         /* And release storage */
         RelationDestroyRelation(relation, false);
     }
     else if (!IsTransactionState())
     {
         /*
          * If we're not inside a valid transaction, we can't do any catalog
          * access so it's not possible to rebuild yet.  Just exit, leaving
          * rd_isvalid = false so that the rebuild will occur when the entry is
          * next opened.
          *
          * Note: it's possible that we come here during subtransaction abort,
          * and the reason for wanting to rebuild is that the rel is open in
          * the outer transaction.  In that case it might seem unsafe to not
          * rebuild immediately, since whatever code has the rel already open
          * will keep on using the relcache entry as-is.  However, in such a
          * case the outer transaction should be holding a lock that's
          * sufficient to prevent any significant change in the rel's schema,
          * so the existing entry contents should be good enough for its
          * purposes; at worst we might be behind on statistics updates or the
          * like.  (See also CheckTableNotInUse() and its callers.)  These same
          * remarks also apply to the cases above where we exit without having
          * done RelationReloadIndexInfo() yet.
          */
         return;
     }
     else
     {
         /*
          * Our strategy for rebuilding an open relcache entry is to build a
          * new entry from scratch, swap its contents with the old entry, and
          * finally delete the new entry (along with any infrastructure swapped
          * over from the old entry).  This is to avoid trouble in case an
          * error causes us to lose control partway through.  The old entry
          * will still be marked !rd_isvalid, so we'll try to rebuild it again
          * on next access.  Meanwhile it's not any less valid than it was
          * before, so any code that might expect to continue accessing it
          * isn't hurt by the rebuild failure.  (Consider for example a
          * subtransaction that ALTERs a table and then gets canceled partway
          * through the cache entry rebuild.  The outer transaction should
          * still see the not-modified cache entry as valid.)  The worst
          * consequence of an error is leaking the necessarily-unreferenced new
          * entry, and this shouldn't happen often enough for that to be a big
          * problem.
          *
          * When rebuilding an open relcache entry, we must preserve ref count,
          * rd_createSubid/rd_newRelfilenodeSubid, and rd_toastoid state.  Also
          * attempt to preserve the pg_class entry (rd_rel), tupledesc,
          * rewrite-rule, partition key, and partition descriptor substructures
          * in place, because various places assume that these structures won't
          * move while they are working with an open relcache entry.  (Note:
          * the refcount mechanism for tupledescs might someday allow us to
          * remove this hack for the tupledesc.)
          *
          * Note that this process does not touch CurrentResourceOwner; which
          * is good because whatever ref counts the entry may have do not
          * necessarily belong to that resource owner.
          */
         Relation    newrel;
         Oid         save_relid = RelationGetRelid(relation);
         bool        keep_tupdesc;
         bool        keep_rules;
         bool        keep_policies;
         bool        keep_partkey;
 
         /* Build temporary entry, but don't link it into hashtable */
         newrel = RelationBuildDesc(save_relid, false);
         if (newrel == NULL)
         {
             /*
              * We can validly get here, if we're using a historic snapshot in
              * which a relation, accessed from outside logical decoding, is
              * still invisible. In that case it's fine to just mark the
              * relation as invalid and return - it'll fully get reloaded by
              * the cache reset at the end of logical decoding (or at the next
              * access).  During normal processing we don't want to ignore this
              * case as it shouldn't happen there, as explained below.
              */
             if (HistoricSnapshotActive())
                 return;
 
             /*
              * This shouldn't happen as dropping a relation is intended to be
              * impossible if still referenced (cf. CheckTableNotInUse()). But
              * if we get here anyway, we can't just delete the relcache entry,
              * as it possibly could get accessed later (as e.g. the error
              * might get trapped and handled via a subtransaction rollback).
              */
             elog(ERROR, "relation %u deleted while still in use", save_relid);
         }
 
         keep_tupdesc = equalTupleDescs(relation->rd_att, newrel->rd_att);
         keep_rules = equalRuleLocks(relation->rd_rules, newrel->rd_rules);
         keep_policies = equalRSDesc(relation->rd_rsdesc, newrel->rd_rsdesc);
         /* partkey is immutable once set up, so we can always keep it */
         keep_partkey = (relation->rd_partkey != NULL);
 
         /*
          * Perform swapping of the relcache entry contents.  Within this
          * process the old entry is momentarily invalid, so there *must* be no
          * possibility of CHECK_FOR_INTERRUPTS within this sequence. Do it in
          * all-in-line code for safety.
          *
          * Since the vast majority of fields should be swapped, our method is
          * to swap the whole structures and then re-swap those few fields we
          * didn't want swapped.
          */
 #define SWAPFIELD(fldtype, fldname) \
         do { \
             fldtype _tmp = newrel->fldname; \
             newrel->fldname = relation->fldname; \
             relation->fldname = _tmp; \
         } while (0)
 
         /* swap all Relation struct fields */
         {
             RelationData tmpstruct;
 
             memcpy(&tmpstruct, newrel, sizeof(RelationData));
             memcpy(newrel, relation, sizeof(RelationData));
             memcpy(relation, &tmpstruct, sizeof(RelationData));
         }
 
         /* rd_smgr must not be swapped, due to back-links from smgr level */
         SWAPFIELD(SMgrRelation, rd_smgr);
         /* rd_refcnt must be preserved */
         SWAPFIELD(int, rd_refcnt);
         /* isnailed shouldn't change */
         Assert(newrel->rd_isnailed == relation->rd_isnailed);
         /* creation sub-XIDs must be preserved */
         SWAPFIELD(SubTransactionId, rd_createSubid);
         SWAPFIELD(SubTransactionId, rd_newRelfilenodeSubid);
         /* un-swap rd_rel pointers, swap contents instead */
         SWAPFIELD(Form_pg_class, rd_rel);
         /* ... but actually, we don't have to update newrel->rd_rel */
         memcpy(relation->rd_rel, newrel->rd_rel, CLASS_TUPLE_SIZE);
         /* preserve old tupledesc, rules, policies if no logical change */
         if (keep_tupdesc)
             SWAPFIELD(TupleDesc, rd_att);
         if (keep_rules)
         {
             SWAPFIELD(RuleLock *, rd_rules);
             SWAPFIELD(MemoryContext, rd_rulescxt);
         }
         if (keep_policies)
             SWAPFIELD(RowSecurityDesc *, rd_rsdesc);
         /* toast OID override must be preserved */
         SWAPFIELD(Oid, rd_toastoid);
         /* pgstat_info must be preserved */
         SWAPFIELD(struct PgStat_TableStatus *, pgstat_info);
         /* preserve old partition key if we have one */
         if (keep_partkey)
         {
             SWAPFIELD(PartitionKey, rd_partkey);
             SWAPFIELD(MemoryContext, rd_partkeycxt);
         }
         if (newrel->rd_pdcxt != NULL)
         {
             /*
              * We are rebuilding a partitioned relation with a non-zero
              * reference count, so we must keep the old partition descriptor
              * around, in case there's a PartitionDirectory with a pointer to
              * it.  This means we can't free the old rd_pdcxt yet.  (This is
              * necessary because RelationGetPartitionDesc hands out direct
              * pointers to the relcache's data structure, unlike our usual
              * practice which is to hand out copies.  We'd have the same
              * problem with rd_partkey, except that we always preserve that
              * once created.)
              *
              * To ensure that it's not leaked completely, re-attach it to the
              * new reldesc, or make it a child of the new reldesc's rd_pdcxt
              * in the unlikely event that there is one already.  (Compare hack
              * in RelationBuildPartitionDesc.)  RelationClose will clean up
              * any such contexts once the reference count reaches zero.
              *
              * In the case where the reference count is zero, this code is not
              * reached, which should be OK because in that case there should
              * be no PartitionDirectory with a pointer to the old entry.
              *
              * Note that newrel and relation have already been swapped, so the
              * "old" partition descriptor is actually the one hanging off of
              * newrel.
              */
             relation->rd_partdesc = NULL;   /* ensure rd_partdesc is invalid */
             if (relation->rd_pdcxt != NULL) /* probably never happens */
                 MemoryContextSetParent(newrel->rd_pdcxt, relation->rd_pdcxt);
             else
                 relation->rd_pdcxt = newrel->rd_pdcxt;
             /* drop newrel's pointers so we don't destroy it below */
             newrel->rd_partdesc = NULL;
             newrel->rd_pdcxt = NULL;
         }
 
 #undef SWAPFIELD
 
         /* And now we can throw away the temporary entry */
         RelationDestroyRelation(newrel, !keep_tupdesc);
     }
 }

◆ RelationClose()

void RelationClose ( Relation relation )

Definition at line 2074 of file relcache.c.

References MemoryContextData::firstchild, InvalidSubTransactionId, MemoryContextDeleteChildren(), RelationData::rd_createSubid, RelationData::rd_newRelfilenodeSubid, RelationData::rd_pdcxt, RelationClearRelation(), RelationDecrementReferenceCount(), and RelationHasReferenceCountZero.

Referenced by index_close(), relation_close(), ReorderBufferCommit(), ReorderBufferToastReplace(), and ResourceOwnerReleaseInternal().

2075 {

2076 /* Note: no locking manipulations needed */

Data Structures

Macros

Typedefs

Functions

Variables

Macro Definition Documentation

◆ EOXactListAdd

◆ INITRELCACHESIZE

◆ MAX_EOXACT_LIST

◆ NUM_CRITICAL_LOCAL_INDEXES

◆ NUM_CRITICAL_LOCAL_RELS

◆ NUM_CRITICAL_SHARED_INDEXES

◆ NUM_CRITICAL_SHARED_RELS

◆ RECOVER_RELATION_BUILD_MEMORY

◆ RelationCacheDelete

◆ RelationCacheInsert

◆ RelationIdCacheLookup

◆ RELCACHE_INIT_FILEMAGIC

◆ SWAPFIELD

Typedef Documentation

◆ OpClassCacheEnt

◆ RelIdCacheEnt

Function Documentation

◆ AllocateRelationDesc()

◆ AtEOSubXact_cleanup()

◆ AtEOSubXact_RelationCache()

◆ AtEOXact_cleanup()

◆ AtEOXact_RelationCache()

◆ AttrDefaultFetch()

◆ BuildHardcodedDescriptor()

◆ CheckConstraintCmp()

◆ CheckConstraintFetch()

◆ equalPolicy()

◆ equalRSDesc()

◆ equalRuleLocks()

◆ errtable()

◆ errtablecol()

◆ errtablecolname()

◆ errtableconstraint()

◆ formrdesc()

◆ GetPgClassDescriptor()

◆ GetPgIndexDescriptor()

◆ GetRelationPublicationActions()

◆ IndexSupportInitialize()

◆ InitIndexAmRoutine()

◆ InitTableAmRoutine()

◆ load_critical_index()

◆ load_relcache_init_file()

◆ LookupOpclassInfo()

◆ RelationBuildDesc()

◆ RelationBuildLocalRelation()

◆ RelationBuildRuleLock()

◆ RelationBuildTupleDesc()

◆ RelationCacheInitFilePostInvalidate()

◆ RelationCacheInitFilePreInvalidate()

◆ RelationCacheInitFileRemove()

◆ RelationCacheInitFileRemoveInDir()

◆ RelationCacheInitialize()

◆ RelationCacheInitializePhase2()

◆ RelationCacheInitializePhase3()

◆ RelationCacheInvalidate()

◆ RelationCacheInvalidateEntry()

◆ RelationClearRelation()

◆ RelationClose()