#include "postgres.h"
#include <sys/file.h>
#include <fcntl.h>
#include <unistd.h>
#include "access/htup_details.h"
#include "access/multixact.h"
#include "access/nbtree.h"
#include "access/reloptions.h"
#include "access/sysattr.h"
#include "access/xact.h"
#include "access/xlog.h"
#include "catalog/catalog.h"
#include "catalog/index.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_authid.h"
#include "catalog/pg_auth_members.h"
#include "catalog/pg_constraint.h"
#include "catalog/pg_database.h"
#include "catalog/pg_namespace.h"
#include "catalog/pg_opclass.h"
#include "catalog/pg_partitioned_table.h"
#include "catalog/pg_proc.h"
#include "catalog/pg_publication.h"
#include "catalog/pg_rewrite.h"
#include "catalog/pg_shseclabel.h"
#include "catalog/pg_statistic_ext.h"
#include "catalog/pg_subscription.h"
#include "catalog/pg_tablespace.h"
#include "catalog/pg_trigger.h"
#include "catalog/pg_type.h"
#include "catalog/schemapg.h"
#include "catalog/storage.h"
#include "commands/policy.h"
#include "commands/trigger.h"
#include "miscadmin.h"
#include "nodes/nodeFuncs.h"
#include "optimizer/clauses.h"
#include "optimizer/prep.h"
#include "optimizer/var.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/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 "utils/tqual.h"

Include dependency graph for relcache.c:

Data Structures
struct	relidcacheent

struct	opclasscacheent

Macros
#define	RELCACHE_INIT_FILENAME "pg_internal.init"

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

#define	MAX_EOXACT_LIST 32

#define	EOXactListAdd(rel)

#define	RelationCacheInsert(RELATION, replace_allowed)

#define	RelationIdCacheLookup(ID, RELATION)

#define	RelationCacheDelete(RELATION)

#define	SWAPFIELD(fldtype, fldname)

#define	INITRELCACHESIZE 400

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

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

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

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

Typedefs
typedef struct relidcacheent	RelIdCacheEnt

typedef struct opclasscacheent	OpClassCacheEnt

Functions
static void	RelationDestroyRelation (Relation relation, bool remember_tupdesc)

static void	RelationClearRelation (Relation relation, bool rebuild)

static void	RelationReloadIndexInfo (Relation relation)

static void	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, bool hasoids, 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 void	RelationBuildPartitionKey (Relation relation)

static PartitionKey	copy_partition_key (PartitionKey fromkey)

static Relation	RelationBuildDesc (Oid targetRelId, bool insertIt)

static void	RelationInitPhysicalAddr (Relation relation)

static void	load_critical_index (Oid indexoid, Oid heapoid)

static TupleDesc	GetPgClassDescriptor (void)

static TupleDesc	GetPgIndexDescriptor (void)

static void	AttrDefaultFetch (Relation relation)

static void	CheckConstraintFetch (Relation relation)

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

static List *	insert_ordered_oid (List *list, Oid datum)

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)

static bool	equalPartitionDescs (PartitionKey key, PartitionDesc partdesc1, PartitionDesc partdesc2)

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)

Relation	RelationIdGetRelation (Oid relationId)

void	RelationIncrementReferenceCount (Relation rel)

void	RelationDecrementReferenceCount (Relation rel)

void	RelationClose (Relation relation)

void	RelationForgetRelation (Oid rid)

void	RelationCacheInvalidateEntry (Oid relationId)

void	RelationCacheInvalidate (void)

void	RelationCloseSmgrByOid (Oid relationId)

void	AtEOXact_RelationCache (bool isCommit)

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

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

void	RelationSetNewRelfilenode (Relation relation, char persistence, TransactionId freezeXid, MultiXactId minmulti)

void	RelationCacheInitialize (void)

void	RelationCacheInitializePhase2 (void)

void	RelationCacheInitializePhase3 (void)

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

List *	RelationGetFKeyList (Relation relation)

List *	RelationGetIndexList (Relation relation)

List *	RelationGetStatExtList (Relation relation)

void	RelationSetIndexList (Relation relation, List *indexIds, Oid oidIndex)

Oid	RelationGetOidIndex (Relation relation)

Oid	RelationGetPrimaryKeyIndex (Relation relation)

Oid	RelationGetReplicaIndex (Relation relation)

List *	RelationGetIndexExpressions (Relation relation)

List *	RelationGetIndexPredicate (Relation relation)

Bitmapset *	RelationGetIndexAttrBitmap (Relation relation, IndexAttrBitmapKind attrKind)

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

struct PublicationActions *	GetRelationPublicationActions (Relation relation)

int	errtable (Relation rel)

int	errtablecol (Relation rel, int attnum)

int	errtablecolname (Relation rel, const char *colname)

int	errtableconstraint (Relation rel, const char *conname)

bool	RelationIdIsInInitFile (Oid relationId)

bool	RelationHasUnloggedIndex (Relation rel)

void	RelationCacheInitFilePreInvalidate (void)

void	RelationCacheInitFilePostInvalidate (void)

void	RelationCacheInitFileRemove (void)

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

static const FormData_pg_attribute	Desc_pg_attribute [Natts_pg_attribute] = {Schema_pg_attribute}

static const FormData_pg_attribute	Desc_pg_proc [Natts_pg_proc] = {Schema_pg_proc}

static const FormData_pg_attribute	Desc_pg_type [Natts_pg_type] = {Schema_pg_type}

static const FormData_pg_attribute	Desc_pg_database [Natts_pg_database] = {Schema_pg_database}

static const FormData_pg_attribute	Desc_pg_authid [Natts_pg_authid] = {Schema_pg_authid}

static const FormData_pg_attribute	Desc_pg_auth_members [Natts_pg_auth_members] = {Schema_pg_auth_members}

static const FormData_pg_attribute	Desc_pg_index [Natts_pg_index] = {Schema_pg_index}

static const FormData_pg_attribute	Desc_pg_shseclabel [Natts_pg_shseclabel] = {Schema_pg_shseclabel}

static const FormData_pg_attribute	Desc_pg_subscription [Natts_pg_subscription] = {Schema_pg_subscription}

static HTAB *	RelationIdCache

bool	criticalRelcachesBuilt = false

bool	criticalSharedRelcachesBuilt = false

static long	relcacheInvalsReceived = 0L

static Oid	eoxact_list [MAX_EOXACT_LIST]

static int	eoxact_list_len = 0

static bool	eoxact_list_overflowed = false

static TupleDesc *	EOXactTupleDescArray

static int	NextEOXactTupleDescNum = 0

static int	EOXactTupleDescArrayLen = 0

static HTAB *	OpClassCache = NULL

Macro Definition Documentation

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

Referenced by RelationBuildLocalRelation(), RelationSetIndexList(), and RelationSetNewRelfilenode().

#define INITRELCACHESIZE 400

Definition at line 3525 of file relcache.c.

Referenced by RelationCacheInitialize().

#define MAX_EOXACT_LIST 32

Definition at line 155 of file relcache.c.

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

Referenced by load_relcache_init_file().

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

Referenced by load_relcache_init_file().

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

Referenced by load_relcache_init_file().

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

Referenced by load_relcache_init_file().

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

Referenced by RelationClearRelation().

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

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

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

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

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

Definition at line 95 of file relcache.c.

Referenced by load_relcache_init_file(), and write_relcache_init_file().

#define RELCACHE_INIT_FILENAME "pg_internal.init"

Definition at line 93 of file relcache.c.

Referenced by load_relcache_init_file(), RelationCacheInitFilePreInvalidate(), RelationCacheInitFileRemove(), RelationCacheInitFileRemoveInDir(), and write_relcache_init_file().

#define SWAPFIELD	(	fldtype,
		fldname
	)

Value:

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

Referenced by RelationClearRelation().

Typedef Documentation

typedef struct opclasscacheent OpClassCacheEnt

typedef struct relidcacheent RelIdCacheEnt

Function Documentation

static Relation AllocateRelationDesc ( Form_pg_class relp )

static

Definition at line 379 of file relcache.c.

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

Referenced by RelationBuildDesc().

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

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

static

Definition at line 3114 of file relcache.c.

References elog, InvalidOid, InvalidSubTransactionId, list_free(), NIL, RelationData::rd_createSubid, RelationData::rd_indexlist, RelationData::rd_indexvalid, RelationData::rd_newRelfilenodeSubid, RelationData::rd_oidindex, RelationData::rd_pkindex, RelationData::rd_replidindex, RelationClearRelation(), RelationGetRelationName, RelationHasReferenceCountZero, and WARNING.

Referenced by AtEOSubXact_RelationCache().

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

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

Definition at line 3067 of file relcache.c.

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

Referenced by AbortSubTransaction(), and CommitSubTransaction().

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

static void AtEOXact_cleanup	(	Relation	relation,
		bool	isCommit
	)

static

Definition at line 2979 of file relcache.c.

References Assert, elog, InvalidOid, InvalidSubTransactionId, IsBootstrapProcessingMode, list_free(), NIL, RelationData::rd_createSubid, RelationData::rd_indexlist, RelationData::rd_indexvalid, RelationData::rd_isnailed, RelationData::rd_newRelfilenodeSubid, RelationData::rd_oidindex, RelationData::rd_pkindex, RelationData::rd_refcnt, RelationData::rd_replidindex, RelationClearRelation(), RelationGetRelationName, RelationHasReferenceCountZero, and WARNING.

Referenced by AtEOXact_RelationCache().

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

void AtEOXact_RelationCache ( bool isCommit )

Definition at line 2916 of file relcache.c.

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

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

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

static void AttrDefaultFetch ( Relation relation )

static

Definition at line 4015 of file relcache.c.

References AccessShareLock, attrDefault::adbin, attrDefault::adnum, Anum_pg_attrdef_adbin, Anum_pg_attrdef_adrelid, AttrDefaultIndexId, AttrDefaultRelationId, tupleDesc::attrs, BTEqualStrategyNumber, CacheMemoryContext, tupleDesc::constr, tupleConstr::defval, elog, fastgetattr, GETSTRUCT, heap_close, heap_open(), HeapTupleIsValid, i, MemoryContextStrdup(), NameStr, NULL, tupleConstr::num_defval, ObjectIdGetDatum, pfree(), RelationData::rd_att, RelationGetRelationName, RelationGetRelid, ScanKeyInit(), systable_beginscan(), systable_endscan(), systable_getnext(), TextDatumGetCString, val, and WARNING.

