#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/parallel.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/partition.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/publicationcmds.h"
#include "commands/trigger.h"
#include "miscadmin.h"
#include "nodes/makefuncs.h"
#include "nodes/nodeFuncs.h"
#include "optimizer/optimizer.h"
#include "pgstat.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	inprogressent

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 inprogressent	InProgressEnt

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, int ndef)

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

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 (bool debug_discard)

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	RelationAssumeNewRelfilenode (Relation relation)

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)

Bitmapset *	RelationGetIdentityKeyBitmap (Relation relation)

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

void	RelationBuildPublicationDesc (Relation relation, PublicationDesc *pubdesc)

Datum *	RelationGetIndexRawAttOptions (Relation indexrel)

static bytea **	CopyIndexAttOptions (bytea **srcopts, int natts)

bytea **	RelationGetIndexAttOptions (Relation relation, bool copy)

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 InProgressEnt *	in_progress_list

static int	in_progress_list_len

static int	in_progress_list_maxlen

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 188 of file relcache.c.

◆ INITRELCACHESIZE

#define INITRELCACHESIZE 400

Definition at line 3867 of file relcache.c.

◆ MAX_EOXACT_LIST

#define MAX_EOXACT_LIST 32

Definition at line 183 of file relcache.c.

◆ NUM_CRITICAL_LOCAL_INDEXES

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

◆ NUM_CRITICAL_LOCAL_RELS

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

◆ NUM_CRITICAL_SHARED_INDEXES

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

◆ NUM_CRITICAL_SHARED_RELS

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

◆ RECOVER_RELATION_BUILD_MEMORY

#define RECOVER_RELATION_BUILD_MEMORY 0

Definition at line 101 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 242 of file relcache.c.

◆ 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 208 of file relcache.c.

◆ 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 230 of file relcache.c.

◆ RELCACHE_INIT_FILEMAGIC

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

Definition at line 92 of file relcache.c.

◆ SWAPFIELD

#define SWAPFIELD	(	fldtype,
		fldname
	)

Value:

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

Typedef Documentation

◆ InProgressEnt

typedef struct inprogressent InProgressEnt

◆ OpClassCacheEnt

typedef struct opclasscacheent OpClassCacheEnt

◆ RelIdCacheEnt

typedef struct relidcacheent RelIdCacheEnt

Function Documentation

◆ AllocateRelationDesc()

static Relation AllocateRelationDesc ( Form_pg_class relp )

static

Definition at line 406 of file relcache.c.

 {
     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;
 }

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

Referenced by RelationBuildDesc().

◆ AtEOSubXact_cleanup()

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

static

Definition at line 3375 of file relcache.c.

 {
     /*
      * Is it a relation created in the current subtransaction?
      *
      * During subcommit, mark it as belonging to the parent, instead, as long
      * as it has not been dropped. Otherwise simply delete the relcache entry.
      * --- it isn't interesting any longer.
      */
     if (relation->rd_createSubid == mySubid)
     {
         /*
          * Valid rd_droppedSubid means the corresponding relation is dropped
          * but the relcache entry is preserved for at-commit pending sync. We
          * need to drop it explicitly here not to make the entry orphan.
          */
         Assert(relation->rd_droppedSubid == mySubid ||
                relation->rd_droppedSubid == InvalidSubTransactionId);
         if (isCommit && relation->rd_droppedSubid == InvalidSubTransactionId)
             relation->rd_createSubid = parentSubid;
         else if (RelationHasReferenceCountZero(relation))
         {
             /* allow the entry to be removed */
             relation->rd_createSubid = InvalidSubTransactionId;
             relation->rd_newRelfilenodeSubid = InvalidSubTransactionId;
             relation->rd_firstRelfilenodeSubid = InvalidSubTransactionId;
             relation->rd_droppedSubid = InvalidSubTransactionId;
             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 record
      * or drop record.
      */
     if (relation->rd_newRelfilenodeSubid == mySubid)
     {
         if (isCommit)
             relation->rd_newRelfilenodeSubid = parentSubid;
         else
             relation->rd_newRelfilenodeSubid = InvalidSubTransactionId;
     }
  
     if (relation->rd_firstRelfilenodeSubid == mySubid)
     {
         if (isCommit)
             relation->rd_firstRelfilenodeSubid = parentSubid;
         else
             relation->rd_firstRelfilenodeSubid = InvalidSubTransactionId;
     }
  
     if (relation->rd_droppedSubid == mySubid)
     {
         if (isCommit)
             relation->rd_droppedSubid = parentSubid;
         else
             relation->rd_droppedSubid = InvalidSubTransactionId;
     }
 }

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

Referenced by AtEOSubXact_RelationCache().

◆ AtEOSubXact_RelationCache()

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

Definition at line 3320 of file relcache.c.

 {
     HASH_SEQ_STATUS status;
     RelIdCacheEnt *idhentry;
     int         i;
  
     /*
      * Forget in_progress_list.  This is relevant when we're aborting due to
      * an error during RelationBuildDesc().  We don't commit subtransactions
      * during RelationBuildDesc().
      */
     Assert(in_progress_list_len == 0 || !isCommit);
     in_progress_list_len = 0;
  
     /*
      * 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 */
 }

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

Referenced by AbortSubTransaction(), and CommitSubTransaction().

◆ AtEOXact_cleanup()

static void AtEOXact_cleanup	(	Relation	relation,
		bool	isCommit
	)

static

Definition at line 3238 of file relcache.c.

 {
     bool        clear_relcache = false;
  
     /*
      * 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 the relation live after this transaction ends?
      *
      * During commit, clear the relcache entry if it is preserved after
      * relation drop, in order not to orphan the entry.  During rollback,
      * clear the relcache entry if the relation is created in the current
      * transaction since it isn't interesting any longer once we are out of
      * the transaction.
      */
     clear_relcache =
         (isCommit ?
          relation->rd_droppedSubid != InvalidSubTransactionId :
          relation->rd_createSubid != InvalidSubTransactionId);
  
     /*
      * Since we are now out of the transaction, reset the subids to zero. That
      * also lets RelationClearRelation() drop the relcache entry.
      */
     relation->rd_createSubid = InvalidSubTransactionId;
     relation->rd_newRelfilenodeSubid = InvalidSubTransactionId;
     relation->rd_firstRelfilenodeSubid = InvalidSubTransactionId;
     relation->rd_droppedSubid = InvalidSubTransactionId;
  
     if (clear_relcache)
     {
         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.
              */
             elog(WARNING, "cannot remove relcache entry for \"%s\" because it has nonzero refcount",
                  RelationGetRelationName(relation));
         }
     }
 }

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

Referenced by AtEOXact_RelationCache().

◆ AtEOXact_RelationCache()

void AtEOXact_RelationCache ( bool isCommit )

Definition at line 3168 of file relcache.c.

 {
     HASH_SEQ_STATUS status;
     RelIdCacheEnt *idhentry;
     int         i;
  
     /*
      * Forget in_progress_list.  This is relevant when we're aborting due to
      * an error during RelationBuildDesc().
      */
     Assert(in_progress_list_len == 0 || !isCommit);
     in_progress_list_len = 0;
  
     /*
      * 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;
 }

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

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

◆ AttrDefaultCmp()

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

static

Definition at line 4439 of file relcache.c.

 {
     const AttrDefault *ada = (const AttrDefault *) a;
     const AttrDefault *adb = (const AttrDefault *) b;
  
     return ada->adnum - adb->adnum;
 }

References a, AttrDefault::adnum, and b.

Referenced by AttrDefaultFetch().

◆ AttrDefaultFetch()

static void AttrDefaultFetch	(	Relation	relation,
		int	ndef
	)

static

Definition at line 4359 of file relcache.c.

 {
     AttrDefault *attrdef;
     Relation    adrel;
     SysScanDesc adscan;
     ScanKeyData skey;
     HeapTuple   htup;
     int         found = 0;
  
     /* Allocate array with room for as many entries as expected */
     attrdef = (AttrDefault *)
         MemoryContextAllocZero(CacheMemoryContext,
                                ndef * sizeof(AttrDefault));
  
     /* Search pg_attrdef for relevant entries */
     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);
  
     while (HeapTupleIsValid(htup = systable_getnext(adscan)))
     {
         Form_pg_attrdef adform = (Form_pg_attrdef) GETSTRUCT(htup);
         Datum       val;
         bool        isnull;
  
         /* protect limited size of array */
         if (found >= ndef)
         {
             elog(WARNING, "unexpected pg_attrdef record found for attribute %d of relation \"%s\"",
                  adform->adnum, RelationGetRelationName(relation));
             break;
         }
  
         val = fastgetattr(htup,
                           Anum_pg_attrdef_adbin,
                           adrel->rd_att, &isnull);
         if (isnull)
             elog(WARNING, "null adbin for attribute %d of relation \"%s\"",
                  adform->adnum, RelationGetRelationName(relation));
         else
         {
             /* detoast and convert to cstring in caller's context */
             char       *s = TextDatumGetCString(val);
  
             attrdef[found].adnum = adform->adnum;
             attrdef[found].adbin = MemoryContextStrdup(CacheMemoryContext, s);
             pfree(s);
             found++;
         }
     }
  
     systable_endscan(adscan);
     table_close(adrel, AccessShareLock);
  
     if (found != ndef)
         elog(WARNING, "%d pg_attrdef record(s) missing for relation \"%s\"",
              ndef - found, RelationGetRelationName(relation));
  
     /*
      * Sort the AttrDefault entries by adnum, for the convenience of
      * equalTupleDescs().  (Usually, they already will be in order, but this
      * might not be so if systable_getnext isn't using an index.)
      */
     if (found > 1)
         qsort(attrdef, found, sizeof(AttrDefault), AttrDefaultCmp);
  
     /* Install array only after it's fully valid */
     relation->rd_att->constr->defval = attrdef;
     relation->rd_att->constr->num_defval = found;
 }

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