Referenced by RelationBuildTupleDesc().

 {
     AttrDefault *attrdef = relation->rd_att->constr->defval;
     int         ndef = relation->rd_att->constr->num_defval;
     Relation    adrel;
     SysScanDesc adscan;
     ScanKeyData skey;
     HeapTuple   htup;
     Datum       val;
     bool        isnull;
     int         found;
     int         i;
 
     ScanKeyInit(&skey,
                 Anum_pg_attrdef_adrelid,
                 BTEqualStrategyNumber, F_OIDEQ,
                 ObjectIdGetDatum(RelationGetRelid(relation)));
 
     adrel = heap_open(AttrDefaultRelationId, AccessShareLock);
     adscan = systable_beginscan(adrel, AttrDefaultIndexId, true,
                                 NULL, 1, &skey);
     found = 0;
 
     while (HeapTupleIsValid(htup = systable_getnext(adscan)))
     {
         Form_pg_attrdef adform = (Form_pg_attrdef) GETSTRUCT(htup);
 
         for (i = 0; i < ndef; i++)
         {
             if (adform->adnum != attrdef[i].adnum)
                 continue;
             if (attrdef[i].adbin != NULL)
                 elog(WARNING, "multiple attrdef records found for attr %s of rel %s",
                      NameStr(relation->rd_att->attrs[adform->adnum - 1]->attname),
                      RelationGetRelationName(relation));
             else
                 found++;
 
             val = fastgetattr(htup,
                               Anum_pg_attrdef_adbin,
                               adrel->rd_att, &isnull);
             if (isnull)
                 elog(WARNING, "null adbin for attr %s of rel %s",
                      NameStr(relation->rd_att->attrs[adform->adnum - 1]->attname),
                      RelationGetRelationName(relation));
             else
             {
                 /* detoast and convert to cstring in caller's context */
                 char       *s = TextDatumGetCString(val);
 
                 attrdef[i].adbin = MemoryContextStrdup(CacheMemoryContext, s);
                 pfree(s);
             }
             break;
         }
 
         if (i >= ndef)
             elog(WARNING, "unexpected attrdef record found for attr %d of rel %s",
                  adform->adnum, RelationGetRelationName(relation));
     }
 
     systable_endscan(adscan);
     heap_close(adrel, AccessShareLock);
 
     if (found != ndef)
         elog(WARNING, "%d attrdef record(s) missing for rel %s",
              ndef - found, RelationGetRelationName(relation));
 }

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

static

Definition at line 3953 of file relcache.c.

References ATTRIBUTE_FIXED_PART_SIZE, tupleDesc::attrs, CacheMemoryContext, CreateTemplateTupleDesc(), i, MemoryContextSwitchTo(), RECORDOID, result, tupleDesc::tdtypeid, and tupleDesc::tdtypmod.

Referenced by GetPgClassDescriptor(), and GetPgIndexDescriptor().

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

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

static

Definition at line 4159 of file relcache.c.

References constrCheck::ccname.

Referenced by CheckConstraintFetch().

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

static void CheckConstraintFetch ( Relation relation )

static

Definition at line 4088 of file relcache.c.

References AccessShareLock, Anum_pg_constraint_conbin, Anum_pg_constraint_conrelid, BTEqualStrategyNumber, CacheMemoryContext, constrCheck::ccbin, constrCheck::ccname, constrCheck::ccnoinherit, constrCheck::ccvalid, tupleConstr::check, CheckConstraintCmp(), tupleDesc::constr, CONSTRAINT_CHECK, ConstraintRelationId, ConstraintRelidIndexId, elog, ERROR, fastgetattr, GETSTRUCT, heap_close, heap_open(), HeapTupleIsValid, MemoryContextStrdup(), NameStr, NULL, tupleConstr::num_check, ObjectIdGetDatum, pfree(), qsort, RelationData::rd_att, RelationGetRelationName, RelationGetRelid, ScanKeyInit(), systable_beginscan(), systable_endscan(), systable_getnext(), TextDatumGetCString, and val.

Referenced by RelationBuildTupleDesc().

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

static PartitionKey copy_partition_key ( PartitionKey fromkey )

static

Definition at line 993 of file relcache.c.

References copyObject, palloc(), PartitionKeyData::partattrs, PartitionKeyData::partcollation, PartitionKeyData::partexprs, PartitionKeyData::partnatts, PartitionKeyData::partopcintype, PartitionKeyData::partopfamily, PartitionKeyData::partsupfunc, PartitionKeyData::parttypalign, PartitionKeyData::parttypbyval, PartitionKeyData::parttypcoll, PartitionKeyData::parttypid, PartitionKeyData::parttyplen, PartitionKeyData::parttypmod, and PartitionKeyData::strategy.

Referenced by RelationBuildPartitionKey().

 {
     PartitionKey newkey;
     int         n;
 
     newkey = (PartitionKey) palloc(sizeof(PartitionKeyData));
 
     newkey->strategy = fromkey->strategy;
     newkey->partnatts = n = fromkey->partnatts;
 
     newkey->partattrs = (AttrNumber *) palloc(n * sizeof(AttrNumber));
     memcpy(newkey->partattrs, fromkey->partattrs, n * sizeof(AttrNumber));
 
     newkey->partexprs = copyObject(fromkey->partexprs);
 
     newkey->partopfamily = (Oid *) palloc(n * sizeof(Oid));
     memcpy(newkey->partopfamily, fromkey->partopfamily, n * sizeof(Oid));
 
     newkey->partopcintype = (Oid *) palloc(n * sizeof(Oid));
     memcpy(newkey->partopcintype, fromkey->partopcintype, n * sizeof(Oid));
 
     newkey->partsupfunc = (FmgrInfo *) palloc(n * sizeof(FmgrInfo));
     memcpy(newkey->partsupfunc, fromkey->partsupfunc, n * sizeof(FmgrInfo));
 
     newkey->partcollation = (Oid *) palloc(n * sizeof(Oid));
     memcpy(newkey->partcollation, fromkey->partcollation, n * sizeof(Oid));
 
     newkey->parttypid = (Oid *) palloc(n * sizeof(Oid));
     memcpy(newkey->parttypid, fromkey->parttypid, n * sizeof(Oid));
 
     newkey->parttypmod = (int32 *) palloc(n * sizeof(int32));
     memcpy(newkey->parttypmod, fromkey->parttypmod, n * sizeof(int32));
 
     newkey->parttyplen = (int16 *) palloc(n * sizeof(int16));
     memcpy(newkey->parttyplen, fromkey->parttyplen, n * sizeof(int16));
 
     newkey->parttypbyval = (bool *) palloc(n * sizeof(bool));
     memcpy(newkey->parttypbyval, fromkey->parttypbyval, n * sizeof(bool));
 
     newkey->parttypalign = (char *) palloc(n * sizeof(bool));
     memcpy(newkey->parttypalign, fromkey->parttypalign, n * sizeof(char));
 
     newkey->parttypcoll = (Oid *) palloc(n * sizeof(Oid));
     memcpy(newkey->parttypcoll, fromkey->parttypcoll, n * sizeof(Oid));
 
     return newkey;
 }

static bool equalPartitionDescs	(	PartitionKey	key,
		PartitionDesc	partdesc1,
		PartitionDesc	partdesc2
	)

static

Definition at line 1173 of file relcache.c.

References Assert, PartitionDescData::boundinfo, i, PartitionDescData::nparts, NULL, PartitionDescData::oids, and partition_bounds_equal().

Referenced by RelationClearRelation().

 {
     int         i;
 
     if (partdesc1 != NULL)
     {
         if (partdesc2 == NULL)
             return false;
         if (partdesc1->nparts != partdesc2->nparts)
             return false;
 
         Assert(key != NULL || partdesc1->nparts == 0);
 
         /*
          * Same oids? If the partitioning structure did not change, that is,
          * no partitions were added or removed to the relation, the oids array
          * should still match element-by-element.
          */
         for (i = 0; i < partdesc1->nparts; i++)
         {
             if (partdesc1->oids[i] != partdesc2->oids[i])
                 return false;
         }
 
         /*
          * Now compare partition bound collections.  The logic to iterate over
          * the collections is private to partition.c.
          */
         if (partdesc1->boundinfo != NULL)
         {
             if (partdesc2->boundinfo == NULL)
                 return false;
 
             if (!partition_bounds_equal(key, partdesc1->boundinfo,
                                         partdesc2->boundinfo))
                 return false;
         }
         else if (partdesc2->boundinfo != NULL)
             return false;
     }
     else if (partdesc2 != NULL)
         return false;
 
     return true;
 }

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

static

Definition at line 1094 of file relcache.c.

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

Referenced by equalRSDesc().

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

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

static

Definition at line 1140 of file relcache.c.

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

Referenced by RelationClearRelation().

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

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

static

Definition at line 1049 of file relcache.c.

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

Referenced by RelationClearRelation().

 {
     int         i;
 
     /*
      * As of 7.3 we assume the rule ordering is repeatable, because
      * RelationBuildRuleLock should read 'em in a consistent order.  So just
      * compare corresponding slots.
      */
     if (rlock1 != NULL)
     {
         if (rlock2 == NULL)
             return false;
         if (rlock1->numLocks != rlock2->numLocks)
             return false;
         for (i = 0; i < rlock1->numLocks; i++)
         {
             RewriteRule *rule1 = rlock1->rules[i];
             RewriteRule *rule2 = rlock2->rules[i];
 
             if (rule1->ruleId != rule2->ruleId)
                 return false;
             if (rule1->event != rule2->event)
                 return false;
             if (rule1->enabled != rule2->enabled)
                 return false;
             if (rule1->isInstead != rule2->isInstead)
                 return false;
             if (!equal(rule1->qual, rule2->qual))
                 return false;
             if (!equal(rule1->actions, rule2->actions))
                 return false;
         }
     }
     else if (rlock2 != NULL)
         return false;
     return true;
 }