Referenced by RelationBuildTupleDesc().

◆ BuildHardcodedDescriptor()

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

static

Definition at line 4294 of file relcache.c.

 {
     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;
 }

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

Referenced by GetPgClassDescriptor(), and GetPgIndexDescriptor().

◆ CheckConstraintCmp()

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

static

Definition at line 4543 of file relcache.c.

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

References a, b, and ConstrCheck::ccname.

Referenced by CheckConstraintFetch().

◆ CheckConstraintFetch()

static void CheckConstraintFetch ( Relation relation )

static

Definition at line 4454 of file relcache.c.

 {
     ConstrCheck *check;
     int         ncheck = relation->rd_rel->relchecks;
     Relation    conrel;
     SysScanDesc conscan;
     ScanKeyData skey[1];
     HeapTuple   htup;
     int         found = 0;
  
     /* Allocate array with room for as many entries as expected */
     check = (ConstrCheck *)
         MemoryContextAllocZero(CacheMemoryContext,
                                ncheck * sizeof(ConstrCheck));
  
     /* Search pg_constraint for relevant entries */
     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;
  
         /* We want check constraints only */
         if (conform->contype != CONSTRAINT_CHECK)
             continue;
  
         /* protect limited size of array */
         if (found >= ncheck)
         {
             elog(WARNING, "unexpected pg_constraint record found for relation \"%s\"",
                  RelationGetRelationName(relation));
             break;
         }
  
         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(WARNING, "null conbin for relation \"%s\"",
                  RelationGetRelationName(relation));
         else
         {
             /* detoast and convert to cstring in caller's context */
             char       *s = TextDatumGetCString(val);
  
             check[found].ccbin = MemoryContextStrdup(CacheMemoryContext, s);
             pfree(s);
             found++;
         }
     }
  
     systable_endscan(conscan);
     table_close(conrel, AccessShareLock);
  
     if (found != ncheck)
         elog(WARNING, "%d pg_constraint record(s) missing for relation \"%s\"",
              ncheck - found, RelationGetRelationName(relation));
  
     /*
      * Sort the records by name.  This ensures that CHECKs are applied in a
      * deterministic order, and it also makes equalTupleDescs() faster.
      */
     if (found > 1)
         qsort(check, found, sizeof(ConstrCheck), CheckConstraintCmp);
  
     /* Install array only after it's fully valid */
     relation->rd_att->constr->check = check;
     relation->rd_att->constr->num_check = found;
 }

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

Referenced by RelationBuildTupleDesc().

◆ CopyIndexAttOptions()

static bytea** CopyIndexAttOptions	(	bytea **	srcopts,
		int	natts
	)

static

Definition at line 5738 of file relcache.c.

 {
     bytea     **opts = palloc(sizeof(*opts) * natts);
  
     for (int i = 0; i < natts; i++)
     {
         bytea      *opt = srcopts[i];
  
         opts[i] = !opt ? NULL : (bytea *)
             DatumGetPointer(datumCopy(PointerGetDatum(opt), false, -1));
     }
  
     return opts;
 }

References datumCopy(), DatumGetPointer, i, opts, palloc(), and PointerGetDatum.

Referenced by RelationGetIndexAttOptions().

◆ equalPolicy()

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

static

Definition at line 950 of file relcache.c.

 {
     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;
 }

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

◆ equalRSDesc()

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

static

Definition at line 996 of file relcache.c.

 {
     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;
 }

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

Referenced by RelationClearRelation().

◆ equalRuleLocks()

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

static

Definition at line 905 of file relcache.c.

 {
     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;
 }

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

Referenced by RelationClearRelation().

◆ errtable()

int errtable ( Relation rel )

Definition at line 5819 of file relcache.c.

 {
     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 */
 }

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

Referenced by ATPrepChangePersistence(), ATRewriteTable(), BuildRelationExtStatistics(), check_default_partition_contents(), errtablecolname(), errtableconstraint(), ExecFindPartition(), and ExecPartitionCheckEmitError().

◆ errtablecol()

int errtablecol	(	Relation	rel,
		int	attnum
	)

Definition at line 5836 of file relcache.c.

 {
     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);
 }

References attname, attnum, errtablecolname(), get_attname(), NameStr, RelationGetDescr, RelationGetRelid, and TupleDescAttr.

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

◆ errtablecolname()

int errtablecolname	(	Relation	rel,
		const char *	colname
	)

Definition at line 5860 of file relcache.c.

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

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

Referenced by errtablecol().

◆ errtableconstraint()

int errtableconstraint	(	Relation	rel,
		const char *	conname
	)

Definition at line 5873 of file relcache.c.

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

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(), and ri_ReportViolation().

◆ formrdesc()

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

static