int errtable ( Relation rel )

Definition at line 5243 of file relcache.c.

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

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

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

int errtablecol	(	Relation	rel,
		int	attnum
	)

Definition at line 5260 of file relcache.c.

References tupleDesc::attrs, errtablecolname(), get_relid_attribute_name(), NameStr, RelationGetDescr, and RelationGetRelid.

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

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

int errtablecolname	(	Relation	rel,
		const char *	colname
	)

Definition at line 5284 of file relcache.c.

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

Referenced by errtablecol().

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

int errtableconstraint	(	Relation	rel,
		const char *	conname
	)

Definition at line 5297 of file relcache.c.

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

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

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

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

static

Definition at line 1887 of file relcache.c.

References ATTRIBUTE_FIXED_PART_SIZE, tupleDesc::attrs, CLASS_TUPLE_SIZE, tupleDesc::constr, CreateTemplateTupleDesc(), GLOBALTABLESPACE_OID, tupleConstr::has_not_null, i, InvalidBackendId, InvalidOid, InvalidSubTransactionId, IsBootstrapProcessingMode, namestrcpy(), NULL, palloc0(), PG_CATALOG_NAMESPACE, RelationData::rd_att, RelationData::rd_backend, RelationData::rd_createSubid, RelationData::rd_islocaltemp, RelationData::rd_isnailed, RelationData::rd_isvalid, RelationData::rd_newRelfilenodeSubid, RelationData::rd_refcnt, RelationData::rd_rel, RelationData::rd_smgr, RelationCacheInsert, RelationGetRelid, RelationInitLockInfo(), RelationInitPhysicalAddr(), RelationMapUpdateMap(), RELKIND_RELATION, RELPERSISTENCE_PERMANENT, REPLICA_IDENTITY_NOTHING, tupleDesc::tdrefcount, tupleDesc::tdtypeid, and tupleDesc::tdtypmod.

Referenced by RelationCacheInitializePhase2(), and RelationCacheInitializePhase3().

 {
     Relation    relation;
     int         i;
     bool        has_not_null;
 
     /*
      * allocate new relation desc, clear all fields of reldesc
      */
     relation = (Relation) palloc0(sizeof(RelationData));
 
     /* make sure relation is marked as having no open file yet */
     relation->rd_smgr = NULL;
 
     /*
      * initialize reference count: 1 because it is nailed in cache
      */
     relation->rd_refcnt = 1;
 
     /*
      * all entries built with this routine are nailed-in-cache; none are for
      * new or temp relations.
      */
     relation->rd_isnailed = true;
     relation->rd_createSubid = InvalidSubTransactionId;
     relation->rd_newRelfilenodeSubid = InvalidSubTransactionId;
     relation->rd_backend = InvalidBackendId;
     relation->rd_islocaltemp = false;
 
     /*
      * initialize relation tuple form
      *
      * The data we insert here is pretty incomplete/bogus, but it'll serve to
      * get us launched.  RelationCacheInitializePhase3() will read the real
      * data from pg_class and replace what we've done here.  Note in
      * particular that relowner is left as zero; this cues
      * RelationCacheInitializePhase3 that the real data isn't there yet.
      */
     relation->rd_rel = (Form_pg_class) palloc0(CLASS_TUPLE_SIZE);
 
     namestrcpy(&relation->rd_rel->relname, relationName);
     relation->rd_rel->relnamespace = PG_CATALOG_NAMESPACE;
     relation->rd_rel->reltype = relationReltype;
 
     /*
      * It's important to distinguish between shared and non-shared relations,
      * even at bootstrap time, to make sure we know where they are stored.
      */
     relation->rd_rel->relisshared = isshared;
     if (isshared)
         relation->rd_rel->reltablespace = GLOBALTABLESPACE_OID;
 
     /* formrdesc is used only for permanent relations */
     relation->rd_rel->relpersistence = RELPERSISTENCE_PERMANENT;
 
     /* ... and they're always populated, too */
     relation->rd_rel->relispopulated = true;
 
     relation->rd_rel->relreplident = REPLICA_IDENTITY_NOTHING;
     relation->rd_rel->relpages = 0;
     relation->rd_rel->reltuples = 0;
     relation->rd_rel->relallvisible = 0;
     relation->rd_rel->relkind = RELKIND_RELATION;
     relation->rd_rel->relhasoids = hasoids;
     relation->rd_rel->relnatts = (int16) natts;
 
     /*
      * initialize attribute tuple form
      *
      * Unlike the case with the relation tuple, this data had better be right
      * because it will never be replaced.  The data comes from
      * src/include/catalog/ headers via genbki.pl.
      */
     relation->rd_att = CreateTemplateTupleDesc(natts, hasoids);
     relation->rd_att->tdrefcount = 1;   /* mark as refcounted */
 
     relation->rd_att->tdtypeid = relationReltype;
     relation->rd_att->tdtypmod = -1;    /* unnecessary, but... */
 
     /*
      * initialize tuple desc info
      */
     has_not_null = false;
     for (i = 0; i < natts; i++)
     {
         memcpy(relation->rd_att->attrs[i],
                &attrs[i],
                ATTRIBUTE_FIXED_PART_SIZE);
         has_not_null |= attrs[i].attnotnull;
         /* make sure attcacheoff is valid */
         relation->rd_att->attrs[i]->attcacheoff = -1;
     }
 
     /* initialize first attribute's attcacheoff, cf RelationBuildTupleDesc */
     relation->rd_att->attrs[0]->attcacheoff = 0;
 
     /* 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) = relation->rd_att->attrs[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 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;
 }

static TupleDesc GetPgClassDescriptor ( void )

static

Definition at line 3984 of file relcache.c.

References BuildHardcodedDescriptor(), Desc_pg_class, Natts_pg_class, and NULL.

Referenced by RelationParseRelOptions().

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

static TupleDesc GetPgIndexDescriptor ( void )

static

Definition at line 3998 of file relcache.c.

References BuildHardcodedDescriptor(), Desc_pg_index, Natts_pg_index, and NULL.

Referenced by RelationGetIndexExpressions(), RelationGetIndexList(), RelationGetIndexPredicate(), and RelationInitIndexAccessInfo().

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

struct PublicationActions* GetRelationPublicationActions ( Relation relation )

Definition at line 5172 of file relcache.c.

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

Referenced by CheckCmdReplicaIdentity().

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

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

static

Definition at line 1668 of file relcache.c.

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

Referenced by RelationInitIndexAccessInfo().

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

static void InitIndexAmRoutine ( Relation relation )

static

Definition at line 1481 of file relcache.c.

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

Referenced by load_relcache_init_file(), and RelationInitIndexAccessInfo().

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

static List * insert_ordered_oid	(	List *	list,
		Oid	datum
	)

static

Definition at line 4551 of file relcache.c.

References lappend_cell_oid(), lcons_oid(), lfirst_oid, linitial_oid, sort-test::list, list_head(), lnext, NIL, and NULL.

Referenced by RelationGetIndexList(), and RelationGetStatExtList().

 {
     ListCell   *prev;
 
     /* Does the datum belong at the front? */
     if (list == NIL || datum < linitial_oid(list))
         return lcons_oid(datum, list);
     /* No, so find the entry it belongs after */
     prev = list_head(list);
     for (;;)
     {
         ListCell   *curr = lnext(prev);
 
         if (curr == NULL || datum < lfirst_oid(curr))
             break;              /* it belongs after 'prev', before 'curr' */
 
         prev = curr;
     }
     /* Insert datum into list after 'prev' */
     lappend_cell_oid(list, prev, datum);
     return list;
 }

static void load_critical_index	(	Oid	indexoid,
		Oid	heapoid
	)

static

Definition at line 3919 of file relcache.c.

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

Referenced by RelationCacheInitializePhase3().

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

static bool load_relcache_init_file ( bool shared )

static

Definition at line 5361 of file relcache.c.

Referenced by RelationCacheInitializePhase2(), and RelationCacheInitializePhase3().

 {
     FILE       *fp;
     char        initfilename[MAXPGPATH];
     Relation   *rels;
     int         relno,
                 num_rels,
                 max_rels,
                 nailed_rels,
                 nailed_indexes,
                 magic;
     int         i;
 
     if (shared)
         snprintf(initfilename, sizeof(initfilename), "global/%s",
                  RELCACHE_INIT_FILENAME);
     else
         snprintf(initfilename, sizeof(initfilename), "%s/%s",
                  DatabasePath, RELCACHE_INIT_FILENAME);
 
     fp = AllocateFile(initfilename, PG_BINARY_R);
     if (fp == NULL)
         return false;
 
     /*
      * Read the index relcache entries from the file.  Note we will not enter
      * any of them into the cache if the read fails partway through; this
      * helps to guard against broken init files.
      */
     max_rels = 100;
     rels = (Relation *) palloc(max_rels * sizeof(Relation));
     num_rels = 0;
     nailed_rels = nailed_indexes = 0;
 
     /* check for correct magic number (compatible version) */
     if (fread(&magic, 1, sizeof(magic), fp) != sizeof(magic))
         goto read_failed;
     if (magic != RELCACHE_INIT_FILEMAGIC)
         goto read_failed;
 
     for (relno = 0;; relno++)
     {
         Size        len;
         size_t      nread;
         Relation    rel;
         Form_pg_class relform;
         bool        has_not_null;
 
         /* first read the relation descriptor length */
         nread = fread(&len, 1, sizeof(len), fp);
         if (nread != sizeof(len))
         {
             if (nread == 0)
                 break;          /* end of file */
             goto read_failed;
         }
 
         /* safety check for incompatible relcache layout */
         if (len != sizeof(RelationData))
             goto read_failed;
 
         /* allocate another relcache header */
         if (num_rels >= max_rels)
         {
             max_rels *= 2;
             rels = (Relation *) repalloc(rels, max_rels * sizeof(Relation));
         }
 
         rel = rels[num_rels++] = (Relation) palloc(len);
 
         /* then, read the Relation structure */
         if (fread(rel, 1, len, fp) != len)
             goto read_failed;
 
         /* next read the relation tuple form */
         if (fread(&len, 1, sizeof(len), fp) != sizeof(len))
             goto read_failed;
 
         relform = (Form_pg_class) palloc(len);
         if (fread(relform, 1, len, fp) != len)
             goto read_failed;
 
         rel->rd_rel = relform;
 
         /* initialize attribute tuple forms */
         rel->rd_att = CreateTemplateTupleDesc(relform->relnatts,
                                               relform->relhasoids);
         rel->rd_att->tdrefcount = 1;    /* mark as refcounted */
 
         rel->rd_att->tdtypeid = relform->reltype;
         rel->rd_att->tdtypmod = -1; /* unnecessary, but... */
 
         /* next read all the attribute tuple form data entries */
         has_not_null = false;
         for (i = 0; i < relform->relnatts; i++)
         {
             if (fread(&len, 1, sizeof(len), fp) != sizeof(len))
                 goto read_failed;
             if (len != ATTRIBUTE_FIXED_PART_SIZE)
                 goto read_failed;
             if (fread(rel->rd_att->attrs[i], 1, len, fp) != len)
                 goto read_failed;
 
             has_not_null |= rel->rd_att->attrs[i]->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 */
         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,
                                              RelationGetRelationName(rel),
                                              ALLOCSET_SMALL_SIZES);
             rel->rd_indexcxt = indexcxt;
 
             /*
              * Now we can fetch the index AM's API struct.  (We can't store
              * that in the init file, since it contains function pointers that
              * might vary across server executions.  Fortunately, it should be
              * safe to call the amhandler even while bootstrapping indexes.)
              */
             InitIndexAmRoutine(rel);
 
             /* next, read the vector of opfamily OIDs */
             if (fread(&len, 1, sizeof(len), fp) != sizeof(len))
                 goto read_failed;
 
             opfamily = (Oid *) MemoryContextAlloc(indexcxt, len);
             if (fread(opfamily, 1, len, fp) != len)
                 goto read_failed;
 
             rel->rd_opfamily = opfamily;
 
             /* next, read the vector of opcintype OIDs */
             if (fread(&len, 1, sizeof(len), fp) != sizeof(len))
                 goto read_failed;
 
             opcintype = (Oid *) MemoryContextAlloc(indexcxt, len);
             if (fread(opcintype, 1, len, fp) != len)
                 goto read_failed;
 
             rel->rd_opcintype = opcintype;
 
             /* next, read the vector of support procedure OIDs */
             if (fread(&len, 1, sizeof(len), fp) != sizeof(len))
                 goto read_failed;
             support = (RegProcedure *) MemoryContextAlloc(indexcxt, len);
             if (fread(support, 1, len, fp) != len)
                 goto read_failed;
 
             rel->rd_support = support;
 
             /* next, read the vector of collation OIDs */
             if (fread(&len, 1, sizeof(len), fp) != sizeof(len))
                 goto read_failed;
 
             indcollation = (Oid *) MemoryContextAlloc(indexcxt, len);
             if (fread(indcollation, 1, len, fp) != len)
                 goto read_failed;
 
             rel->rd_indcollation = indcollation;
 
             /* finally, read the vector of indoption values */
             if (fread(&len, 1, sizeof(len), fp) != sizeof(len))
                 goto read_failed;
 
             indoption = (int16 *) MemoryContextAlloc(indexcxt, len);
             if (fread(indoption, 1, len, fp) != len)
                 goto read_failed;
 
             rel->rd_indoption = indoption;
 
             /* set up zeroed fmgr-info vector */
             nsupport = relform->relnatts * rel->rd_amroutine->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++;
 
             Assert(rel->rd_index == NULL);
             Assert(rel->rd_indextuple == NULL);
             Assert(rel->rd_indexcxt == NULL);
             Assert(rel->rd_amroutine == NULL);
             Assert(rel->rd_opfamily == NULL);
             Assert(rel->rd_opcintype == NULL);
             Assert(rel->rd_support == NULL);
             Assert(rel->rd_supportinfo == NULL);
             Assert(rel->rd_indoption == NULL);
             Assert(rel->rd_indcollation == NULL);
         }
 
         /*
          * Rules and triggers are not saved (mainly because the internal
          * format is complex and subject to change).  They must be rebuilt if
          * needed by RelationCacheInitializePhase3.  This is not expected to
          * be a big performance hit since few system catalogs have such. Ditto
          * for RLS policy data, 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_partkeycxt = NULL;
         rel->rd_partkey = NULL;
         rel->rd_pdcxt = NULL;
         rel->rd_partdesc = NULL;
         rel->rd_partcheck = NIL;
         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 = 0;
         rel->rd_fkeylist = NIL;
         rel->rd_fkeyvalid = false;
         rel->rd_indexlist = NIL;
         rel->rd_oidindex = InvalidOid;
         rel->rd_pkindex = InvalidOid;
         rel->rd_replidindex = InvalidOid;
         rel->rd_indexattr = NULL;
         rel->rd_keyattr = NULL;
         rel->rd_pkattr = NULL;
         rel->rd_idattr = NULL;
         rel->rd_pubactions = NULL;
         rel->rd_statvalid = false;
         rel->rd_statlist = NIL;
         rel->rd_createSubid = InvalidSubTransactionId;
         rel->rd_newRelfilenodeSubid = InvalidSubTransactionId;
         rel->rd_amcache = NULL;
         MemSet(&rel->pgstat_info, 0, sizeof(rel->pgstat_info));
 
         /*
          * Recompute lock and physical addressing info.  This is needed in
          * case the pg_internal.init file was copied from some other database
          * by CREATE DATABASE.
          */
         RelationInitLockInfo(rel);
         RelationInitPhysicalAddr(rel);
     }
 
     /*
      * We reached the end of the init file without apparent problem.  Did we
      * get the right number of nailed items?  This is a useful crosscheck in
      * case the set of critical rels or indexes changes.  However, that should
      * not happen in a normally-running system, so let's bleat if it does.
      *
      * For the shared init file, we're called before client authentication is
      * done, which means that elog(WARNING) will go only to the postmaster
      * log, where it's easily missed.  To ensure that developers notice bad
      * values of NUM_CRITICAL_SHARED_RELS/NUM_CRITICAL_SHARED_INDEXES, we put
      * an Assert(false) there.
      */
     if (shared)
     {
         if (nailed_rels != NUM_CRITICAL_SHARED_RELS ||
             nailed_indexes != NUM_CRITICAL_SHARED_INDEXES)
         {
             elog(WARNING, "found %d nailed shared rels and %d nailed shared indexes in init file, but expected %d and %d respectively",
                  nailed_rels, nailed_indexes,
                  NUM_CRITICAL_SHARED_RELS, NUM_CRITICAL_SHARED_INDEXES);
             /* Make sure we get developers' attention about this */
             Assert(false);
             /* In production builds, recover by bootstrapping the relcache */
             goto read_failed;
         }
     }
     else
     {
         if (nailed_rels != NUM_CRITICAL_LOCAL_RELS ||
             nailed_indexes != NUM_CRITICAL_LOCAL_INDEXES)
         {
             elog(WARNING, "found %d nailed rels and %d nailed indexes in init file, but expected %d and %d respectively",
                  nailed_rels, nailed_indexes,
                  NUM_CRITICAL_LOCAL_RELS, NUM_CRITICAL_LOCAL_INDEXES);
             /* We don't need an Assert() in this case */
             goto read_failed;
         }
     }
 
     /*
      * OK, all appears well.
      *
      * Now insert all the new relcache entries into the cache.
      */
     for (relno = 0; relno < num_rels; relno++)
     {
         RelationCacheInsert(rels[relno], false);
     }
 
     pfree(rels);
     FreeFile(fp);
 
     if (shared)
         criticalSharedRelcachesBuilt = true;
     else
         criticalRelcachesBuilt = true;
     return true;
 
     /*
      * init file is broken, so do it the hard way.  We don't bother trying to
      * free the clutter we just allocated; it's not in the relcache so it
      * won't hurt.
      */
 read_failed:
     pfree(rels);
     FreeFile(fp);
 
     return false;
 }

static OpClassCacheEnt * LookupOpclassInfo	(	Oid	operatorClassOid,
		StrategyNumber	numSupport
	)

static

Definition at line 1719 of file relcache.c.

References AccessMethodProcedureIndexId, AccessMethodProcedureRelationId, AccessShareLock, Anum_pg_amproc_amprocfamily, Anum_pg_amproc_amproclefttype, Anum_pg_amproc_amprocrighttype, Assert, BTEqualStrategyNumber, CacheMemoryContext, CreateCacheMemoryContext(), criticalRelcachesBuilt, elog, HASHCTL::entrysize, ERROR, GETSTRUCT, HASH_BLOBS, hash_create(), HASH_ELEM, HASH_ENTER, hash_search(), heap_close, heap_open(), HeapTupleIsValid, INT2_BTREE_OPS_OID, HASHCTL::keysize, MemoryContextAllocZero(), MemSet, NULL, opclasscacheent::numSupport, ObjectIdAttributeNumber, ObjectIdGetDatum, OID_BTREE_OPS_OID, opclasscacheent::opcfamily, opclasscacheent::opcintype, OpclassOidIndexId, OperatorClassRelationId, ScanKeyInit(), opclasscacheent::supportProcs, systable_beginscan(), systable_endscan(), systable_getnext(), and opclasscacheent::valid.