Definition at line 1865 of file relcache.c.

 {
     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_firstRelfilenodeSubid = InvalidSubTransactionId;
     relation->rd_droppedSubid = 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 = -1;
     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;    /* just to be sure */
  
     /*
      * 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;
 }

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_droppedSubid, RelationData::rd_firstRelfilenodeSubid, 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().

◆ GetPgClassDescriptor()

static TupleDesc GetPgClassDescriptor ( void )

static

Definition at line 4324 of file relcache.c.

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

References BuildHardcodedDescriptor(), and Desc_pg_class.

Referenced by RelationParseRelOptions().

◆ GetPgIndexDescriptor()

static TupleDesc GetPgIndexDescriptor ( void )

static

Definition at line 4337 of file relcache.c.

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

References BuildHardcodedDescriptor(), and Desc_pg_index.

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

◆ IndexSupportInitialize()

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

static

Definition at line 1587 of file relcache.c.

 {
     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));
     }
 }

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

Referenced by RelationInitIndexAccessInfo().

◆ InitIndexAmRoutine()

static void InitIndexAmRoutine ( Relation relation )

static

Definition at line 1392 of file relcache.c.

 {
     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);
 }

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

Referenced by load_relcache_init_file(), and RelationInitIndexAccessInfo().

◆ InitTableAmRoutine()

static void InitTableAmRoutine ( Relation relation )

static

Definition at line 1791 of file relcache.c.

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

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

Referenced by RelationInitTableAccessMethod().

◆ load_critical_index()

static void load_critical_index	(	Oid	indexoid,
		Oid	heapoid
	)

static

Definition at line 4258 of file relcache.c.

 {
     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);
  
     (void) RelationGetIndexAttOptions(ird, false);
 }

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

Referenced by RelationCacheInitializePhase3().

◆ load_relcache_init_file()

static bool load_relcache_init_file ( bool shared )

static

Definition at line 5937 of file relcache.c.

 {
     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 ? relform->reltype : RECORDOID;
         rel->rd_att->tdtypmod = -1; /* just to be sure */
  
         /* 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;
  
             /* finally, read the vector of opcoptions values */
             rel->rd_opcoptions = (bytea **)
                 MemoryContextAllocZero(indexcxt, sizeof(*rel->rd_opcoptions) * relform->relnatts);
  
             for (i = 0; i < relform->relnatts; i++)
             {
                 if (fread(&len, 1, sizeof(len), fp) != sizeof(len))
                     goto read_failed;
  
                 if (len > 0)
                 {
                     rel->rd_opcoptions[i] = (bytea *) MemoryContextAlloc(indexcxt, len);
                     if (fread(rel->rd_opcoptions[i], 1, len, fp) != len)
                         goto read_failed;
                 }
             }
  
             /* 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 (RELKIND_HAS_TABLE_AM(rel->rd_rel->relkind) || rel->rd_rel->relkind == RELKIND_SEQUENCE)
                 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);
             Assert(rel->rd_opcoptions == 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_partdesc_nodetached = NULL;
         rel->rd_partdesc_nodetached_xmin = InvalidTransactionId;
         rel->rd_pdcxt = NULL;
         rel->rd_pddcxt = 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_attrsvalid = false;
         rel->rd_keyattr = NULL;
         rel->rd_pkattr = NULL;
         rel->rd_idattr = NULL;
         rel->rd_hotblockingattr = NULL;
         rel->rd_pubdesc = 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_firstRelfilenodeSubid = InvalidSubTransactionId;
         rel->rd_droppedSubid = 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;
 }

Referenced by RelationCacheInitializePhase2(), and RelationCacheInitializePhase3().

◆ LookupOpclassInfo()

static OpClassCacheEnt * LookupOpclassInfo	(	Oid	operatorClassOid,
		StrategyNumber	numSupport
	)

static

Definition at line 1638 of file relcache.c.

 {
     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;
  
         /* Also make sure CacheMemoryContext exists */
         if (!CacheMemoryContext)
             CreateCacheMemoryContext();
  
         ctl.keysize = sizeof(Oid);
         ctl.entrysize = sizeof(OpClassCacheEnt);
         OpClassCache = hash_create("Operator class cache", 64,
                                    &ctl, HASH_ELEM | HASH_BLOBS);
     }
  
     opcentry = (OpClassCacheEnt *) hash_search(OpClassCache,
                                                (void *) &operatorClassOid,
                                                HASH_ENTER, &found);
  
     if (!found)
     {
         /* Initialize new entry */
         opcentry->valid = false;    /* until known OK */
         opcentry->numSupport = numSupport;
         opcentry->supportProcs = NULL;  /* filled below */
     }
     else
     {
         Assert(numSupport == opcentry->numSupport);
     }
  
     /*
      * When aggressively testing cache-flush hazards, we disable the operator
      * class cache and force reloading of the info on each call.  This models
      * no real-world behavior, since the cache entries are never invalidated
      * otherwise.  However it can be helpful for detecting bugs in the cache
      * loading logic itself, such as reliance on a non-nailed index.  Given
      * the limited use-case and the fact that this adds a great deal of
      * expense, we enable it only for high values of debug_discard_caches.
      */
 #ifdef DISCARD_CACHES_ENABLED
     if (debug_discard_caches > 2)
         opcentry->valid = false;
 #endif
  
     if (opcentry->valid)
         return opcentry;
  
     /*
      * Need to fill in new entry.  First allocate space, unless we already did
      * so in some previous attempt.
      */
     if (opcentry->supportProcs == NULL && numSupport > 0)
         opcentry->supportProcs = (RegProcedure *)
             MemoryContextAllocZero(CacheMemoryContext,
                                    numSupport * sizeof(RegProcedure));
  
     /*
      * 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;
 }

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

Referenced by IndexSupportInitialize().

◆ RelationAssumeNewRelfilenode()

void RelationAssumeNewRelfilenode ( Relation relation )

Definition at line 3844 of file relcache.c.

 {
     relation->rd_newRelfilenodeSubid = GetCurrentSubTransactionId();
     if (relation->rd_firstRelfilenodeSubid == InvalidSubTransactionId)
         relation->rd_firstRelfilenodeSubid = relation->rd_newRelfilenodeSubid;
  
     /* Flag relation as needing eoxact cleanup (to clear these fields) */
     EOXactListAdd(relation);
 }

References EOXactListAdd, GetCurrentSubTransactionId(), InvalidSubTransactionId, RelationData::rd_firstRelfilenodeSubid, and RelationData::rd_newRelfilenodeSubid.

Referenced by ATExecSetTableSpace(), reindex_index(), RelationSetNewRelfilenode(), and swap_relation_files().

◆ RelationBuildDesc()

static Relation RelationBuildDesc	(	Oid	targetRelId,
		bool	insertIt
	)

static