Referenced by IndexSupportInitialize().

 {
     OpClassCacheEnt *opcentry;
     bool        found;
     Relation    rel;
     SysScanDesc scan;
     ScanKeyData skey[3];
     HeapTuple   htup;
     bool        indexOK;
 
     if (OpClassCache == NULL)
     {
         /* First time through: initialize the opclass cache */
         HASHCTL     ctl;
 
         MemSet(&ctl, 0, sizeof(ctl));
         ctl.keysize = sizeof(Oid);
         ctl.entrysize = sizeof(OpClassCacheEnt);
         OpClassCache = hash_create("Operator class cache", 64,
                                    &ctl, HASH_ELEM | HASH_BLOBS);
 
         /* Also make sure CacheMemoryContext exists */
         if (!CacheMemoryContext)
             CreateCacheMemoryContext();
     }
 
     opcentry = (OpClassCacheEnt *) hash_search(OpClassCache,
                                                (void *) &operatorClassOid,
                                                HASH_ENTER, &found);
 
     if (!found)
     {
         /* Need to allocate memory for new entry */
         opcentry->valid = false;    /* until known OK */
         opcentry->numSupport = numSupport;
 
         if (numSupport > 0)
             opcentry->supportProcs = (RegProcedure *)
                 MemoryContextAllocZero(CacheMemoryContext,
                                        numSupport * sizeof(RegProcedure));
         else
             opcentry->supportProcs = NULL;
     }
     else
     {
         Assert(numSupport == opcentry->numSupport);
     }
 
     /*
      * When testing for cache-flush hazards, we intentionally disable the
      * operator class cache and force reloading of the info on each call. This
      * is helpful because we want to test the case where a cache flush occurs
      * while we are loading the info, and it's very hard to provoke that if
      * this happens only once per opclass per backend.
      */
 #if defined(CLOBBER_CACHE_ALWAYS)
     opcentry->valid = false;
 #endif
 
     if (opcentry->valid)
         return opcentry;
 
     /*
      * Need to fill in new entry.
      *
      * To avoid infinite recursion during startup, force heap scans if we're
      * looking up info for the opclasses used by the indexes we would like to
      * reference here.
      */
     indexOK = criticalRelcachesBuilt ||
         (operatorClassOid != OID_BTREE_OPS_OID &&
          operatorClassOid != INT2_BTREE_OPS_OID);
 
     /*
      * We have to fetch the pg_opclass row to determine its opfamily and
      * opcintype, which are needed to look up related operators and functions.
      * It'd be convenient to use the syscache here, but that probably doesn't
      * work while bootstrapping.
      */
     ScanKeyInit(&skey[0],
                 ObjectIdAttributeNumber,
                 BTEqualStrategyNumber, F_OIDEQ,
                 ObjectIdGetDatum(operatorClassOid));
     rel = heap_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);
     heap_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 = heap_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);
         heap_close(rel, AccessShareLock);
     }
 
     opcentry->valid = true;
     return opcentry;
 }

static Relation RelationBuildDesc	(	Oid	targetRelId,
		bool	insertIt
	)

static

Definition at line 1233 of file relcache.c.

References AllocateRelationDesc(), Assert, BackendIdForTempRelations, elog, ERROR, GETSTRUCT, GetTempNamespaceBackendId(), heap_freetuple(), HeapTupleGetOid, HeapTupleIsValid, InvalidBackendId, InvalidSubTransactionId, isTempOrTempToastNamespace(), NIL, NULL, OidIsValid, RelationData::rd_backend, RelationData::rd_createSubid, RelationData::rd_fkeylist, RelationData::rd_fkeyvalid, RelationData::rd_islocaltemp, RelationData::rd_isnailed, RelationData::rd_isvalid, RelationData::rd_newRelfilenodeSubid, RelationData::rd_partdesc, RelationData::rd_partkey, RelationData::rd_partkeycxt, RelationData::rd_pdcxt, RelationData::rd_refcnt, RelationData::rd_rel, RelationData::rd_rsdesc, RelationData::rd_rules, RelationData::rd_rulescxt, RelationData::rd_smgr, RelationBuildPartitionDesc(), RelationBuildPartitionKey(), RelationBuildRowSecurity(), RelationBuildRuleLock(), RelationBuildTriggers(), RelationBuildTupleDesc(), RelationCacheInsert, RelationGetRelid, RelationInitIndexAccessInfo(), RelationInitLockInfo(), RelationInitPhysicalAddr(), RelationParseRelOptions(), RELKIND_PARTITIONED_TABLE, RELPERSISTENCE_PERMANENT, RELPERSISTENCE_TEMP, RELPERSISTENCE_UNLOGGED, ScanPgRelation(), and RelationData::trigdesc.

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

 {
     Relation    relation;
     Oid         relid;
     HeapTuple   pg_class_tuple;
     Form_pg_class relp;
 
     /*
      * 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))
         return NULL;
 
     /*
      * get information from the pg_class_tuple
      */
     relid = HeapTupleGetOid(pg_class_tuple);
     relp = (Form_pg_class) GETSTRUCT(pg_class_tuple);
     Assert(relid == targetRelId);
 
     /*
      * allocate storage for the relation descriptor, and copy pg_class_tuple
      * to relation->rd_rel.
      */
     relation = AllocateRelationDesc(relp);
 
     /*
      * initialize the relation's relation id (relation->rd_id)
      */
     RelationGetRelid(relation) = relid;
 
     /*
      * normal relations are not nailed into the cache; nor can a pre-existing
      * relation be new.  It could be temp though.  (Actually, it could be new
      * too, but it's okay to forget that fact if forced to flush the entry.)
      */
     relation->rd_refcnt = 0;
     relation->rd_isnailed = false;
     relation->rd_createSubid = InvalidSubTransactionId;
     relation->rd_newRelfilenodeSubid = InvalidSubTransactionId;
     switch (relation->rd_rel->relpersistence)
     {
         case RELPERSISTENCE_UNLOGGED:
         case RELPERSISTENCE_PERMANENT:
             relation->rd_backend = InvalidBackendId;
             relation->rd_islocaltemp = false;
             break;
         case RELPERSISTENCE_TEMP:
             if (isTempOrTempToastNamespace(relation->rd_rel->relnamespace))
             {
                 relation->rd_backend = BackendIdForTempRelations();
                 relation->rd_islocaltemp = true;
             }
             else
             {
                 /*
                  * If it's a temp table, but not one of ours, we have to use
                  * the slow, grotty method to figure out the owning backend.
                  *
                  * Note: it's possible that rd_backend gets set to MyBackendId
                  * here, in case we are looking at a pg_class entry left over
                  * from a crashed backend that coincidentally had the same
                  * BackendId we're using.  We should *not* consider such a
                  * table to be "ours"; this is why we need the separate
                  * rd_islocaltemp flag.  The pg_class entry will get flushed
                  * if/when we clean out the corresponding temp table namespace
                  * in preparation for using it.
                  */
                 relation->rd_backend =
                     GetTempNamespaceBackendId(relation->rd_rel->relnamespace);
                 Assert(relation->rd_backend != InvalidBackendId);
                 relation->rd_islocaltemp = false;
             }
             break;
         default:
             elog(ERROR, "invalid relpersistence: %c",
                  relation->rd_rel->relpersistence);
             break;
     }
 
     /*
      * initialize the tuple descriptor (relation->rd_att).
      */
     RelationBuildTupleDesc(relation);
 
     /*
      * Fetch rules and triggers that affect this relation
      */
     if (relation->rd_rel->relhasrules)
         RelationBuildRuleLock(relation);
     else
     {
         relation->rd_rules = NULL;
         relation->rd_rulescxt = NULL;
     }
 
     if (relation->rd_rel->relhastriggers)
         RelationBuildTriggers(relation);
     else
         relation->trigdesc = NULL;
 
     if (relation->rd_rel->relrowsecurity)
         RelationBuildRowSecurity(relation);
     else
         relation->rd_rsdesc = NULL;
 
     /* foreign key data is not loaded till asked for */
     relation->rd_fkeylist = NIL;
     relation->rd_fkeyvalid = false;
 
     /* if a partitioned table, initialize key and partition descriptor info */
     if (relation->rd_rel->relkind == RELKIND_PARTITIONED_TABLE)
     {
         RelationBuildPartitionKey(relation);
         RelationBuildPartitionDesc(relation);
     }
     else
     {
         relation->rd_partkeycxt = NULL;
         relation->rd_partkey = NULL;
         relation->rd_partdesc = NULL;
         relation->rd_pdcxt = NULL;
     }
 
     /*
      * if it's an index, initialize index-related information
      */
     if (OidIsValid(relation->rd_rel->relam))
         RelationInitIndexAccessInfo(relation);
 
     /* extract reloptions if any */
     RelationParseRelOptions(relation, pg_class_tuple);
 
     /*
      * initialize the relation lock manager information
      */
     RelationInitLockInfo(relation); /* see lmgr.c */
 
     /*
      * initialize physical addressing information for the relation
      */
     RelationInitPhysicalAddr(relation);
 
     /* make sure relation is marked as having no open file yet */
     relation->rd_smgr = NULL;
 
     /*
      * now we can free the memory allocated for pg_class_tuple
      */
     heap_freetuple(pg_class_tuple);
 
     /*
      * Insert newly created relation into relcache hash table, if requested.
      *
      * There is one scenario in which we might find a hashtable entry already
      * present, even though our caller failed to find it: if the relation is a
      * system catalog or index that's used during relcache load, we might have
      * recursively created the same relcache entry during the preceding steps.
      * So allow RelationCacheInsert to delete any already-present relcache
      * entry for the same OID.  The already-present entry should have refcount
      * zero (else somebody forgot to close it); in the event that it doesn't,
      * we'll elog a WARNING and leak the already-present entry.
      */
     if (insertIt)
         RelationCacheInsert(relation, true);
 
     /* It's fully valid */
     relation->rd_isvalid = true;
 
     return relation;
 }

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

Definition at line 3179 of file relcache.c.

References Assert, AssertArg, AttributeRelationId, tupleDesc::attrs, AuthIdRelationId, AuthMemRelationId, BackendIdForTempRelations, BOOTSTRAP_SUPERUSERID, CacheMemoryContext, CLASS_TUPLE_SIZE, tupleDesc::constr, CreateCacheMemoryContext(), CreateTupleDescCopy(), DatabaseRelationId, elog, EOXactListAdd, ERROR, GetCurrentSubTransactionId(), tupleConstr::has_not_null, i, InvalidBackendId, InvalidOid, InvalidSubTransactionId, IsSharedRelation(), IsSystemNamespace(), isTempOrTempToastNamespace(), MemoryContextSwitchTo(), namestrcpy(), tupleDesc::natts, NULL, palloc0(), ProcedureRelationId, RelationData::rd_att, RelationData::rd_backend, RelationData::rd_createSubid, RelationData::rd_islocaltemp, RelationData::rd_isnailed, RelationData::rd_isvalid, RelationData::rd_newRelfilenodeSubid, RelationData::rd_refcnt, RelationData::rd_rel, RelationData::rd_smgr, RelationCacheInsert, RelationGetRelid, RelationIncrementReferenceCount(), RelationInitLockInfo(), RelationInitPhysicalAddr(), RelationMapUpdateMap(), RelationRelationId, RELKIND_MATVIEW, RELKIND_PARTITIONED_TABLE, RELKIND_RELATION, RELPERSISTENCE_PERMANENT, RELPERSISTENCE_TEMP, RELPERSISTENCE_UNLOGGED, REPLICA_IDENTITY_DEFAULT, REPLICA_IDENTITY_NOTHING, tupleDesc::tdhasoid, tupleDesc::tdrefcount, and TypeRelationId.

Referenced by heap_create().

 {
     Relation    rel;
     MemoryContext oldcxt;
     int         natts = tupDesc->natts;
     int         i;
     bool        has_not_null;
     bool        nailit;
 
     AssertArg(natts >= 0);
 
     /*
      * check for creation of a rel that must be nailed in cache.
      *
      * XXX this list had better match the relations specially handled in
      * RelationCacheInitializePhase2/3.
      */
     switch (relid)
     {
         case DatabaseRelationId:
         case AuthIdRelationId:
         case AuthMemRelationId:
         case RelationRelationId:
         case AttributeRelationId:
         case ProcedureRelationId:
         case TypeRelationId:
             nailit = true;
             break;
         default:
             nailit = false;
             break;
     }
 
     /*
      * check that hardwired list of shared rels matches what's in the
      * bootstrap .bki file.  If you get a failure here during initdb, you
      * probably need to fix IsSharedRelation() to match whatever you've done
      * to the set of shared relations.
      */
     if (shared_relation != IsSharedRelation(relid))
         elog(ERROR, "shared_relation flag for \"%s\" does not match IsSharedRelation(%u)",
              relname, relid);
 
     /* Shared relations had better be mapped, too */
     Assert(mapped_relation || !shared_relation);
 
     /*
      * switch to the cache context to create the relcache entry.
      */
     if (!CacheMemoryContext)
         CreateCacheMemoryContext();
 
     oldcxt = MemoryContextSwitchTo(CacheMemoryContext);
 
     /*
      * allocate a new relation descriptor and fill in basic state fields.
      */
     rel = (Relation) palloc0(sizeof(RelationData));
 
     /* make sure relation is marked as having no open file yet */
     rel->rd_smgr = NULL;
 
     /* mark it nailed if appropriate */
     rel->rd_isnailed = nailit;
 
     rel->rd_refcnt = nailit ? 1 : 0;
 
     /* it's being created in this transaction */
     rel->rd_createSubid = GetCurrentSubTransactionId();
     rel->rd_newRelfilenodeSubid = InvalidSubTransactionId;
 
     /*
      * create a new tuple descriptor from the one passed in.  We do this
      * partly to copy it into the cache context, and partly because the new
      * relation can't have any defaults or constraints yet; they have to be
      * added in later steps, because they require additions to multiple system
      * catalogs.  We can copy attnotnull constraints here, however.
      */
     rel->rd_att = CreateTupleDescCopy(tupDesc);
     rel->rd_att->tdrefcount = 1;    /* mark as refcounted */
     has_not_null = false;
     for (i = 0; i < natts; i++)
     {
         rel->rd_att->attrs[i]->attidentity = tupDesc->attrs[i]->attidentity;
         rel->rd_att->attrs[i]->attnotnull = tupDesc->attrs[i]->attnotnull;
         has_not_null |= tupDesc->attrs[i]->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->relhasoids = rel->rd_att->tdhasoid;
     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;
 
     /* system relations and non-table objects don't have one */
     if (!IsSystemNamespace(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++)
         rel->rd_att->attrs[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);
 
     /*
      * Okay to insert into the relcache hash table.
      *
      * Ordinarily, there should certainly not be an existing hash entry for
      * the same OID; but during bootstrap, when we create a "real" relcache
      * entry for one of the bootstrap relations, we'll be overwriting the
      * phony one created with formrdesc.  So allow that to happen for nailed
      * rels.
      */
     RelationCacheInsert(rel, nailit);
 
     /*
      * Flag relation as needing eoxact cleanup (to clear rd_createSubid). We
      * can't do this before storing relid in it.
      */
     EOXactListAdd(rel);
 
     /*
      * done building relcache entry.
      */
     MemoryContextSwitchTo(oldcxt);
 
     /* It's fully valid */
     rel->rd_isvalid = true;
 
     /*
      * Caller expects us to pin the returned entry.
      */
     RelationIncrementReferenceCount(rel);
 
     return rel;
 }

static void RelationBuildPartitionKey ( Relation relation )

static

Definition at line 827 of file relcache.c.

Referenced by RelationBuildDesc(), and RelationCacheInitializePhase3().

 {
     Form_pg_partitioned_table form;
     HeapTuple   tuple;
     bool        isnull;
     int         i;
     PartitionKey key;
     AttrNumber *attrs;
     oidvector  *opclass;
     oidvector  *collation;
     ListCell   *partexprs_item;
     Datum       datum;
     MemoryContext partkeycxt,
                 oldcxt;
 
     tuple = SearchSysCache1(PARTRELID,
                             ObjectIdGetDatum(RelationGetRelid(relation)));
 
     /*
      * The following happens when we have created our pg_class entry but not
      * the pg_partitioned_table entry yet.
      */
     if (!HeapTupleIsValid(tuple))
         return;
 
     key = (PartitionKey) palloc0(sizeof(PartitionKeyData));
 
     /* Fixed-length attributes */
     form = (Form_pg_partitioned_table) GETSTRUCT(tuple);
     key->strategy = form->partstrat;
     key->partnatts = form->partnatts;
 
     /*
      * We can rely on the first variable-length attribute being mapped to the
      * relevant field of the catalog's C struct, because all previous
      * attributes are non-nullable and fixed-length.
      */
     attrs = form->partattrs.values;
 
     /* But use the hard way to retrieve further variable-length attributes */
     /* Operator class */
     datum = SysCacheGetAttr(PARTRELID, tuple,
                             Anum_pg_partitioned_table_partclass, &isnull);
     Assert(!isnull);
     opclass = (oidvector *) DatumGetPointer(datum);
 
     /* Collation */
     datum = SysCacheGetAttr(PARTRELID, tuple,
                             Anum_pg_partitioned_table_partcollation, &isnull);
     Assert(!isnull);
     collation = (oidvector *) DatumGetPointer(datum);
 
     /* Expressions */
     datum = SysCacheGetAttr(PARTRELID, tuple,
                             Anum_pg_partitioned_table_partexprs, &isnull);
     if (!isnull)
     {
         char       *exprString;
         Node       *expr;
 
         exprString = TextDatumGetCString(datum);
         expr = stringToNode(exprString);
         pfree(exprString);
 
         /*
          * Run the expressions through const-simplification since the planner
          * will be comparing them to similarly-processed qual clause operands,
          * and may fail to detect valid matches without this step.  We don't
          * need to bother with canonicalize_qual() though, because partition
          * expressions are not full-fledged qualification clauses.
          */
         expr = eval_const_expressions(NULL, (Node *) expr);
 
         /* May as well fix opfuncids too */
         fix_opfuncids((Node *) expr);
         key->partexprs = (List *) expr;
     }
 
     key->partattrs = (AttrNumber *) palloc0(key->partnatts * sizeof(AttrNumber));
     key->partopfamily = (Oid *) palloc0(key->partnatts * sizeof(Oid));
     key->partopcintype = (Oid *) palloc0(key->partnatts * sizeof(Oid));
     key->partsupfunc = (FmgrInfo *) palloc0(key->partnatts * sizeof(FmgrInfo));
 
     key->partcollation = (Oid *) palloc0(key->partnatts * sizeof(Oid));
 
     /* Gather type and collation info as well */
     key->parttypid = (Oid *) palloc0(key->partnatts * sizeof(Oid));
     key->parttypmod = (int32 *) palloc0(key->partnatts * sizeof(int32));
     key->parttyplen = (int16 *) palloc0(key->partnatts * sizeof(int16));
     key->parttypbyval = (bool *) palloc0(key->partnatts * sizeof(bool));
     key->parttypalign = (char *) palloc0(key->partnatts * sizeof(char));
     key->parttypcoll = (Oid *) palloc0(key->partnatts * sizeof(Oid));
 
     /* Copy partattrs and fill other per-attribute info */
     memcpy(key->partattrs, attrs, key->partnatts * sizeof(int16));
     partexprs_item = list_head(key->partexprs);
     for (i = 0; i < key->partnatts; i++)
     {
         AttrNumber  attno = key->partattrs[i];
         HeapTuple   opclasstup;
         Form_pg_opclass opclassform;
         Oid         funcid;
 
         /* Collect opfamily information */
         opclasstup = SearchSysCache1(CLAOID,
                                      ObjectIdGetDatum(opclass->values[i]));
         if (!HeapTupleIsValid(opclasstup))
             elog(ERROR, "cache lookup failed for opclass %u", opclass->values[i]);
 
         opclassform = (Form_pg_opclass) GETSTRUCT(opclasstup);
         key->partopfamily[i] = opclassform->opcfamily;
         key->partopcintype[i] = opclassform->opcintype;
 
         /*
          * A btree support function covers the cases of list and range methods
          * currently supported.
          */
         funcid = get_opfamily_proc(opclassform->opcfamily,
                                    opclassform->opcintype,
                                    opclassform->opcintype,
                                    BTORDER_PROC);
 
         fmgr_info(funcid, &key->partsupfunc[i]);
 
         /* Collation */
         key->partcollation[i] = collation->values[i];
 
         /* Collect type information */
         if (attno != 0)
         {
             key->parttypid[i] = relation->rd_att->attrs[attno - 1]->atttypid;
             key->parttypmod[i] = relation->rd_att->attrs[attno - 1]->atttypmod;
             key->parttypcoll[i] = relation->rd_att->attrs[attno - 1]->attcollation;
         }
         else
         {
             key->parttypid[i] = exprType(lfirst(partexprs_item));
             key->parttypmod[i] = exprTypmod(lfirst(partexprs_item));
             key->parttypcoll[i] = exprCollation(lfirst(partexprs_item));
         }
         get_typlenbyvalalign(key->parttypid[i],
                              &key->parttyplen[i],
                              &key->parttypbyval[i],
                              &key->parttypalign[i]);
 
         ReleaseSysCache(opclasstup);
     }
 
     ReleaseSysCache(tuple);
 
     /* Success --- now copy to the cache memory */
     partkeycxt = AllocSetContextCreate(CacheMemoryContext,
                                        RelationGetRelationName(relation),
                                        ALLOCSET_SMALL_SIZES);
     relation->rd_partkeycxt = partkeycxt;
     oldcxt = MemoryContextSwitchTo(relation->rd_partkeycxt);
     relation->rd_partkey = copy_partition_key(key);
     MemoryContextSwitchTo(oldcxt);
 }

static void RelationBuildRuleLock ( Relation relation )

static

Definition at line 659 of file relcache.c.

References AccessShareLock, RewriteRule::actions, ALLOCSET_SMALL_SIZES, AllocSetContextCreate(), Anum_pg_rewrite_ev_action, Anum_pg_rewrite_ev_class, Anum_pg_rewrite_ev_qual, Assert, BTEqualStrategyNumber, CacheMemoryContext, RewriteRule::enabled, RewriteRule::event, GETSTRUCT, heap_close, heap_getattr, heap_open(), HeapTupleGetOid, HeapTupleIsValid, RewriteRule::isInstead, MemoryContextAlloc(), MemoryContextDelete(), MemoryContextSwitchTo(), NULL, RuleLock::numLocks, ObjectIdGetDatum, pfree(), RewriteRule::qual, RelationData::rd_rel, RelationData::rd_rules, RelationData::rd_rulescxt, RelationGetDescr, RelationGetRelationName, RelationGetRelid, repalloc(), RewriteRelationId, RewriteRelRulenameIndexId, RewriteRule::ruleId, RuleLock::rules, rules, ScanKeyInit(), setRuleCheckAsUser(), stringToNode(), systable_beginscan(), systable_endscan(), systable_getnext(), and TextDatumGetCString.

Referenced by RelationBuildDesc(), and RelationCacheInitializePhase3().

 {
     MemoryContext rulescxt;
     MemoryContext oldcxt;
     HeapTuple   rewrite_tuple;
     Relation    rewrite_desc;
     TupleDesc   rewrite_tupdesc;
     SysScanDesc rewrite_scan;
     ScanKeyData key;
     RuleLock   *rulelock;
     int         numlocks;
     RewriteRule **rules;
     int         maxlocks;
 
     /*
      * Make the private context.  Assume it'll not contain much data.
      */
     rulescxt = AllocSetContextCreate(CacheMemoryContext,
                                      RelationGetRelationName(relation),
                                      ALLOCSET_SMALL_SIZES);
     relation->rd_rulescxt = rulescxt;
 
     /*
      * allocate an array to hold the rewrite rules (the array is extended if
      * necessary)
      */
     maxlocks = 4;
     rules = (RewriteRule **)
         MemoryContextAlloc(rulescxt, sizeof(RewriteRule *) * maxlocks);
     numlocks = 0;
 
     /*
      * form a scan key
      */
     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 = heap_open(RewriteRelationId, AccessShareLock);
     rewrite_tupdesc = RelationGetDescr(rewrite_desc);
     rewrite_scan = systable_beginscan(rewrite_desc,
                                       RewriteRelRulenameIndexId,
                                       true, NULL,
                                       1, &key);
 
     while (HeapTupleIsValid(rewrite_tuple = systable_getnext(rewrite_scan)))
     {
         Form_pg_rewrite rewrite_form = (Form_pg_rewrite) GETSTRUCT(rewrite_tuple);
         bool        isnull;
         Datum       rule_datum;
         char       *rule_str;
         RewriteRule *rule;
 
         rule = (RewriteRule *) MemoryContextAlloc(rulescxt,
                                                   sizeof(RewriteRule));
 
         rule->ruleId = HeapTupleGetOid(rewrite_tuple);
 
         rule->event = rewrite_form->ev_type - '0';
         rule->enabled = rewrite_form->ev_enabled;
         rule->isInstead = rewrite_form->is_instead;
 
         /*
          * Must use heap_getattr to fetch ev_action and ev_qual.  Also, the
          * rule strings are often large enough to be toasted.  To avoid
          * leaking memory in the caller's context, do the detoasting here so
          * we can free the detoasted version.
          */
         rule_datum = heap_getattr(rewrite_tuple,
                                   Anum_pg_rewrite_ev_action,
                                   rewrite_tupdesc,
                                   &isnull);
         Assert(!isnull);
         rule_str = TextDatumGetCString(rule_datum);
         oldcxt = MemoryContextSwitchTo(rulescxt);
         rule->actions = (List *) stringToNode(rule_str);
         MemoryContextSwitchTo(oldcxt);
         pfree(rule_str);
 
         rule_datum = heap_getattr(rewrite_tuple,
                                   Anum_pg_rewrite_ev_qual,
                                   rewrite_tupdesc,
                                   &isnull);
         Assert(!isnull);
         rule_str = TextDatumGetCString(rule_datum);
         oldcxt = MemoryContextSwitchTo(rulescxt);
         rule->qual = (Node *) stringToNode(rule_str);
         MemoryContextSwitchTo(oldcxt);
         pfree(rule_str);
 
         /*
          * We want the rule's table references to be checked as though by the
          * table owner, not the user referencing the rule.  Therefore, scan
          * through the rule's actions and set the checkAsUser field on all
          * rtable entries.  We have to look at the qual as well, in case it
          * contains sublinks.
          *
          * The reason for doing this when the rule is loaded, rather than when
          * it is stored, is that otherwise ALTER TABLE OWNER would have to
          * grovel through stored rules to update checkAsUser fields. Scanning
          * the rule tree during load is relatively cheap (compared to
          * constructing it in the first place), so we do it here.
          */
         setRuleCheckAsUser((Node *) rule->actions, relation->rd_rel->relowner);
         setRuleCheckAsUser(rule->qual, relation->rd_rel->relowner);
 
         if (numlocks >= maxlocks)
         {
             maxlocks *= 2;
             rules = (RewriteRule **)
                 repalloc(rules, sizeof(RewriteRule *) * maxlocks);
         }
         rules[numlocks++] = rule;
     }
 
     /*
      * end the scan and close the attribute relation
      */
     systable_endscan(rewrite_scan);
     heap_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;
 }

static void RelationBuildTupleDesc ( Relation relation )

static

Definition at line 487 of file relcache.c.

References AccessShareLock, attrDefault::adbin, attrDefault::adnum, Anum_pg_attribute_attnum, Anum_pg_attribute_attrelid, Assert, AttrDefaultFetch(), ATTRIBUTE_FIXED_PART_SIZE, AttributeRelationId, AttributeRelidNumIndexId, tupleDesc::attrs, BTEqualStrategyNumber, BTGreaterStrategyNumber, CacheMemoryContext, tupleConstr::check, CheckConstraintFetch(), tupleDesc::constr, criticalRelcachesBuilt, tupleConstr::defval, elog, ERROR, GETSTRUCT, tupleConstr::has_not_null, heap_close, heap_open(), HeapTupleIsValid, i, Int16GetDatum, MemoryContextAlloc(), MemoryContextAllocZero(), NULL, tupleConstr::num_check, tupleConstr::num_defval, ObjectIdGetDatum, pfree(), RelationData::rd_att, RelationData::rd_rel, RelationGetRelationName, RelationGetRelid, repalloc(), ScanKeyInit(), systable_beginscan(), systable_endscan(), systable_getnext(), tupleDesc::tdhasoid, tupleDesc::tdtypeid, and tupleDesc::tdtypmod.

Referenced by RelationBuildDesc().

 {
     HeapTuple   pg_attribute_tuple;
     Relation    pg_attribute_desc;
     SysScanDesc pg_attribute_scan;
     ScanKeyData skey[2];
     int         need;
     TupleConstr *constr;
     AttrDefault *attrdef = NULL;
     int         ndef = 0;
 
     /* copy some fields from pg_class row to rd_att */
     relation->rd_att->tdtypeid = relation->rd_rel->reltype;
     relation->rd_att->tdtypmod = -1;    /* unnecessary, but... */
     relation->rd_att->tdhasoid = relation->rd_rel->relhasoids;
 
     constr = (TupleConstr *) MemoryContextAlloc(CacheMemoryContext,
                                                 sizeof(TupleConstr));
     constr->has_not_null = false;
 
     /*
      * Form a scan key that selects only user attributes (attnum > 0).
      * (Eliminating system attribute rows at the index level is lots faster
      * than fetching them.)
      */
     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 = heap_open(AttributeRelationId, AccessShareLock);
     pg_attribute_scan = systable_beginscan(pg_attribute_desc,
                                            AttributeRelidNumIndexId,
                                            criticalRelcachesBuilt,
                                            NULL,
                                            2, skey);
 
     /*
      * add attribute data to relation->rd_att
      */
     need = relation->rd_rel->relnatts;
 
     while (HeapTupleIsValid(pg_attribute_tuple = systable_getnext(pg_attribute_scan)))
     {
         Form_pg_attribute attp;
 
         attp = (Form_pg_attribute) GETSTRUCT(pg_attribute_tuple);
 
         if (attp->attnum <= 0 ||
             attp->attnum > relation->rd_rel->relnatts)
             elog(ERROR, "invalid attribute number %d for %s",
                  attp->attnum, RelationGetRelationName(relation));
 
         memcpy(relation->rd_att->attrs[attp->attnum - 1],
                attp,
                ATTRIBUTE_FIXED_PART_SIZE);
 
         /* Update constraint/default info */
         if (attp->attnotnull)
             constr->has_not_null = true;
 
         if (attp->atthasdef)
         {
             if (attrdef == NULL)
                 attrdef = (AttrDefault *)
                     MemoryContextAllocZero(CacheMemoryContext,
                                            relation->rd_rel->relnatts *
                                            sizeof(AttrDefault));
             attrdef[ndef].adnum = attp->attnum;
             attrdef[ndef].adbin = NULL;
             ndef++;
         }
         need--;
         if (need == 0)
             break;
     }
 
     /*
      * end the scan and close the attribute relation
      */
     systable_endscan(pg_attribute_scan);
     heap_close(pg_attribute_desc, AccessShareLock);
 
     if (need != 0)
         elog(ERROR, "catalog is missing %d attribute(s) for relid %u",
              need, RelationGetRelid(relation));
 
     /*
      * The attcacheoff values we read from pg_attribute should all be -1
      * ("unknown").  Verify this if assert checking is on.  They will be
      * computed when and if needed during tuple access.
      */
 #ifdef USE_ASSERT_CHECKING
     {
         int         i;
 
         for (i = 0; i < relation->rd_rel->relnatts; i++)
             Assert(relation->rd_att->attrs[i]->attcacheoff == -1);
     }
 #endif
 
     /*
      * However, we can easily set the attcacheoff value for the first
      * attribute: it must be zero.  This eliminates the need for special cases
      * for attnum=1 that used to exist in fastgetattr() and index_getattr().
      */
     if (relation->rd_rel->relnatts > 0)
         relation->rd_att->attrs[0]->attcacheoff = 0;
 
     /*
      * Set up constraint/default info
      */
     if (constr->has_not_null || ndef > 0 || relation->rd_rel->relchecks)
     {
         relation->rd_att->constr = constr;
 
         if (ndef > 0)           /* DEFAULTs */
         {
             if (ndef < relation->rd_rel->relnatts)
                 constr->defval = (AttrDefault *)
                     repalloc(attrdef, ndef * sizeof(AttrDefault));
             else
                 constr->defval = attrdef;
             constr->num_defval = ndef;
             AttrDefaultFetch(relation);
         }
         else
             constr->num_defval = 0;
 
         if (relation->rd_rel->relchecks > 0)    /* CHECKs */
         {
             constr->num_check = relation->rd_rel->relchecks;
             constr->check = (ConstrCheck *)
                 MemoryContextAllocZero(CacheMemoryContext,
                                        constr->num_check * sizeof(ConstrCheck));
             CheckConstraintFetch(relation);
         }
         else
             constr->num_check = 0;
     }
     else
     {
         pfree(constr);
         relation->rd_att->constr = NULL;
     }
 }

void RelationCacheInitFilePostInvalidate ( void )

Definition at line 6069 of file relcache.c.

References LWLockRelease().

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

 {
     LWLockRelease(RelCacheInitLock);
 }

void RelationCacheInitFilePreInvalidate ( void )

Definition at line 6043 of file relcache.c.

References DatabasePath, ereport, errcode_for_file_access(), errmsg(), ERROR, LW_EXCLUSIVE, LWLockAcquire(), MAXPGPATH, RELCACHE_INIT_FILENAME, snprintf(), and unlink().

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

 {
     char        initfilename[MAXPGPATH];
 
     snprintf(initfilename, sizeof(initfilename), "%s/%s",
              DatabasePath, RELCACHE_INIT_FILENAME);
 
     LWLockAcquire(RelCacheInitLock, LW_EXCLUSIVE);
 
     if (unlink(initfilename) < 0)
     {
         /*
          * The file might not be there if no backend has been started since
          * the last removal.  But complain about failures other than ENOENT.
          * Fortunately, it's not too late to abort the transaction if we can't
          * get rid of the would-be-obsolete init file.
          */
         if (errno != ENOENT)
             ereport(ERROR,
                     (errcode_for_file_access(),
                      errmsg("could not remove cache file \"%s\": %m",
                             initfilename)));
     }
 }

void RelationCacheInitFileRemove ( void )

Definition at line 6084 of file relcache.c.

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

Referenced by StartupXLOG().

 {
     const char *tblspcdir = "pg_tblspc";
     DIR        *dir;
     struct dirent *de;
     char        path[MAXPGPATH + 10 + sizeof(TABLESPACE_VERSION_DIRECTORY)];
 
     /*
      * We zap the shared cache file too.  In theory it can't get out of sync
      * enough to be a problem, but in data-corruption cases, who knows ...
      */
     snprintf(path, sizeof(path), "global/%s",
              RELCACHE_INIT_FILENAME);
     unlink_initfile(path);
 
     /* Scan everything in the default tablespace */
     RelationCacheInitFileRemoveInDir("base");
 
     /* Scan the tablespace link directory to find non-default tablespaces */
     dir = AllocateDir(tblspcdir);
     if (dir == NULL)
     {
         elog(LOG, "could not open tablespace link directory \"%s\": %m",
              tblspcdir);
         return;
     }
 
     while ((de = ReadDir(dir, tblspcdir)) != 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);
 }

static void RelationCacheInitFileRemoveInDir ( const char * tblspcpath )

static

Definition at line 6127 of file relcache.c.

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

Referenced by RelationCacheInitFileRemove().

 {
     DIR        *dir;
     struct dirent *de;
     char        initfilename[MAXPGPATH * 2];
 
     /* Scan the tablespace directory to find per-database directories */
     dir = AllocateDir(tblspcpath);
     if (dir == NULL)
     {
         elog(LOG, "could not open tablespace directory \"%s\": %m",
              tblspcpath);
         return;
     }
 
     while ((de = ReadDir(dir, tblspcpath)) != 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);
         }
     }
 
     FreeDir(dir);
 }