Definition at line 1037 of file relcache.c.

 {
     int         in_progress_offset;
     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 when debug_discard_caches is active, and
      * perhaps it's not true in other cases.
      *
      * When debug_discard_caches is active or when forced to by
      * RECOVER_RELATION_BUILD_MEMORY=1, 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.
      */
 #ifdef MAYBE_RECOVER_RELATION_BUILD_MEMORY
     MemoryContext tmpcxt = NULL;
     MemoryContext oldcxt = NULL;
  
     if (RECOVER_RELATION_BUILD_MEMORY || debug_discard_caches > 0)
     {
         tmpcxt = AllocSetContextCreate(CurrentMemoryContext,
                                        "RelationBuildDesc workspace",
                                        ALLOCSET_DEFAULT_SIZES);
         oldcxt = MemoryContextSwitchTo(tmpcxt);
     }
 #endif
  
     /* Register to catch invalidation messages */
     if (in_progress_list_len >= in_progress_list_maxlen)
     {
         int         allocsize;
  
         allocsize = in_progress_list_maxlen * 2;
         in_progress_list = repalloc(in_progress_list,
                                     allocsize * sizeof(*in_progress_list));
         in_progress_list_maxlen = allocsize;
     }
     in_progress_offset = in_progress_list_len++;
     in_progress_list[in_progress_offset].reloid = targetRelId;
 retry:
     in_progress_list[in_progress_offset].invalidated = false;
  
     /*
      * 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))
     {
 #ifdef MAYBE_RECOVER_RELATION_BUILD_MEMORY
         if (tmpcxt)
         {
             /* Return to caller's context, and blow away the temporary context */
             MemoryContextSwitchTo(oldcxt);
             MemoryContextDelete(tmpcxt);
         }
 #endif
         Assert(in_progress_offset + 1 == in_progress_list_len);
         in_progress_list_len--;
         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.  Since we don't flush
      * new relations, it won't be new.  It could be temp though.
      */
     relation->rd_refcnt = 0;
     relation->rd_isnailed = false;
     relation->rd_createSubid = InvalidSubTransactionId;
     relation->rd_newRelfilenodeSubid = InvalidSubTransactionId;
     relation->rd_firstRelfilenodeSubid = InvalidSubTransactionId;
     relation->rd_droppedSubid = 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);
  
     /* 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_partdesc_nodetached = NULL;
     relation->rd_partdesc_nodetached_xmin = InvalidTransactionId;
     relation->rd_pdcxt = NULL;
     relation->rd_pddcxt = NULL;
     relation->rd_partcheck = NIL;
     relation->rd_partcheckvalid = false;
     relation->rd_partcheckcxt = NULL;
  
     /*
      * initialize access method information
      */
     if (relation->rd_rel->relkind == RELKIND_INDEX ||
         relation->rd_rel->relkind == RELKIND_PARTITIONED_INDEX)
         RelationInitIndexAccessInfo(relation);
     else if (RELKIND_HAS_TABLE_AM(relation->rd_rel->relkind) ||
              relation->rd_rel->relkind == RELKIND_SEQUENCE)
         RelationInitTableAccessMethod(relation);
     else
         Assert(relation->rd_rel->relam == InvalidOid);
  
     /* extract reloptions if any */
     RelationParseRelOptions(relation, pg_class_tuple);
  
     /*
      * Fetch rules and triggers that affect this relation.
      *
      * Note that RelationBuildRuleLock() relies on this being done after
      * extracting the relation's reloptions.
      */
     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;
  
     /*
      * 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);
  
     /*
      * If an invalidation arrived mid-build, start over.  Between here and the
      * end of this function, don't add code that does or reasonably could read
      * system catalogs.  That range must be free from invalidation processing
      * for the !insertIt case.  For the insertIt case, RelationCacheInsert()
      * will enroll this relation in ordinary relcache invalidation processing,
      */
     if (in_progress_list[in_progress_offset].invalidated)
     {
         RelationDestroyRelation(relation, false);
         goto retry;
     }
     Assert(in_progress_offset + 1 == in_progress_list_len);
     in_progress_list_len--;
  
     /*
      * 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;
  
 #ifdef MAYBE_RECOVER_RELATION_BUILD_MEMORY
     if (tmpcxt)
     {
         /* Return to caller's context, and blow away the temporary context */
         MemoryContextSwitchTo(oldcxt);
         MemoryContextDelete(tmpcxt);
     }
 #endif
  
     return relation;
 }

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

◆ 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 3457 of file relcache.c.

 {
     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;
     rel->rd_firstRelfilenodeSubid = InvalidSubTransactionId;
     rel->rd_droppedSubid = 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;
  
     /*
      * RelationInitTableAccessMethod will do syscache lookups, so we mustn't
      * run it in CacheMemoryContext.  Fortunately, the remaining steps don't
      * require a long-lived current context.
      */
     MemoryContextSwitchTo(oldcxt);
  
     if (RELKIND_HAS_TABLE_AM(relkind) || relkind == RELKIND_SEQUENCE)
         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);
  
     /* It's fully valid */
     rel->rd_isvalid = true;
  
     /*
      * Caller expects us to pin the returned entry.
      */
     RelationIncrementReferenceCount(rel);
  
     return rel;
 }

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_droppedSubid, RelationData::rd_firstRelfilenodeSubid, 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(), relname, TupleDescData::tdrefcount, and TupleDescAttr.

Referenced by heap_create().

◆ RelationBuildPublicationDesc()

void RelationBuildPublicationDesc	(	Relation	relation,
		PublicationDesc *	pubdesc
	)

Definition at line 5561 of file relcache.c.

 {
     List       *puboids;
     ListCell   *lc;
     MemoryContext oldcxt;
     Oid         schemaid;
     List       *ancestors = NIL;
     Oid         relid = RelationGetRelid(relation);
  
     /*
      * If not publishable, it publishes no actions.  (pgoutput_change() will
      * ignore it.)
      */
     if (!is_publishable_relation(relation))
     {
         memset(pubdesc, 0, sizeof(PublicationDesc));
         pubdesc->rf_valid_for_update = true;
         pubdesc->rf_valid_for_delete = true;
         pubdesc->cols_valid_for_update = true;
         pubdesc->cols_valid_for_delete = true;
         return;
     }
  
     if (relation->rd_pubdesc)
     {
         memcpy(pubdesc, relation->rd_pubdesc, sizeof(PublicationDesc));
         return;
     }
  
     memset(pubdesc, 0, sizeof(PublicationDesc));
     pubdesc->rf_valid_for_update = true;
     pubdesc->rf_valid_for_delete = true;
     pubdesc->cols_valid_for_update = true;
     pubdesc->cols_valid_for_delete = true;
  
     /* Fetch the publication membership info. */
     puboids = GetRelationPublications(relid);
     schemaid = RelationGetNamespace(relation);
     puboids = list_concat_unique_oid(puboids, GetSchemaPublications(schemaid));
  
     if (relation->rd_rel->relispartition)
     {
         /* Add publications that the ancestors are in too. */
         ancestors = get_partition_ancestors(relid);
  
         foreach(lc, ancestors)
         {
             Oid         ancestor = lfirst_oid(lc);
  
             puboids = list_concat_unique_oid(puboids,
                                              GetRelationPublications(ancestor));
             schemaid = get_rel_namespace(ancestor);
             puboids = list_concat_unique_oid(puboids,
                                              GetSchemaPublications(schemaid));
         }
     }
     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);
  
         pubdesc->pubactions.pubinsert |= pubform->pubinsert;
         pubdesc->pubactions.pubupdate |= pubform->pubupdate;
         pubdesc->pubactions.pubdelete |= pubform->pubdelete;
         pubdesc->pubactions.pubtruncate |= pubform->pubtruncate;
  
         /*
          * Check if all columns referenced in the filter expression are part
          * of the REPLICA IDENTITY index or not.
          *
          * If the publication is FOR ALL TABLES then it means the table has no
          * row filters and we can skip the validation.
          */
         if (!pubform->puballtables &&
             (pubform->pubupdate || pubform->pubdelete) &&
             pub_rf_contains_invalid_column(pubid, relation, ancestors,
                                            pubform->pubviaroot))
         {
             if (pubform->pubupdate)
                 pubdesc->rf_valid_for_update = false;
             if (pubform->pubdelete)
                 pubdesc->rf_valid_for_delete = false;
         }
  
         /*
          * Check if all columns are part of the REPLICA IDENTITY index or not.
          *
          * If the publication is FOR ALL TABLES then it means the table has no
          * column list and we can skip the validation.
          */
         if (!pubform->puballtables &&
             (pubform->pubupdate || pubform->pubdelete) &&
             pub_collist_contains_invalid_column(pubid, relation, ancestors,
                                                 pubform->pubviaroot))
         {
             if (pubform->pubupdate)
                 pubdesc->cols_valid_for_update = false;
             if (pubform->pubdelete)
                 pubdesc->cols_valid_for_delete = false;
         }
  
         ReleaseSysCache(tup);
  
         /*
          * If we know everything is replicated and the row filter is invalid
          * for update and delete, there is no point to check for other
          * publications.
          */
         if (pubdesc->pubactions.pubinsert && pubdesc->pubactions.pubupdate &&
             pubdesc->pubactions.pubdelete && pubdesc->pubactions.pubtruncate &&
             !pubdesc->rf_valid_for_update && !pubdesc->rf_valid_for_delete)
             break;
  
         /*
          * If we know everything is replicated and the column list is invalid
          * for update and delete, there is no point to check for other
          * publications.
          */
         if (pubdesc->pubactions.pubinsert && pubdesc->pubactions.pubupdate &&
             pubdesc->pubactions.pubdelete && pubdesc->pubactions.pubtruncate &&
             !pubdesc->cols_valid_for_update && !pubdesc->cols_valid_for_delete)
             break;
     }
  
     if (relation->rd_pubdesc)
     {
         pfree(relation->rd_pubdesc);
         relation->rd_pubdesc = NULL;
     }
  
     /* Now save copy of the descriptor in the relcache entry. */
     oldcxt = MemoryContextSwitchTo(CacheMemoryContext);
     relation->rd_pubdesc = palloc(sizeof(PublicationDesc));
     memcpy(relation->rd_pubdesc, pubdesc, sizeof(PublicationDesc));
     MemoryContextSwitchTo(oldcxt);
 }

References CacheMemoryContext, PublicationDesc::cols_valid_for_delete, PublicationDesc::cols_valid_for_update, elog, ERROR, get_partition_ancestors(), get_rel_namespace(), GetAllTablesPublications(), GetRelationPublications(), GetSchemaPublications(), GETSTRUCT, HeapTupleIsValid, is_publishable_relation(), lfirst_oid, list_concat_unique_oid(), MemoryContextSwitchTo(), NIL, ObjectIdGetDatum, palloc(), pfree(), pub_collist_contains_invalid_column(), pub_rf_contains_invalid_column(), PublicationDesc::pubactions, PublicationActions::pubdelete, PublicationActions::pubinsert, PUBLICATIONOID, PublicationActions::pubtruncate, PublicationActions::pubupdate, RelationData::rd_pubdesc, RelationData::rd_rel, RelationGetNamespace, RelationGetRelid, ReleaseSysCache(), PublicationDesc::rf_valid_for_delete, PublicationDesc::rf_valid_for_update, and SearchSysCache1().

Referenced by CheckCmdReplicaIdentity().

◆ RelationBuildRuleLock()

static void RelationBuildRuleLock ( Relation relation )

static

Definition at line 730 of file relcache.c.

 {
     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;
         Oid         check_as_user;
  
         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);
  
         /*
          * If this is a SELECT rule defining a view, and the view has
          * "security_invoker" set, we must perform all permissions checks on
          * relations referred to by the rule as the invoking user.
          *
          * In all other cases (including non-SELECT rules on security invoker
          * views), perform the permissions checks as the relation owner.
          */
         if (rule->event == CMD_SELECT &&
             relation->rd_rel->relkind == RELKIND_VIEW &&
             RelationHasSecurityInvoker(relation))
             check_as_user = InvalidOid;
         else
             check_as_user = relation->rd_rel->relowner;
  
         /*
          * 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, check_as_user);
         setRuleCheckAsUser(rule->qual, check_as_user);
  
         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;
 }

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

Referenced by RelationBuildDesc(), and RelationCacheInitializePhase3().

◆ RelationBuildTupleDesc()

static void RelationBuildTupleDesc ( Relation relation )

static

Definition at line 518 of file relcache.c.

 {
     HeapTuple   pg_attribute_tuple;
     Relation    pg_attribute_desc;
     SysScanDesc pg_attribute_scan;
     ScanKeyData skey[2];
     int         need;
     TupleConstr *constr;
     AttrMissing *attrmiss = NULL;
     int         ndef = 0;
  
     /* fill rd_att's type ID fields (compare heap.c's AddNewRelationTuple) */
     relation->rd_att->tdtypeid =
         relation->rd_rel->reltype ? relation->rd_rel->reltype : RECORDOID;
     relation->rd_att->tdtypmod = -1;    /* just to be sure */
  
     constr = (TupleConstr *) MemoryContextAllocZero(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 relation \"%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 (attp->atthasdef)
             ndef++;
  
         /* If the column has a "missing" value, put it in the attrmiss array */
         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, "pg_attribute catalog is missing %d attribute(s) for relation OID %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 ||
         constr->has_generated_stored ||
         ndef > 0 ||
         attrmiss ||
         relation->rd_rel->relchecks > 0)
     {
         relation->rd_att->constr = constr;
  
         if (ndef > 0)           /* DEFAULTs */
             AttrDefaultFetch(relation, ndef);
         else
             constr->num_defval = 0;
  
         constr->missing = attrmiss;
  
         if (relation->rd_rel->relchecks > 0)    /* CHECKs */
             CheckConstraintFetch(relation);
         else
             constr->num_check = 0;
     }
     else
     {
         pfree(constr);
         relation->rd_att->constr = NULL;
     }
 }

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

Referenced by RelationBuildDesc().

◆ RelationCacheInitFilePostInvalidate()

void RelationCacheInitFilePostInvalidate ( void )

Definition at line 6646 of file relcache.c.

 {
     LWLockRelease(RelCacheInitLock);
 }

References LWLockRelease().

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

◆ RelationCacheInitFilePreInvalidate()

void RelationCacheInitFilePreInvalidate ( void )

Definition at line 6621 of file relcache.c.

 {
     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);
 }

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

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

◆ RelationCacheInitFileRemove()

void RelationCacheInitFileRemove ( void )

Definition at line 6661 of file relcache.c.

 {
     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);
 }

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

Referenced by StartupXLOG().

◆ RelationCacheInitFileRemoveInDir()

static void RelationCacheInitFileRemoveInDir ( const char * tblspcpath )

static

Definition at line 6694 of file relcache.c.

 {
     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);
 }

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

Referenced by RelationCacheInitFileRemove().

◆ RelationCacheInitialize()

void RelationCacheInitialize ( void )

Definition at line 3870 of file relcache.c.

 {
     HASHCTL     ctl;
     int         allocsize;
  
     /*
      * make sure cache memory context exists
      */
     if (!CacheMemoryContext)
         CreateCacheMemoryContext();
  
     /*
      * create hashtable that indexes the relcache
      */
     ctl.keysize = sizeof(Oid);
     ctl.entrysize = sizeof(RelIdCacheEnt);
     RelationIdCache = hash_create("Relcache by OID", INITRELCACHESIZE,
                                   &ctl, HASH_ELEM | HASH_BLOBS);
  
     /*
      * reserve enough in_progress_list slots for many cases
      */
     allocsize = 4;
     in_progress_list =
         MemoryContextAlloc(CacheMemoryContext,
                            allocsize * sizeof(*in_progress_list));
     in_progress_list_maxlen = allocsize;
  
     /*
      * relation mapper needs to be initialized too
      */
     RelationMapInitialize();
 }

References CacheMemoryContext, CreateCacheMemoryContext(), HASHCTL::entrysize, HASH_BLOBS, hash_create(), HASH_ELEM, in_progress_list, in_progress_list_maxlen, INITRELCACHESIZE, HASHCTL::keysize, MemoryContextAlloc(), RelationIdCache, and RelationMapInitialize().

Referenced by InitPostgres().

◆ RelationCacheInitializePhase2()

void RelationCacheInitializePhase2 ( void )

Definition at line 3916 of file relcache.c.

 {
     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);
 }

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

◆ RelationCacheInitializePhase3()

void RelationCacheInitializePhase3 ( void )

Definition at line 3975 of file relcache.c.

 {
     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 &&
             (RELKIND_HAS_TABLE_AM(relation->rd_rel->relkind) || relation->rd_rel->relkind == RELKIND_SEQUENCE))
         {
             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);
     }
 }

References Assert(), CacheMemoryContext, CLASS_TUPLE_SIZE, criticalRelcachesBuilt, criticalSharedRelcachesBuilt, 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, InitCatalogCachePhase2(), InvalidOid, IsBootstrapProcessingMode, load_critical_index(), load_relcache_init_file(), MemoryContextSwitchTo(), ObjectIdGetDatum, 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, RelationIdCache, RelationIncrementReferenceCount(), RelationInitTableAccessMethod(), RelationMapInitializePhase3(), RelationParseRelOptions(), relidcacheent::reldesc, ReleaseSysCache(), RELOID, SearchSysCache1(), status(), TupleDescData::tdtypeid, TupleDescData::tdtypmod, RelationData::trigdesc, and write_relcache_init_file().