void RelationCacheInitialize ( void )

Definition at line 3528 of file relcache.c.

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

Referenced by InitPostgres().

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

void RelationCacheInitializePhase2 ( void )

Definition at line 3565 of file relcache.c.

References AuthIdRelation_Rowtype_Id, AuthMemRelation_Rowtype_Id, CacheMemoryContext, DatabaseRelation_Rowtype_Id, Desc_pg_auth_members, Desc_pg_authid, Desc_pg_database, Desc_pg_shseclabel, Desc_pg_subscription, formrdesc(), IsBootstrapProcessingMode, load_relcache_init_file(), MemoryContextSwitchTo(), Natts_pg_auth_members, Natts_pg_authid, Natts_pg_database, Natts_pg_shseclabel, Natts_pg_subscription, RelationMapInitializePhase2(), SharedSecLabelRelation_Rowtype_Id, and SubscriptionRelation_Rowtype_Id.

Referenced by InitPostgres().

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

void RelationCacheInitializePhase3 ( void )

Definition at line 3624 of file relcache.c.

References AccessMethodProcedureIndexId, AccessMethodProcedureRelationId, Assert, AttributeRelation_Rowtype_Id, AttributeRelationId, AttributeRelidNumIndexId, AuthIdOidIndexId, AuthIdRelationId, AuthIdRolnameIndexId, AuthMemMemRoleIndexId, AuthMemRelationId, CacheMemoryContext, CLASS_TUPLE_SIZE, ClassOidIndexId, criticalRelcachesBuilt, criticalSharedRelcachesBuilt, DatabaseNameIndexId, DatabaseOidIndexId, DatabaseRelationId, 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, IndexRelationId, IndexRelidIndexId, InitCatalogCachePhase2(), InvalidOid, IsBootstrapProcessingMode, load_critical_index(), load_relcache_init_file(), MemoryContextSwitchTo(), Natts_pg_attribute, Natts_pg_class, Natts_pg_proc, Natts_pg_type, NULL, ObjectIdGetDatum, OpclassOidIndexId, OperatorClassRelationId, pfree(), ProcedureRelation_Rowtype_Id, RelationData::rd_att, RelationData::rd_options, RelationData::rd_partdesc, RelationData::rd_partkey, RelationData::rd_rel, RelationData::rd_rsdesc, RelationData::rd_rules, RelationBuildPartitionDesc(), RelationBuildPartitionKey(), RelationBuildRowSecurity(), RelationBuildRuleLock(), RelationBuildTriggers(), RelationDecrementReferenceCount(), RelationGetRelationName, RelationGetRelid, RelationIncrementReferenceCount(), RelationMapInitializePhase3(), RelationParseRelOptions(), RelationRelation_Rowtype_Id, RelationRelationId, relidcacheent::reldesc, ReleaseSysCache(), RELKIND_PARTITIONED_TABLE, RELOID, RewriteRelationId, RewriteRelRulenameIndexId, SearchSysCache1, SharedSecLabelObjectIndexId, SharedSecLabelRelationId, status(), tupleDesc::tdhasoid, tupleDesc::tdtypeid, tupleDesc::tdtypmod, RelationData::trigdesc, TriggerRelationId, TriggerRelidNameIndexId, TypeRelation_Rowtype_Id, and write_relcache_init_file().