Referenced by InitPostgres().

◆ RelationCacheInvalidate()

void RelationCacheInvalidate ( bool debug_discard )

Definition at line 2924 of file relcache.c.

 {
     HASH_SEQ_STATUS status;
     RelIdCacheEnt *idhentry;
     Relation    relation;
     List       *rebuildFirstList = NIL;
     List       *rebuildList = NIL;
     ListCell   *l;
     int         i;
  
     /*
      * 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_firstRelfilenodeSubid != 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);
  
     if (!debug_discard)
         /* Any RelationBuildDesc() on the stack must start over. */
         for (i = 0; i < in_progress_list_len; i++)
             in_progress_list[i].invalidated = true;
 }

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

Referenced by InvalidateSystemCachesExtended(), and LocalExecuteInvalidationMessage().

◆ RelationCacheInvalidateEntry()

void RelationCacheInvalidateEntry ( Oid relationId )

Definition at line 2868 of file relcache.c.

 {
     Relation    relation;
  
     RelationIdCacheLookup(relationId, relation);
  
     if (PointerIsValid(relation))
     {
         relcacheInvalsReceived++;
         RelationFlushRelation(relation);
     }
     else
     {
         int         i;
  
         for (i = 0; i < in_progress_list_len; i++)
             if (in_progress_list[i].reloid == relationId)
                 in_progress_list[i].invalidated = true;
     }
 }

References i, in_progress_list, in_progress_list_len, inprogressent::invalidated, PointerIsValid, RelationFlushRelation(), RelationIdCacheLookup, and relcacheInvalsReceived.

Referenced by LocalExecuteInvalidationMessage().

◆ RelationClearRelation()

static void RelationClearRelation	(	Relation	relation,
		bool	rebuild
	)

static

Definition at line 2493 of file relcache.c.

 {
     /*
      * 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;
     }
  
     /* Mark it invalid until we've finished rebuild */
     relation->rd_isvalid = false;
  
     /* See RelationForgetRelation(). */
     if (relation->rd_droppedSubid != InvalidSubTransactionId)
         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)
     {
         if (IsTransactionState())
             RelationReloadIndexInfo(relation);
         return;
     }
  
     /*
      * 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_*Subid, 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);
  
         /*
          * Between here and the end of the swap, don't add code that does or
          * reasonably could read system catalogs.  That range must be free
          * from invalidation processing.  See RelationBuildDesc() manipulation
          * of in_progress_list.
          */
  
         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);
         SWAPFIELD(SubTransactionId, rd_firstRelfilenodeSubid);
         SWAPFIELD(SubTransactionId, rd_droppedSubid);
         /* 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 / enabled must be preserved */
         SWAPFIELD(struct PgStat_TableStatus *, pgstat_info);
         SWAPFIELD(bool, pgstat_enabled);
         /* preserve old partition key if we have one */
         if (keep_partkey)
         {
             SWAPFIELD(PartitionKey, rd_partkey);
             SWAPFIELD(MemoryContext, rd_partkeycxt);
         }
         if (newrel->rd_pdcxt != NULL || newrel->rd_pddcxt != 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 */
             relation->rd_partdesc_nodetached = NULL;
             relation->rd_partdesc_nodetached_xmin = InvalidTransactionId;
             if (relation->rd_pdcxt != NULL) /* probably never happens */
                 MemoryContextSetParent(newrel->rd_pdcxt, relation->rd_pdcxt);
             else
                 relation->rd_pdcxt = newrel->rd_pdcxt;
             if (relation->rd_pddcxt != NULL)
                 MemoryContextSetParent(newrel->rd_pddcxt, relation->rd_pddcxt);
             else
                 relation->rd_pddcxt = newrel->rd_pddcxt;
             /* drop newrel's pointers so we don't destroy it below */
             newrel->rd_partdesc = NULL;
             newrel->rd_partdesc_nodetached = NULL;
             newrel->rd_partdesc_nodetached_xmin = InvalidTransactionId;
             newrel->rd_pdcxt = NULL;
             newrel->rd_pddcxt = NULL;
         }
  
 #undef SWAPFIELD
  
         /* And now we can throw away the temporary entry */
         RelationDestroyRelation(newrel, !keep_tupdesc);
     }
 }

References Assert(), CLASS_TUPLE_SIZE, elog, equalRSDesc(), equalRuleLocks(), equalTupleDescs(), ERROR, HistoricSnapshotActive(), InvalidSubTransactionId, InvalidTransactionId, IsTransactionState(), MemoryContextSetParent(), pfree(), RelationData::rd_amcache, RelationData::rd_att, RelationData::rd_droppedSubid, RelationData::rd_indexcxt, RelationData::rd_isnailed, RelationData::rd_isvalid, RelationData::rd_partdesc, RelationData::rd_partdesc_nodetached, RelationData::rd_partdesc_nodetached_xmin, RelationData::rd_partkey, RelationData::rd_pdcxt, RelationData::rd_pddcxt, 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().

◆ RelationClose()

void RelationClose ( Relation relation )

Definition at line 2159 of file relcache.c.

 {
     /* Note: no locking manipulations needed */
     RelationDecrementReferenceCount(relation);
  
     /*
      * If the relation is no longer open in this session, we can clean up any
      * stale partition descriptors it has.  This is unlikely, so check to see
      * if there are child contexts before expending a call to mcxt.c.
      */
     if (RelationHasReferenceCountZero(relation))
     {
         if (relation->rd_pdcxt != NULL &&
             relation->rd_pdcxt->firstchild != NULL)
             MemoryContextDeleteChildren(relation->rd_pdcxt);
  
         if (relation->rd_pddcxt != NULL &&
             relation->rd_pddcxt->firstchild != NULL)
             MemoryContextDeleteChildren(relation->rd_pddcxt);
     }
  
 #ifdef RELCACHE_FORCE_RELEASE
     if (RelationHasReferenceCountZero(relation) &&
         relation->rd_createSubid == InvalidSubTransactionId &&
         relation->rd_firstRelfilenodeSubid == InvalidSubTransactionId)
         RelationClearRelation(relation, false);
 #endif
 }

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

Referenced by index_close(), init_tuple_slot(), maybe_send_schema(), pgoutput_change(), pgoutput_row_filter_init(), relation_close(), RelationGetIdentityKeyBitmap(), ReorderBufferProcessTXN(), ReorderBufferToastReplace(), and ResourceOwnerReleaseInternal().

◆ RelationCloseSmgrByOid()

void RelationCloseSmgrByOid ( Oid relationId )

Definition at line 3033 of file relcache.c.

 {
     Relation    relation;
  
     RelationIdCacheLookup(relationId, relation);
  
     if (!PointerIsValid(relation))
         return;                 /* not in cache, nothing to do */
  
     RelationCloseSmgr(relation);
 }

References PointerIsValid, RelationCloseSmgr, and RelationIdCacheLookup.

Referenced by swap_relation_files().

◆ RelationDecrementReferenceCount()

void RelationDecrementReferenceCount ( Relation rel )

Definition at line 2139 of file relcache.c.

 {
     Assert(rel->rd_refcnt > 0);
     rel->rd_refcnt -= 1;
     if (!IsBootstrapProcessingMode())
         ResourceOwnerForgetRelationRef(CurrentResourceOwner, rel);
 }

References Assert(), CurrentResourceOwner, IsBootstrapProcessingMode, RelationData::rd_refcnt, and ResourceOwnerForgetRelationRef().

Referenced by DestroyPartitionDirectory(), heap_endscan(), index_endscan(), RelationCacheInitializePhase3(), RelationClose(), and RelationFlushRelation().

◆ RelationDestroyRelation()

static void RelationDestroyRelation	(	Relation	relation,
		bool	remember_tupdesc
	)

static

Definition at line 2401 of file relcache.c.

 {
     Assert(RelationHasReferenceCountZero(relation));
  
     /*
      * Make sure smgr and lower levels close the relation's files, if they
      * weren't closed already.  (This was probably done by caller, but let's
      * just be real sure.)
      */
     RelationCloseSmgr(relation);
  
     /* break mutual link with stats entry */
     pgstat_unlink_relation(relation);
  
     /*
      * Free all the subsidiary data structures of the relcache entry, then the
      * entry itself.
      */
     if (relation->rd_rel)
         pfree(relation->rd_rel);
     /* can't use DecrTupleDescRefCount here */
     Assert(relation->rd_att->tdrefcount > 0);
     if (--relation->rd_att->tdrefcount == 0)
     {
         /*
          * If we Rebuilt a relcache entry during a transaction then its
          * possible we did that because the TupDesc changed as the result of
          * an ALTER TABLE that ran at less than AccessExclusiveLock. It's
          * possible someone copied that TupDesc, in which case the copy would
          * point to free'd memory. So if we rebuild an entry we keep the
          * TupDesc around until end of transaction, to be safe.
          */
         if (remember_tupdesc)
             RememberToFreeTupleDescAtEOX(relation->rd_att);
         else
             FreeTupleDesc(relation->rd_att);
     }
     FreeTriggerDesc(relation->trigdesc);
     list_free_deep(relation->rd_fkeylist);
     list_free(relation->rd_indexlist);
     list_free(relation->rd_statlist);
     bms_free(relation->rd_keyattr);
     bms_free(relation->rd_pkattr);
     bms_free(relation->rd_idattr);
     bms_free(relation->rd_hotblockingattr);
     if (relation->rd_pubdesc)
         pfree(relation->rd_pubdesc);
     if (relation->rd_options)
         pfree(relation->rd_options);
     if (relation->rd_indextuple)
         pfree(relation->rd_indextuple);
     if (relation->rd_amcache)
         pfree(relation->rd_amcache);
     if (relation->rd_fdwroutine)
         pfree(relation->rd_fdwroutine);
     if (relation->rd_indexcxt)
         MemoryContextDelete(relation->rd_indexcxt);
     if (relation->rd_rulescxt)
         MemoryContextDelete(relation->rd_rulescxt);
     if (relation->rd_rsdesc)
         MemoryContextDelete(relation->rd_rsdesc->rscxt);
     if (relation->rd_partkeycxt)
         MemoryContextDelete(relation->rd_partkeycxt);
     if (relation->rd_pdcxt)
         MemoryContextDelete(relation->rd_pdcxt);
     if (relation->rd_pddcxt)
         MemoryContextDelete(relation->rd_pddcxt);
     if (relation->rd_partcheckcxt)
         MemoryContextDelete(relation->rd_partcheckcxt);
     pfree(relation);
 }

References Assert(), bms_free(), FreeTriggerDesc(), FreeTupleDesc(), list_free(), list_free_deep(), MemoryContextDelete(), pfree(), pgstat_unlink_relation(), RelationData::rd_amcache, RelationData::rd_att, RelationData::rd_fdwroutine, RelationData::rd_fkeylist, RelationData::rd_hotblockingattr, RelationData::rd_idattr, RelationData::rd_indexcxt, RelationData::rd_indexlist, RelationData::rd_indextuple, RelationData::rd_keyattr, RelationData::rd_options, RelationData::rd_partcheckcxt, RelationData::rd_partkeycxt, RelationData::rd_pdcxt, RelationData::rd_pddcxt, RelationData::rd_pkattr, RelationData::rd_pubdesc, RelationData::rd_rel, RelationData::rd_rsdesc, RelationData::rd_rulescxt, RelationData::rd_statlist, RelationCloseSmgr, RelationHasReferenceCountZero, RememberToFreeTupleDescAtEOX(), RowSecurityDesc::rscxt, TupleDescData::tdrefcount, and RelationData::trigdesc.

Referenced by RelationBuildDesc(), and RelationClearRelation().

◆ RelationFlushRelation()

static void RelationFlushRelation ( Relation relation )

static

Definition at line 2791 of file relcache.c.

 {
     if (relation->rd_createSubid != InvalidSubTransactionId ||
         relation->rd_firstRelfilenodeSubid != InvalidSubTransactionId)
     {
         /*
          * New relcache entries are always rebuilt, not flushed; else we'd
          * forget the "new" status of the relation.  Ditto for the
          * new-relfilenode status.
          *
          * The rel could have zero refcnt here, so temporarily increment the
          * refcnt to ensure it's safe to rebuild it.  We can assume that the
          * current transaction has some lock on the rel already.
          */
         RelationIncrementReferenceCount(relation);
         RelationClearRelation(relation, true);
         RelationDecrementReferenceCount(relation);
     }
     else
     {
         /*
          * Pre-existing rels can be dropped from the relcache if not open.
          */
         bool        rebuild = !RelationHasReferenceCountZero(relation);
  
         RelationClearRelation(relation, rebuild);
     }
 }

References InvalidSubTransactionId, RelationData::rd_createSubid, RelationData::rd_firstRelfilenodeSubid, RelationClearRelation(), RelationDecrementReferenceCount(), RelationHasReferenceCountZero, and RelationIncrementReferenceCount().

Referenced by RelationCacheInvalidateEntry().

◆ RelationForgetRelation()

void RelationForgetRelation ( Oid rid )

Definition at line 2824 of file relcache.c.

 {
     Relation    relation;
  
     RelationIdCacheLookup(rid, relation);
  
     if (!PointerIsValid(relation))
         return;                 /* not in cache, nothing to do */
  
     if (!RelationHasReferenceCountZero(relation))
         elog(ERROR, "relation %u is still open", rid);
  
     Assert(relation->rd_droppedSubid == InvalidSubTransactionId);
     if (relation->rd_createSubid != InvalidSubTransactionId ||
         relation->rd_firstRelfilenodeSubid != InvalidSubTransactionId)
     {
         /*
          * In the event of subtransaction rollback, we must not forget
          * rd_*Subid.  Mark the entry "dropped" so RelationClearRelation()
          * invalidates it in lieu of destroying it.  (If we're in a top
          * transaction, we could opt to destroy the entry.)
          */
         relation->rd_droppedSubid = GetCurrentSubTransactionId();
     }
  
     RelationClearRelation(relation, false);
 }

References Assert(), elog, ERROR, GetCurrentSubTransactionId(), InvalidSubTransactionId, PointerIsValid, RelationData::rd_createSubid, RelationData::rd_droppedSubid, RelationData::rd_firstRelfilenodeSubid, RelationClearRelation(), RelationHasReferenceCountZero, and RelationIdCacheLookup.

Referenced by heap_drop_with_catalog(), and index_drop().

◆ RelationGetDummyIndexExpressions()

List* RelationGetDummyIndexExpressions ( Relation relation )

Definition at line 4968 of file relcache.c.

 {
     List       *result;
     Datum       exprsDatum;
     bool        isnull;
     char       *exprsString;
     List       *rawExprs;
     ListCell   *lc;
  
     /* Quick exit if there is nothing to do. */
     if (relation->rd_indextuple == NULL ||
         heap_attisnull(relation->rd_indextuple, Anum_pg_index_indexprs, NULL))
         return NIL;
  
     /* Extract raw node tree(s) from index tuple. */
     exprsDatum = heap_getattr(relation->rd_indextuple,
                               Anum_pg_index_indexprs,
                               GetPgIndexDescriptor(),
                               &isnull);
     Assert(!isnull);
     exprsString = TextDatumGetCString(exprsDatum);
     rawExprs = (List *) stringToNode(exprsString);
     pfree(exprsString);
  
     /* Construct null Consts; the typlen and typbyval are arbitrary. */
     result = NIL;
     foreach(lc, rawExprs)
     {
         Node       *rawExpr = (Node *) lfirst(lc);
  
         result = lappend(result,
                          makeConst(exprType(rawExpr),
                                    exprTypmod(rawExpr),
                                    exprCollation(rawExpr),
                                    1,
                                    (Datum) 0,
                                    true,
                                    true));
     }
  
     return result;
 }