Referenced by InitPostgres().

 {
     HASH_SEQ_STATUS status;
     RelIdCacheEnt *idhentry;
     MemoryContext oldcxt;
     bool        needNewCacheFile = !criticalSharedRelcachesBuilt;
 
     /*
      * relation mapper needs initialized too
      */
     RelationMapInitializePhase3();
 
     /*
      * switch to cache memory context
      */
     oldcxt = MemoryContextSwitchTo(CacheMemoryContext);
 
     /*
      * Try to load the local relcache cache file.  If unsuccessful, bootstrap
      * the cache with pre-made descriptors for the critical "nailed-in" system
      * catalogs.
      */
     if (IsBootstrapProcessingMode() ||
         !load_relcache_init_file(false))
     {
         needNewCacheFile = true;
 
         formrdesc("pg_class", RelationRelation_Rowtype_Id, false,
                   true, Natts_pg_class, Desc_pg_class);
         formrdesc("pg_attribute", AttributeRelation_Rowtype_Id, false,
                   false, Natts_pg_attribute, Desc_pg_attribute);
         formrdesc("pg_proc", ProcedureRelation_Rowtype_Id, false,
                   true, Natts_pg_proc, Desc_pg_proc);
         formrdesc("pg_type", TypeRelation_Rowtype_Id, false,
                   true, 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);
             Assert(relation->rd_att->tdhasoid == relp->relhasoids);
 
             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;
         }
 
         /*
 

Data Structures

Macros

Typedefs

Functions

Variables

Macro Definition Documentation

Typedef Documentation

Function Documentation