References Assert(), exprCollation(), exprType(), exprTypmod(), GetPgIndexDescriptor(), heap_attisnull(), heap_getattr(), lappend(), lfirst, makeConst(), NIL, pfree(), RelationData::rd_indextuple, stringToNode(), and TextDatumGetCString.

Referenced by BuildDummyIndexInfo().

◆ RelationGetExclusionInfo()

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

Definition at line 5429 of file relcache.c.

 {
     int         indnkeyatts;
     Oid        *ops;
     Oid        *funcs;
     uint16     *strats;
     Relation    conrel;
     SysScanDesc conscan;
     ScanKeyData skey[1];
     HeapTuple   htup;
     bool        found;
     MemoryContext oldcxt;
     int         i;
  
     indnkeyatts = IndexRelationGetNumberOfKeyAttributes(indexRelation);
  
     /* Allocate result space in caller context */
     *operators = ops = (Oid *) palloc(sizeof(Oid) * indnkeyatts);
     *procs = funcs = (Oid *) palloc(sizeof(Oid) * indnkeyatts);
     *strategies = strats = (uint16 *) palloc(sizeof(uint16) * indnkeyatts);
  
     /* Quick exit if we have the data cached already */
     if (indexRelation->rd_exclstrats != NULL)
     {
         memcpy(ops, indexRelation->rd_exclops, sizeof(Oid) * indnkeyatts);
         memcpy(funcs, indexRelation->rd_exclprocs, sizeof(Oid) * indnkeyatts);
         memcpy(strats, indexRelation->rd_exclstrats, sizeof(uint16) * indnkeyatts);
         return;
     }
  
     /*
      * Search pg_constraint for the constraint associated with the index. To
      * make this not too painfully slow, we use the index on conrelid; that
      * will hold the parent relation's OID not the index's own OID.
      *
      * Note: if we wanted to rely on the constraint name matching the index's
      * name, we could just do a direct lookup using pg_constraint's unique
      * index.  For the moment it doesn't seem worth requiring that.
      */
     ScanKeyInit(&skey[0],
                 Anum_pg_constraint_conrelid,
                 BTEqualStrategyNumber, F_OIDEQ,
                 ObjectIdGetDatum(indexRelation->rd_index->indrelid));
  
     conrel = table_open(ConstraintRelationId, AccessShareLock);
     conscan = systable_beginscan(conrel, ConstraintRelidTypidNameIndexId, true,
                                  NULL, 1, skey);
     found = false;
  
     while (HeapTupleIsValid(htup = systable_getnext(conscan)))
     {
         Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(htup);
         Datum       val;
         bool        isnull;
         ArrayType  *arr;
         int         nelem;
  
         /* We want the exclusion constraint owning the index */
         if (conform->contype != CONSTRAINT_EXCLUSION ||
             conform->conindid != RelationGetRelid(indexRelation))
             continue;
  
         /* There should be only one */
         if (found)
             elog(ERROR, "unexpected exclusion constraint record found for rel %s",
                  RelationGetRelationName(indexRelation));
         found = true;
  
         /* Extract the operator OIDS from conexclop */
         val = fastgetattr(htup,
                           Anum_pg_constraint_conexclop,
                           conrel->rd_att, &isnull);
         if (isnull)
             elog(ERROR, "null conexclop for rel %s",
                  RelationGetRelationName(indexRelation));
  
         arr = DatumGetArrayTypeP(val);  /* ensure not toasted */
         nelem = ARR_DIMS(arr)[0];
         if (ARR_NDIM(arr) != 1 ||
             nelem != indnkeyatts ||
             ARR_HASNULL(arr) ||
             ARR_ELEMTYPE(arr) != OIDOID)
             elog(ERROR, "conexclop is not a 1-D Oid array");
  
         memcpy(ops, ARR_DATA_PTR(arr), sizeof(Oid) * indnkeyatts);
     }
  
     systable_endscan(conscan);
     table_close(conrel, AccessShareLock);
  
     if (!found)
         elog(ERROR, "exclusion constraint record missing for rel %s",
              RelationGetRelationName(indexRelation));
  
     /* We need the func OIDs and strategy numbers too */
     for (i = 0; i < indnkeyatts; i++)
     {
         funcs[i] = get_opcode(ops[i]);
         strats[i] = get_op_opfamily_strategy(ops[i],
                                              indexRelation->rd_opfamily[i]);
         /* shouldn't fail, since it was checked at index creation */
         if (strats[i] == InvalidStrategy)
             elog(ERROR, "could not find strategy for operator %u in family %u",
                  ops[i], indexRelation->rd_opfamily[i]);
     }
  
     /* Save a copy of the results in the relcache entry. */
     oldcxt = MemoryContextSwitchTo(indexRelation->rd_indexcxt);
     indexRelation->rd_exclops = (Oid *) palloc(sizeof(Oid) * indnkeyatts);
     indexRelation->rd_exclprocs = (Oid *) palloc(sizeof(Oid) * indnkeyatts);
     indexRelation->rd_exclstrats = (uint16 *) palloc(sizeof(uint16) * indnkeyatts);
     memcpy(indexRelation->rd_exclops, ops, sizeof(Oid) * indnkeyatts);
     memcpy(indexRelation->rd_exclprocs, funcs, sizeof(Oid) * indnkeyatts);
     memcpy(indexRelation->rd_exclstrats, strats, sizeof(uint16) * indnkeyatts);
     MemoryContextSwitchTo(oldcxt);
 }

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

◆ InProgressEnt

◆ OpClassCacheEnt

◆ RelIdCacheEnt

Function Documentation

◆ AllocateRelationDesc()

◆ AtEOSubXact_cleanup()

◆ AtEOSubXact_RelationCache()

◆ AtEOXact_cleanup()

◆ AtEOXact_RelationCache()

◆ AttrDefaultCmp()

◆ AttrDefaultFetch()

◆ BuildHardcodedDescriptor()

◆ CheckConstraintCmp()

◆ CheckConstraintFetch()

◆ CopyIndexAttOptions()

◆ equalPolicy()

◆ equalRSDesc()

◆ equalRuleLocks()

◆ errtable()

◆ errtablecol()

◆ errtablecolname()

◆ errtableconstraint()

◆ formrdesc()

◆ GetPgClassDescriptor()

◆ GetPgIndexDescriptor()

◆ IndexSupportInitialize()

◆ InitIndexAmRoutine()

◆ InitTableAmRoutine()

◆ load_critical_index()

◆ load_relcache_init_file()

◆ LookupOpclassInfo()

◆ RelationAssumeNewRelfilenode()

◆ RelationBuildDesc()

◆ RelationBuildLocalRelation()

◆ RelationBuildPublicationDesc()

◆ RelationBuildRuleLock()

◆ RelationBuildTupleDesc()

◆ RelationCacheInitFilePostInvalidate()

◆ RelationCacheInitFilePreInvalidate()

◆ RelationCacheInitFileRemove()

◆ RelationCacheInitFileRemoveInDir()

◆ RelationCacheInitialize()

◆ RelationCacheInitializePhase2()

◆ RelationCacheInitializePhase3()

◆ RelationCacheInvalidate()

◆ RelationCacheInvalidateEntry()

◆ RelationClearRelation()

◆ RelationClose()

◆ RelationCloseSmgrByOid()

◆ RelationDecrementReferenceCount()

◆ RelationDestroyRelation()

◆ RelationFlushRelation()

◆ RelationForgetRelation()

◆ RelationGetDummyIndexExpressions()

◆ RelationGetExclusionInfo()