#include "access/tupdesc.h"
#include "nodes/bitmapset.h"

Include dependency graph for relcache.h:

This graph shows which files directly or indirectly include this file:

Typedefs
typedef struct RelationData *	Relation

typedef Relation *	RelationPtr

typedef enum IndexAttrBitmapKind	IndexAttrBitmapKind

Enumerations
enum	IndexAttrBitmapKind { INDEX_ATTR_BITMAP_ALL, INDEX_ATTR_BITMAP_KEY, INDEX_ATTR_BITMAP_PRIMARY_KEY, INDEX_ATTR_BITMAP_IDENTITY_KEY }

Functions
Relation	RelationIdGetRelation (Oid relationId)

void	RelationClose (Relation relation)

List *	RelationGetFKeyList (Relation relation)

List *	RelationGetIndexList (Relation relation)

List *	RelationGetStatExtList (Relation relation)

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 keyAttrs)

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

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

void	RelationInitIndexAccessInfo (Relation relation)

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)

void	RelationCacheInitialize (void)

void	RelationCacheInitializePhase2 (void)

void	RelationCacheInitializePhase3 (void)

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

bool	RelationIdIsInInitFile (Oid relationId)

void	RelationCacheInitFilePreInvalidate (void)

void	RelationCacheInitFilePostInvalidate (void)

void	RelationCacheInitFileRemove (void)

Variables
bool	criticalRelcachesBuilt

bool	criticalSharedRelcachesBuilt

Typedef Documentation

typedef enum IndexAttrBitmapKind IndexAttrBitmapKind

typedef struct RelationData* Relation

Definition at line 21 of file relcache.h.

typedef Relation* RelationPtr

Definition at line 29 of file relcache.h.

Enumeration Type Documentation

enum IndexAttrBitmapKind

Enumerator
INDEX_ATTR_BITMAP_ALL
INDEX_ATTR_BITMAP_KEY
INDEX_ATTR_BITMAP_PRIMARY_KEY
INDEX_ATTR_BITMAP_IDENTITY_KEY

Definition at line 49 of file relcache.h.

 {
     INDEX_ATTR_BITMAP_ALL,
     INDEX_ATTR_BITMAP_KEY,
     INDEX_ATTR_BITMAP_PRIMARY_KEY,
     INDEX_ATTR_BITMAP_IDENTITY_KEY
 } IndexAttrBitmapKind;

Function Documentation

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

Definition at line 3071 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 */
 }

void AtEOXact_RelationCache ( bool isCommit )

Definition at line 2920 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;
 }

int errtable ( Relation rel )

Definition at line 5247 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 5264 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 5288 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 5301 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 */
 }

struct PublicationActions* GetRelationPublicationActions ( Relation relation )

Definition at line 5176 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;
 }

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

void RelationCacheInitFilePostInvalidate ( void )

Definition at line 6073 of file relcache.c.

References LWLockRelease().

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

 {
     LWLockRelease(RelCacheInitLock);
 }

void RelationCacheInitFilePreInvalidate ( void )

Definition at line 6047 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 6088 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);
 }

void RelationCacheInitialize ( void )

Definition at line 3532 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 3569 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 3628 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;
         }
 
         /*
          * Fix data that isn't saved in relcache cache file.
          *
          * relhasrules or relhastriggers could possibly be wrong or out of
          * date.  If we don't actually find any rules or triggers, clear the
          * local copy of the flag so that we don't get into an infinite loop
          * here.  We don't make any attempt to fix the pg_class entry, though.
          */
         if (relation->rd_rel->relhasrules && relation->rd_rules == NULL)
         {
             RelationBuildRuleLock(relation);
             if (relation->rd_rules == NULL)
                 relation->rd_rel->relhasrules = false;
             restart = true;
         }
         if (relation->rd_rel->relhastriggers && relation->trigdesc == NULL)
         {
             RelationBuildTriggers(relation);
             if (relation->trigdesc == NULL)
                 relation->rd_rel->relhastriggers = false;
             restart = true;
         }
 
         /*
          * Re-load the row security policies if the relation has them, since
          * they are not preserved in the cache.  Note that we can never NOT
          * have a policy while relrowsecurity is true,
          * RelationBuildRowSecurity will create a single default-deny policy
          * if there is no policy defined in pg_policy.
          */
         if (relation->rd_rel->relrowsecurity && relation->rd_rsdesc == NULL)
         {
             RelationBuildRowSecurity(relation);
 
             Assert(relation->rd_rsdesc != NULL);
             restart = true;
         }
 
         /*
          * Reload the partition key and descriptor for a partitioned table.
          */
         if (relation->rd_rel->relkind == RELKIND_PARTITIONED_TABLE &&
             relation->rd_partkey == NULL)
         {
             RelationBuildPartitionKey(relation);
             Assert(relation->rd_partkey != NULL);
 
             restart = true;
         }
 
         if (relation->rd_rel->relkind == RELKIND_PARTITIONED_TABLE &&
             relation->rd_partdesc == NULL)
         {
             RelationBuildPartitionDesc(relation);
             Assert(relation->rd_partdesc != NULL);
 
             restart = true;
         }
 
         /* Release hold on the relation */
         RelationDecrementReferenceCount(relation);
 
         /* Now, restart the hashtable scan if needed */
         if (restart)
         {
             hash_seq_term(&status);
             hash_seq_init(&status, RelationIdCache);
         }
     }
 
     /*
      * Lastly, write out new relcache cache files if needed.  We don't bother
      * to distinguish cases where only one of the two needs an update.
      */
     if (needNewCacheFile)
     {
         /*
          * Force all the catcaches to finish initializing and thereby open the
          * catalogs and indexes they use.  This will preload the relcache with
          * entries for all the most important system catalogs and indexes, so
          * that the init files will be most useful for future backends.
          */
         InitCatalogCachePhase2();
 
         /* now write the files */
         write_relcache_init_file(true);
         write_relcache_init_file(false);
     }
 }

void RelationCacheInvalidate ( void )

Definition at line 2760 of file relcache.c.

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

Referenced by InvalidateSystemCaches(), and LocalExecuteInvalidationMessage().

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

void RelationCacheInvalidateEntry ( Oid relationId )

Definition at line 2716 of file relcache.c.

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

Referenced by LocalExecuteInvalidationMessage().

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

void RelationClose ( Relation relation )

Definition at line 2160 of file relcache.c.

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

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

 {
     /* Note: no locking manipulations needed */
     RelationDecrementReferenceCount(relation);
 
 #ifdef RELCACHE_FORCE_RELEASE
     if (RelationHasReferenceCountZero(relation) &&
         relation->rd_createSubid == InvalidSubTransactionId &&
         relation->rd_newRelfilenodeSubid == InvalidSubTransactionId)
         RelationClearRelation(relation, false);
 #endif
 }

void RelationCloseSmgrByOid ( Oid relationId )

Definition at line 2863 of file relcache.c.

References PointerIsValid, RelationCloseSmgr, and RelationIdCacheLookup.

Referenced by swap_relation_files().

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

void RelationForgetRelation ( Oid rid )

Definition at line 2684 of file relcache.c.

References elog, ERROR, PointerIsValid, RelationClearRelation(), RelationHasReferenceCountZero, and RelationIdCacheLookup.

Referenced by heap_drop_with_catalog(), and index_drop().

 {
     Relation    relation;
 
     RelationIdCacheLookup(rid, relation);
 
     if (!PointerIsValid(relation))
         return;                 /* not in cache, nothing to do */
 
     if (!RelationHasReferenceCountZero(relation))
         elog(ERROR, "relation %u is still open", rid);
 
     /* Unconditionally destroy the relcache entry */
     RelationClearRelation(relation, false);
 }

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

Definition at line 5058 of file relcache.c.

References AccessShareLock, Anum_pg_constraint_conexclop, Anum_pg_constraint_conrelid, ARR_DATA_PTR, ARR_DIMS, ARR_ELEMTYPE, ARR_HASNULL, ARR_NDIM, BTEqualStrategyNumber, CONSTRAINT_EXCLUSION, ConstraintRelationId, ConstraintRelidIndexId, DatumGetArrayTypeP, elog, ERROR, fastgetattr, get_op_opfamily_strategy(), get_opcode(), GETSTRUCT, heap_close, heap_open(), HeapTupleIsValid, i, InvalidStrategy, MemoryContextSwitchTo(), NULL, ObjectIdGetDatum, OIDOID, palloc(), RelationData::rd_att, RelationData::rd_exclops, RelationData::rd_exclprocs, RelationData::rd_exclstrats, RelationData::rd_index, RelationData::rd_indexcxt, RelationData::rd_opfamily, RelationData::rd_rel, RelationGetRelationName, RelationGetRelid, ScanKeyInit(), systable_beginscan(), systable_endscan(), systable_getnext(), and val.

Referenced by BuildIndexInfo(), and CheckIndexCompatible().

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

List* RelationGetFKeyList ( Relation relation )

Definition at line 4186 of file relcache.c.

References AccessShareLock, Anum_pg_constraint_confkey, Anum_pg_constraint_conkey, Anum_pg_constraint_conpfeqop, Anum_pg_constraint_conrelid, ARR_DATA_PTR, ARR_DIMS, ARR_ELEMTYPE, ARR_HASNULL, ARR_NDIM, BTEqualStrategyNumber, CacheMemoryContext, ForeignKeyCacheInfo::confkey, ForeignKeyCacheInfo::confrelid, ForeignKeyCacheInfo::conkey, ForeignKeyCacheInfo::conpfeqop, ForeignKeyCacheInfo::conrelid, CONSTRAINT_FOREIGN, ConstraintRelationId, ConstraintRelidIndexId, copyObject, DatumGetArrayTypeP, elog, ERROR, fastgetattr, GETSTRUCT, heap_close, heap_open(), HeapTupleIsValid, INDEX_MAX_KEYS, INT2OID, lappend(), list_free_deep(), makeNode, MemoryContextSwitchTo(), NIL, ForeignKeyCacheInfo::nkeys, NULL, ObjectIdGetDatum, OIDOID, RelationData::rd_att, RelationData::rd_fkeylist, RelationData::rd_fkeyvalid, RelationData::rd_rel, RelationGetRelationName, RelationGetRelid, result, ScanKeyInit(), systable_beginscan(), systable_endscan(), and systable_getnext().

Referenced by get_relation_foreign_keys().

 {
     List       *result;
     Relation    conrel;
     SysScanDesc conscan;
     ScanKeyData skey;
     HeapTuple   htup;
     List       *oldlist;
     MemoryContext oldcxt;
 
     /* Quick exit if we already computed the list. */
     if (relation->rd_fkeyvalid)
         return relation->rd_fkeylist;
 
     /* Fast path: if it doesn't have any triggers, it can't have FKs */
     if (!relation->rd_rel->relhastriggers)
         return NIL;
 
     /*
      * We build the list we intend to return (in the caller's context) while
      * doing the scan.  After successfully completing the scan, we copy that
      * list into the relcache entry.  This avoids cache-context memory leakage
      * if we get some sort of error partway through.
      */
     result = NIL;
 
     /* Prepare to scan pg_constraint for entries having conrelid = this rel. */
     ScanKeyInit(&skey,
                 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 constraint = (Form_pg_constraint) GETSTRUCT(htup);
         ForeignKeyCacheInfo *info;
         Datum       adatum;
         bool        isnull;
         ArrayType  *arr;
         int         nelem;
 
         /* consider only foreign keys */
         if (constraint->contype != CONSTRAINT_FOREIGN)
             continue;
 
         info = makeNode(ForeignKeyCacheInfo);
         info->conrelid = constraint->conrelid;
         info->confrelid = constraint->confrelid;
 
         /* Extract data from conkey field */
         adatum = fastgetattr(htup, Anum_pg_constraint_conkey,
                              conrel->rd_att, &isnull);
         if (isnull)
             elog(ERROR, "null conkey for rel %s",
                  RelationGetRelationName(relation));
 
         arr = DatumGetArrayTypeP(adatum);   /* ensure not toasted */
         nelem = ARR_DIMS(arr)[0];
         if (ARR_NDIM(arr) != 1 ||
             nelem < 1 ||
             nelem > INDEX_MAX_KEYS ||
             ARR_HASNULL(arr) ||
             ARR_ELEMTYPE(arr) != INT2OID)
             elog(ERROR, "conkey is not a 1-D smallint array");
 
         info->nkeys = nelem;
         memcpy(info->conkey, ARR_DATA_PTR(arr), nelem * sizeof(AttrNumber));
 
         /* Likewise for confkey */
         adatum = fastgetattr(htup, Anum_pg_constraint_confkey,
                              conrel->rd_att, &isnull);
         if (isnull)
             elog(ERROR, "null confkey for rel %s",
                  RelationGetRelationName(relation));
 
         arr = DatumGetArrayTypeP(adatum);   /* ensure not toasted */
         nelem = ARR_DIMS(arr)[0];
         if (ARR_NDIM(arr) != 1 ||
             nelem != info->nkeys ||
             ARR_HASNULL(arr) ||
             ARR_ELEMTYPE(arr) != INT2OID)
             elog(ERROR, "confkey is not a 1-D smallint array");
 
         memcpy(info->confkey, ARR_DATA_PTR(arr), nelem * sizeof(AttrNumber));
 
         /* Likewise for conpfeqop */
         adatum = fastgetattr(htup, Anum_pg_constraint_conpfeqop,
                              conrel->rd_att, &isnull);
         if (isnull)
             elog(ERROR, "null conpfeqop for rel %s",
                  RelationGetRelationName(relation));
 
         arr = DatumGetArrayTypeP(adatum);   /* ensure not toasted */
         nelem = ARR_DIMS(arr)[0];
         if (ARR_NDIM(arr) != 1 ||
             nelem != info->nkeys ||
             ARR_HASNULL(arr) ||
             ARR_ELEMTYPE(arr) != OIDOID)
             elog(ERROR, "conpfeqop is not a 1-D OID array");
 
         memcpy(info->conpfeqop, ARR_DATA_PTR(arr), nelem * sizeof(Oid));
 
         /* Add FK's node to the result list */
         result = lappend(result, info);
     }
 
     systable_endscan(conscan);
     heap_close(conrel, AccessShareLock);
 
     /* Now save a copy of the completed list in the relcache entry. */
     oldcxt = MemoryContextSwitchTo(CacheMemoryContext);
     oldlist = relation->rd_fkeylist;
     relation->rd_fkeylist = copyObject(result);
     relation->rd_fkeyvalid = true;
     MemoryContextSwitchTo(oldcxt);
 
     /* Don't leak the old list, if there is one */
     list_free_deep(oldlist);
 
     return result;
 }

Bitmapset* RelationGetIndexAttrBitmap	(	Relation	relation,
		IndexAttrBitmapKind	keyAttrs
	)

Definition at line 4851 of file relcache.c.

References AccessShareLock, bms_add_member(), bms_copy(), bms_free(), BuildIndexInfo(), CacheMemoryContext, elog, equal(), ERROR, FirstLowInvalidHeapAttributeNumber, i, IndexInfo::ii_Expressions, IndexInfo::ii_KeyAttrNumbers, IndexInfo::ii_NumIndexAttrs, IndexInfo::ii_Predicate, IndexInfo::ii_Unique, INDEX_ATTR_BITMAP_ALL, INDEX_ATTR_BITMAP_IDENTITY_KEY, INDEX_ATTR_BITMAP_KEY, INDEX_ATTR_BITMAP_PRIMARY_KEY, index_close(), index_open(), lfirst_oid, list_free(), MemoryContextSwitchTo(), NIL, NULL, pull_varattnos(), RelationData::rd_idattr, RelationData::rd_indexattr, RelationData::rd_keyattr, RelationData::rd_pkattr, RelationData::rd_pkindex, RelationData::rd_replidindex, RelationGetForm, and RelationGetIndexList().

Referenced by ExecUpdateLockMode(), heap_update(), logicalrep_rel_open(), logicalrep_write_attrs(), and reindex_relation().

 {
     Bitmapset  *indexattrs;     /* indexed columns */
     Bitmapset  *uindexattrs;    /* columns in unique indexes */
     Bitmapset  *pkindexattrs;   /* columns in the primary index */
     Bitmapset  *idindexattrs;   /* columns in the replica identity */
     List       *indexoidlist;
     List       *newindexoidlist;
     Oid         relpkindex;
     Oid         relreplindex;
     ListCell   *l;
     MemoryContext oldcxt;
 
     /* Quick exit if we already computed the result. */
     if (relation->rd_indexattr != NULL)
     {
         switch (attrKind)
         {
             case INDEX_ATTR_BITMAP_ALL:
                 return bms_copy(relation->rd_indexattr);
             case INDEX_ATTR_BITMAP_KEY:
                 return bms_copy(relation->rd_keyattr);
             case INDEX_ATTR_BITMAP_PRIMARY_KEY:
                 return bms_copy(relation->rd_pkattr);
             case INDEX_ATTR_BITMAP_IDENTITY_KEY:
                 return bms_copy(relation->rd_idattr);
             default:
                 elog(ERROR, "unknown attrKind %u", attrKind);
         }
     }
 
     /* Fast path if definitely no indexes */
     if (!RelationGetForm(relation)->relhasindex)
         return NULL;
 
     /*
      * Get cached list of index OIDs. If we have to start over, we do so here.
      */
 restart:
     indexoidlist = RelationGetIndexList(relation);
 
     /* Fall out if no indexes (but relhasindex was set) */
     if (indexoidlist == NIL)
         return NULL;
 
     /*
      * Copy the rd_pkindex and rd_replidindex values computed by
      * RelationGetIndexList before proceeding.  This is needed because a
      * relcache flush could occur inside index_open below, resetting the
      * fields managed by RelationGetIndexList.  We need to do the work with
      * stable values of these fields.
      */
     relpkindex = relation->rd_pkindex;
     relreplindex = relation->rd_replidindex;
 
     /*
      * For each index, add referenced attributes to indexattrs.
      *
      * Note: we consider all indexes returned by RelationGetIndexList, even if
      * they are not indisready or indisvalid.  This is important because an
      * index for which CREATE INDEX CONCURRENTLY has just started must be
      * included in HOT-safety decisions (see README.HOT).  If a DROP INDEX
      * CONCURRENTLY is far enough along that we should ignore the index, it
      * won't be returned at all by RelationGetIndexList.
      */
     indexattrs = NULL;
     uindexattrs = NULL;
     pkindexattrs = NULL;
     idindexattrs = NULL;
     foreach(l, indexoidlist)
     {
         Oid         indexOid = lfirst_oid(l);
         Relation    indexDesc;
         IndexInfo  *indexInfo;
         int         i;
         bool        isKey;      /* candidate key */
         bool        isPK;       /* primary key */
         bool        isIDKey;    /* replica identity index */
 
         indexDesc = index_open(indexOid, AccessShareLock);
 
         /* Extract index key information from the index's pg_index row */
         indexInfo = BuildIndexInfo(indexDesc);
 
         /* Can this index be referenced by a foreign key? */
         isKey = indexInfo->ii_Unique &&
             indexInfo->ii_Expressions == NIL &&
             indexInfo->ii_Predicate == NIL;
 
         /* Is this a primary key? */
         isPK = (indexOid == relpkindex);
 
         /* Is this index the configured (or default) replica identity? */
         isIDKey = (indexOid == relreplindex);
 
         /* Collect simple attribute references */
         for (i = 0; i < indexInfo->ii_NumIndexAttrs; i++)
         {
             int         attrnum = indexInfo->ii_KeyAttrNumbers[i];
 
             if (attrnum != 0)
             {
                 indexattrs = bms_add_member(indexattrs,
                                             attrnum - FirstLowInvalidHeapAttributeNumber);
 
                 if (isKey)
                     uindexattrs = bms_add_member(uindexattrs,
                                                  attrnum - FirstLowInvalidHeapAttributeNumber);
 
                 if (isPK)
                     pkindexattrs = bms_add_member(pkindexattrs,
                                                   attrnum - FirstLowInvalidHeapAttributeNumber);
 
                 if (isIDKey)
                     idindexattrs = bms_add_member(idindexattrs,
                                                   attrnum - FirstLowInvalidHeapAttributeNumber);
             }
         }
 
         /* Collect all attributes used in expressions, too */
         pull_varattnos((Node *) indexInfo->ii_Expressions, 1, &indexattrs);
 
         /* Collect all attributes in the index predicate, too */
         pull_varattnos((Node *) indexInfo->ii_Predicate, 1, &indexattrs);
 
         index_close(indexDesc, AccessShareLock);
     }
 
     /*
      * During one of the index_opens in the above loop, we might have received
      * a relcache flush event on this relcache entry, which might have been
      * signaling a change in the rel's index list.  If so, we'd better start
      * over to ensure we deliver up-to-date attribute bitmaps.
      */
     newindexoidlist = RelationGetIndexList(relation);
     if (equal(indexoidlist, newindexoidlist) &&
         relpkindex == relation->rd_pkindex &&
         relreplindex == relation->rd_replidindex)
     {
         /* Still the same index set, so proceed */
         list_free(newindexoidlist);
         list_free(indexoidlist);
     }
     else
     {
         /* Gotta do it over ... might as well not leak memory */
         list_free(newindexoidlist);
         list_free(indexoidlist);
         bms_free(uindexattrs);
         bms_free(pkindexattrs);
         bms_free(idindexattrs);
         bms_free(indexattrs);
 
         goto restart;
     }
 
     /* Don't leak the old values of these bitmaps, if any */
     bms_free(relation->rd_indexattr);
     relation->rd_indexattr = NULL;
     bms_free(relation->rd_keyattr);
     relation->rd_keyattr = NULL;
     bms_free(relation->rd_pkattr);
     relation->rd_pkattr = NULL;
     bms_free(relation->rd_idattr);
     relation->rd_idattr = NULL;
 
     /*
      * Now save copies of the bitmaps in the relcache entry.  We intentionally
      * set rd_indexattr last, because that's the one that signals validity of
      * the values; if we run out of memory before making that copy, we won't
      * leave the relcache entry looking like the other ones are valid but
      * empty.
      */
     oldcxt = MemoryContextSwitchTo(CacheMemoryContext);
     relation->rd_keyattr = bms_copy(uindexattrs);
     relation->rd_pkattr = bms_copy(pkindexattrs);
     relation->rd_idattr = bms_copy(idindexattrs);
     relation->rd_indexattr = bms_copy(indexattrs);
     MemoryContextSwitchTo(oldcxt);
 
     /* We return our original working copy for caller to play with */
     switch (attrKind)
     {
         case INDEX_ATTR_BITMAP_ALL:
             return indexattrs;
         case INDEX_ATTR_BITMAP_KEY:
             return uindexattrs;
         case INDEX_ATTR_BITMAP_PRIMARY_KEY:
             return bms_copy(relation->rd_pkattr);
         case INDEX_ATTR_BITMAP_IDENTITY_KEY:
             return idindexattrs;
         default:
             elog(ERROR, "unknown attrKind %u", attrKind);
             return NULL;
     }
 }

List* RelationGetIndexExpressions ( Relation relation )

Definition at line 4705 of file relcache.c.

References Anum_pg_index_indexprs, Assert, canonicalize_qual(), copyObject, eval_const_expressions(), fix_opfuncids(), GetPgIndexDescriptor(), heap_attisnull(), heap_getattr, MemoryContextSwitchTo(), NIL, NULL, pfree(), RelationData::rd_indexcxt, RelationData::rd_indexprs, RelationData::rd_indextuple, result, stringToNode(), and TextDatumGetCString.

Referenced by ATExecReplicaIdentity(), BuildIndexInfo(), ExecRefreshMatView(), get_relation_info(), infer_arbiter_indexes(), refresh_by_match_merge(), and transformIndexConstraint().

 {
     List       *result;
     Datum       exprsDatum;
     bool        isnull;
     char       *exprsString;
     MemoryContext oldcxt;
 
     /* Quick exit if we already computed the result. */
     if (relation->rd_indexprs)
         return copyObject(relation->rd_indexprs);
 
     /* Quick exit if there is nothing to do. */
     if (relation->rd_indextuple == NULL ||
         heap_attisnull(relation->rd_indextuple, Anum_pg_index_indexprs))
         return NIL;
 
     /*
      * We build the tree we intend to return in the caller's context. After
      * successfully completing the work, we copy it into the relcache entry.
      * This avoids problems if we get some sort of error partway through.
      */
     exprsDatum = heap_getattr(relation->rd_indextuple,
                               Anum_pg_index_indexprs,
                               GetPgIndexDescriptor(),
                               &isnull);
     Assert(!isnull);
     exprsString = TextDatumGetCString(exprsDatum);
     result = (List *) stringToNode(exprsString);
     pfree(exprsString);
 
     /*
      * Run the expressions through eval_const_expressions. This is not just an
      * optimization, but is necessary, because the planner will be comparing
      * them to similarly-processed qual clauses, and may fail to detect valid
      * matches without this.  We don't bother with canonicalize_qual, however.
      */
     result = (List *) eval_const_expressions(NULL, (Node *) result);
 
     result = (List *) canonicalize_qual((Expr *) result);
 
     /* May as well fix opfuncids too */
     fix_opfuncids((Node *) result);
 
     /* Now save a copy of the completed tree in the relcache entry. */
     oldcxt = MemoryContextSwitchTo(relation->rd_indexcxt);
     relation->rd_indexprs = copyObject(result);
     MemoryContextSwitchTo(oldcxt);
 
     return result;
 }

List* RelationGetIndexList ( Relation relation )

Definition at line 4349 of file relcache.c.

References AccessShareLock, Anum_pg_index_indclass, Anum_pg_index_indpred, Anum_pg_index_indrelid, Assert, BTEqualStrategyNumber, CacheMemoryContext, DatumGetPointer, GetPgIndexDescriptor(), GETSTRUCT, heap_attisnull(), heap_close, heap_getattr, heap_open(), HeapTupleIsValid, IndexIndrelidIndexId, IndexIsLive, IndexIsValid, IndexRelationId, insert_ordered_oid(), InvalidOid, list_copy(), list_free(), MemoryContextSwitchTo(), NIL, NULL, ObjectIdAttributeNumber, ObjectIdGetDatum, OID_BTREE_OPS_OID, OidIsValid, RelationData::rd_indexlist, RelationData::rd_indexvalid, RelationData::rd_oidindex, RelationData::rd_pkindex, RelationData::rd_rel, RelationData::rd_replidindex, RelationGetRelid, REPLICA_IDENTITY_DEFAULT, REPLICA_IDENTITY_INDEX, result, ScanKeyInit(), systable_beginscan(), systable_endscan(), systable_getnext(), and oidvector::values.

Referenced by AlterIndexNamespaces(), ATExecChangeOwner(), ATExecDropNotNull(), ATExecSetTableSpace(), calculate_indexes_size(), calculate_toast_table_size(), cluster(), ExecOpenIndices(), ExecRefreshMatView(), get_relation_info(), infer_arbiter_indexes(), mark_index_clustered(), refresh_by_match_merge(), reindex_relation(), relation_mark_replica_identity(), RelationGetIndexAttrBitmap(), RelationGetOidIndex(), RelationGetPrimaryKeyIndex(), RelationGetReplicaIndex(), relationHasPrimaryKey(), RelationHasUnloggedIndex(), RelationTruncateIndexes(), toast_open_indexes(), transformFkeyCheckAttrs(), transformFkeyGetPrimaryKey(), transformTableLikeClause(), triggered_change_notification(), and vac_open_indexes().

 {
     Relation    indrel;
     SysScanDesc indscan;
     ScanKeyData skey;
     HeapTuple   htup;
     List       *result;
     List       *oldlist;
     char        replident = relation->rd_rel->relreplident;
     Oid         oidIndex = InvalidOid;
     Oid         pkeyIndex = InvalidOid;
     Oid         candidateIndex = InvalidOid;
     MemoryContext oldcxt;
 
     /* Quick exit if we already computed the list. */
     if (relation->rd_indexvalid != 0)
         return list_copy(relation->rd_indexlist);
 
     /*
      * We build the list we intend to return (in the caller's context) while
      * doing the scan.  After successfully completing the scan, we copy that
      * list into the relcache entry.  This avoids cache-context memory leakage
      * if we get some sort of error partway through.
      */
     result = NIL;
     oidIndex = InvalidOid;
 
     /* Prepare to scan pg_index for entries having indrelid = this rel. */
     ScanKeyInit(&skey,
                 Anum_pg_index_indrelid,
                 BTEqualStrategyNumber, F_OIDEQ,
                 ObjectIdGetDatum(RelationGetRelid(relation)));
 
     indrel = heap_open(IndexRelationId, AccessShareLock);
     indscan = systable_beginscan(indrel, IndexIndrelidIndexId, true,
                                  NULL, 1, &skey);
 
     while (HeapTupleIsValid(htup = systable_getnext(indscan)))
     {
         Form_pg_index index = (Form_pg_index) GETSTRUCT(htup);
         Datum       indclassDatum;
         oidvector  *indclass;
         bool        isnull;
 
         /*
          * Ignore any indexes that are currently being dropped.  This will
          * prevent them from being searched, inserted into, or considered in
          * HOT-safety decisions.  It's unsafe to touch such an index at all
          * since its catalog entries could disappear at any instant.
          */
         if (!IndexIsLive(index))
             continue;
 
         /* Add index's OID to result list in the proper order */
         result = insert_ordered_oid(result, index->indexrelid);
 
         /*
          * indclass cannot be referenced directly through the C struct,
          * because it comes after the variable-width indkey field.  Must
          * extract the datum the hard way...
          */
         indclassDatum = heap_getattr(htup,
                                      Anum_pg_index_indclass,
                                      GetPgIndexDescriptor(),
                                      &isnull);
         Assert(!isnull);
         indclass = (oidvector *) DatumGetPointer(indclassDatum);
 
         /*
          * Invalid, non-unique, non-immediate or predicate indexes aren't
          * interesting for either oid indexes or replication identity indexes,
          * so don't check them.
          */
         if (!IndexIsValid(index) || !index->indisunique ||
             !index->indimmediate ||
             !heap_attisnull(htup, Anum_pg_index_indpred))
             continue;
 
         /* Check to see if is a usable btree index on OID */
         if (index->indnatts == 1 &&
             index->indkey.values[0] == ObjectIdAttributeNumber &&
             indclass->values[0] == OID_BTREE_OPS_OID)
             oidIndex = index->indexrelid;
 
         /* remember primary key index if any */
         if (index->indisprimary)
             pkeyIndex = index->indexrelid;
 
         /* remember explicitly chosen replica index */
         if (index->indisreplident)
             candidateIndex = index->indexrelid;
     }
 
     systable_endscan(indscan);
 
     heap_close(indrel, AccessShareLock);
 
     /* Now save a copy of the completed list in the relcache entry. */
     oldcxt = MemoryContextSwitchTo(CacheMemoryContext);
     oldlist = relation->rd_indexlist;
     relation->rd_indexlist = list_copy(result);
     relation->rd_oidindex = oidIndex;
     relation->rd_pkindex = pkeyIndex;
     if (replident == REPLICA_IDENTITY_DEFAULT && OidIsValid(pkeyIndex))
         relation->rd_replidindex = pkeyIndex;
     else if (replident == REPLICA_IDENTITY_INDEX && OidIsValid(candidateIndex))
         relation->rd_replidindex = candidateIndex;
     else
         relation->rd_replidindex = InvalidOid;
     relation->rd_indexvalid = 1;
     MemoryContextSwitchTo(oldcxt);
 
     /* Don't leak the old list, if there is one */
     list_free(oldlist);
 
     return result;
 }

List* RelationGetIndexPredicate ( Relation relation )

Definition at line 4768 of file relcache.c.

References Anum_pg_index_indpred, Assert, canonicalize_qual(), copyObject, eval_const_expressions(), fix_opfuncids(), GetPgIndexDescriptor(), heap_attisnull(), heap_getattr, make_ands_implicit(), MemoryContextSwitchTo(), NIL, NULL, pfree(), RelationData::rd_indexcxt, RelationData::rd_indextuple, RelationData::rd_indpred, result, stringToNode(), and TextDatumGetCString.

Referenced by ATExecReplicaIdentity(), BuildIndexInfo(), ExecRefreshMatView(), get_relation_info(), infer_arbiter_indexes(), refresh_by_match_merge(), and transformIndexConstraint().

 {
     List       *result;
     Datum       predDatum;
     bool        isnull;
     char       *predString;
     MemoryContext oldcxt;
 
     /* Quick exit if we already computed the result. */
     if (relation->rd_indpred)
         return copyObject(relation->rd_indpred);
 
     /* Quick exit if there is nothing to do. */
     if (relation->rd_indextuple == NULL ||
         heap_attisnull(relation->rd_indextuple, Anum_pg_index_indpred))
         return NIL;
 
     /*
      * We build the tree we intend to return in the caller's context. After
      * successfully completing the work, we copy it into the relcache entry.
      * This avoids problems if we get some sort of error partway through.
      */
     predDatum = heap_getattr(relation->rd_indextuple,
                              Anum_pg_index_indpred,
                              GetPgIndexDescriptor(),
                              &isnull);
     Assert(!isnull);
     predString = TextDatumGetCString(predDatum);
     result = (List *) stringToNode(predString);
     pfree(predString);
 
     /*
      * Run the expression through const-simplification and canonicalization.
      * This is not just an optimization, but is necessary, because the planner
      * will be comparing it to similarly-processed qual clauses, and may fail
      * to detect valid matches without this.  This must match the processing
      * done to qual clauses in preprocess_expression()!  (We can skip the
      * stuff involving subqueries, however, since we don't allow any in index
      * predicates.)
      */
     result = (List *) eval_const_expressions(NULL, (Node *) result);
 
     result = (List *) canonicalize_qual((Expr *) result);
 
     /* Also convert to implicit-AND format */
     result = make_ands_implicit((Expr *) result);
 
     /* May as well fix opfuncids too */
     fix_opfuncids((Node *) result);
 
     /* Now save a copy of the completed tree in the relcache entry. */
     oldcxt = MemoryContextSwitchTo(relation->rd_indexcxt);
     relation->rd_indpred = copyObject(result);
     MemoryContextSwitchTo(oldcxt);
 
     return result;
 }

Oid RelationGetOidIndex ( Relation relation )

Definition at line 4631 of file relcache.c.

References Assert, list_free(), RelationData::rd_indexvalid, RelationData::rd_oidindex, RelationData::rd_rel, and RelationGetIndexList().

Referenced by GetNewOid().

 {
     List       *ilist;
 
     /*
      * If relation doesn't have OIDs at all, caller is probably confused. (We
      * could just silently return InvalidOid, but it seems better to throw an
      * assertion.)
      */
     Assert(relation->rd_rel->relhasoids);
 
     if (relation->rd_indexvalid == 0)
     {
         /* RelationGetIndexList does the heavy lifting. */
         ilist = RelationGetIndexList(relation);
         list_free(ilist);
         Assert(relation->rd_indexvalid != 0);
     }
 
     return relation->rd_oidindex;
 }

Oid RelationGetPrimaryKeyIndex ( Relation relation )

Definition at line 4659 of file relcache.c.

References Assert, list_free(), RelationData::rd_indexvalid, RelationData::rd_pkindex, and RelationGetIndexList().

Referenced by GetRelationIdentityOrPK().

 {
     List       *ilist;
 
     if (relation->rd_indexvalid == 0)
     {
         /* RelationGetIndexList does the heavy lifting. */
         ilist = RelationGetIndexList(relation);
         list_free(ilist);
         Assert(relation->rd_indexvalid != 0);
     }
 
     return relation->rd_pkindex;
 }

Oid RelationGetReplicaIndex ( Relation relation )

Definition at line 4680 of file relcache.c.

References Assert, list_free(), RelationData::rd_indexvalid, RelationData::rd_replidindex, and RelationGetIndexList().

Referenced by build_replindex_scan_key(), CheckCmdReplicaIdentity(), ExtractReplicaIdentity(), GetRelationIdentityOrPK(), and pg_get_replica_identity_index().

 {
     List       *ilist;
 
     if (relation->rd_indexvalid == 0)
     {
         /* RelationGetIndexList does the heavy lifting. */
         ilist = RelationGetIndexList(relation);
         list_free(ilist);
         Assert(relation->rd_indexvalid != 0);
     }
 
     return relation->rd_replidindex;
 }

List* RelationGetStatExtList ( Relation relation )

Definition at line 4489 of file relcache.c.

References AccessShareLock, Anum_pg_statistic_ext_stxrelid, BTEqualStrategyNumber, CacheMemoryContext, heap_close, heap_open(), HeapTupleGetOid, HeapTupleIsValid, insert_ordered_oid(), list_copy(), list_free(), MemoryContextSwitchTo(), NIL, NULL, ObjectIdGetDatum, RelationData::rd_statlist, RelationData::rd_statvalid, RelationGetRelid, result, ScanKeyInit(), StatisticExtRelationId, StatisticExtRelidIndexId, systable_beginscan(), systable_endscan(), and systable_getnext().

Referenced by get_relation_statistics().

 {
     Relation    indrel;
     SysScanDesc indscan;
     ScanKeyData skey;
     HeapTuple   htup;
     List       *result;
     List       *oldlist;
     MemoryContext oldcxt;
 
     /* Quick exit if we already computed the list. */
     if (relation->rd_statvalid != 0)
         return list_copy(relation->rd_statlist);
 
     /*
      * We build the list we intend to return (in the caller's context) while
      * doing the scan.  After successfully completing the scan, we copy that
      * list into the relcache entry.  This avoids cache-context memory leakage
      * if we get some sort of error partway through.
      */
     result = NIL;
 
     /*
      * Prepare to scan pg_statistic_ext for entries having stxrelid = this
      * rel.
      */
     ScanKeyInit(&skey,
                 Anum_pg_statistic_ext_stxrelid,
                 BTEqualStrategyNumber, F_OIDEQ,
                 ObjectIdGetDatum(RelationGetRelid(relation)));
 
     indrel = heap_open(StatisticExtRelationId, AccessShareLock);
     indscan = systable_beginscan(indrel, StatisticExtRelidIndexId, true,
                                  NULL, 1, &skey);
 
     while (HeapTupleIsValid(htup = systable_getnext(indscan)))
         result = insert_ordered_oid(result, HeapTupleGetOid(htup));
 
     systable_endscan(indscan);
 
     heap_close(indrel, AccessShareLock);
 
     /* Now save a copy of the completed list in the relcache entry. */
     oldcxt = MemoryContextSwitchTo(CacheMemoryContext);
     oldlist = relation->rd_statlist;
     relation->rd_statlist = list_copy(result);
 
     relation->rd_statvalid = true;
     MemoryContextSwitchTo(oldcxt);
 
     /* Don't leak the old list, if there is one */
     list_free(oldlist);
 
     return result;
 }

Relation RelationIdGetRelation ( Oid relationId )

Definition at line 2071 of file relcache.c.

References Assert, IsTransactionState(), RelationData::rd_isvalid, RelationData::rd_rel, RelationBuildDesc(), RelationClearRelation(), RelationIdCacheLookup, RelationIncrementReferenceCount(), RelationIsValid, RelationReloadIndexInfo(), and RELKIND_INDEX.

Referenced by ExtractReplicaIdentity(), relation_open(), ReorderBufferCommit(), ReorderBufferToastReplace(), and try_relation_open().

 {
     Relation    rd;
 
     /* Make sure we're in an xact, even if this ends up being a cache hit */
     Assert(IsTransactionState());
 
     /*
      * first try to find reldesc in the cache
      */
     RelationIdCacheLookup(relationId, rd);
 
     if (RelationIsValid(rd))
     {
         RelationIncrementReferenceCount(rd);
         /* revalidate cache entry if necessary */
         if (!rd->rd_isvalid)
         {
             /*
              * Indexes only have a limited number of possible schema changes,
              * and we don't want to use the full-blown procedure because it's
              * a headache for indexes that reload itself depends on.
              */
             if (rd->rd_rel->relkind == RELKIND_INDEX)
                 RelationReloadIndexInfo(rd);
             else
                 RelationClearRelation(rd, true);
             Assert(rd->rd_isvalid);
         }
         return rd;
     }
 
     /*
      * no reldesc in the cache, so have RelationBuildDesc() build one and add
      * it.
      */
     rd = RelationBuildDesc(relationId, true);
     if (RelationIsValid(rd))
         RelationIncrementReferenceCount(rd);
     return rd;
 }

bool RelationIdIsInInitFile ( Oid relationId )

Definition at line 5964 of file relcache.c.

References Assert, RelationSupportsSysCache(), and TriggerRelidNameIndexId.

Referenced by RegisterRelcacheInvalidation(), and write_relcache_init_file().

 {
     if (relationId == TriggerRelidNameIndexId)
     {
         /* If this Assert fails, we don't need this special case anymore. */
         Assert(!RelationSupportsSysCache(relationId));
         return true;
     }
     return RelationSupportsSysCache(relationId);
 }

void RelationInitIndexAccessInfo ( Relation relation )

Definition at line 1509 of file relcache.c.

References ALLOCSET_SMALL_SIZES, AllocSetContextCreate(), AMOID, IndexAmRoutine::amsupport, Anum_pg_index_indclass, Anum_pg_index_indcollation, Anum_pg_index_indoption, Assert, CacheMemoryContext, DatumGetPointer, elog, ERROR, fastgetattr, GetPgIndexDescriptor(), GETSTRUCT, heap_copytuple(), HeapTupleIsValid, INDEXRELID, IndexSupportInitialize(), InitIndexAmRoutine(), MemoryContextAllocZero(), MemoryContextSwitchTo(), NIL, NULL, ObjectIdGetDatum, RelationData::rd_amcache, RelationData::rd_amhandler, RelationData::rd_amroutine, RelationData::rd_exclops, RelationData::rd_exclprocs, RelationData::rd_exclstrats, RelationData::rd_indcollation, RelationData::rd_index, RelationData::rd_indexcxt, RelationData::rd_indexprs, RelationData::rd_indextuple, RelationData::rd_indoption, RelationData::rd_indpred, RelationData::rd_opcintype, RelationData::rd_opfamily, RelationData::rd_rel, RelationData::rd_support, RelationData::rd_supportinfo, RelationGetRelationName, RelationGetRelid, ReleaseSysCache(), SearchSysCache1, int2vector::values, and oidvector::values.

Referenced by index_create(), and RelationBuildDesc().

 {
     HeapTuple   tuple;
     Form_pg_am  aform;
     Datum       indcollDatum;
     Datum       indclassDatum;
     Datum       indoptionDatum;
     bool        isnull;
     oidvector  *indcoll;
     oidvector  *indclass;
     int2vector *indoption;
     MemoryContext indexcxt;
     MemoryContext oldcontext;
     int         natts;
     uint16      amsupport;
 
     /*
      * Make a copy of the pg_index entry for the index.  Since pg_index
      * contains variable-length and possibly-null fields, we have to do this
      * honestly rather than just treating it as a Form_pg_index struct.
      */
     tuple = SearchSysCache1(INDEXRELID,
                             ObjectIdGetDatum(RelationGetRelid(relation)));
     if (!HeapTupleIsValid(tuple))
         elog(ERROR, "cache lookup failed for index %u",
              RelationGetRelid(relation));
     oldcontext = MemoryContextSwitchTo(CacheMemoryContext);
     relation->rd_indextuple = heap_copytuple(tuple);
     relation->rd_index = (Form_pg_index) GETSTRUCT(relation->rd_indextuple);
     MemoryContextSwitchTo(oldcontext);
     ReleaseSysCache(tuple);
 
     /*
      * Look up the index's access method, save the OID of its handler function
      */
     tuple = SearchSysCache1(AMOID, ObjectIdGetDatum(relation->rd_rel->relam));
     if (!HeapTupleIsValid(tuple))
         elog(ERROR, "cache lookup failed for access method %u",
              relation->rd_rel->relam);
     aform = (Form_pg_am) GETSTRUCT(tuple);
     relation->rd_amhandler = aform->amhandler;
     ReleaseSysCache(tuple);
 
     natts = relation->rd_rel->relnatts;
     if (natts != relation->rd_index->indnatts)
         elog(ERROR, "relnatts disagrees with indnatts for index %u",
              RelationGetRelid(relation));
 
     /*
      * Make the private context to hold index access info.  The reason we need
      * a context, and not just a couple of pallocs, is so that we won't leak
      * any subsidiary info attached to fmgr lookup records.
      */
     indexcxt = AllocSetContextCreate(CacheMemoryContext,
                                      RelationGetRelationName(relation),
                                      ALLOCSET_SMALL_SIZES);
     relation->rd_indexcxt = indexcxt;
 
     /*
      * Now we can fetch the index AM's API struct
      */
     InitIndexAmRoutine(relation);
 
     /*
      * Allocate arrays to hold data
      */
     relation->rd_opfamily = (Oid *)
         MemoryContextAllocZero(indexcxt, natts * sizeof(Oid));
     relation->rd_opcintype = (Oid *)
         MemoryContextAllocZero(indexcxt, natts * sizeof(Oid));
 
     amsupport = relation->rd_amroutine->amsupport;
     if (amsupport > 0)
     {
         int         nsupport = natts * amsupport;
 
         relation->rd_support = (RegProcedure *)
             MemoryContextAllocZero(indexcxt, nsupport * sizeof(RegProcedure));
         relation->rd_supportinfo = (FmgrInfo *)
             MemoryContextAllocZero(indexcxt, nsupport * sizeof(FmgrInfo));
     }
     else
     {
         relation->rd_support = NULL;
         relation->rd_supportinfo = NULL;
     }
 
     relation->rd_indcollation = (Oid *)
         MemoryContextAllocZero(indexcxt, natts * sizeof(Oid));
 
     relation->rd_indoption = (int16 *)
         MemoryContextAllocZero(indexcxt, natts * sizeof(int16));
 
     /*
      * indcollation cannot be referenced directly through the C struct,
      * because it comes after the variable-width indkey field.  Must extract
      * the datum the hard way...
      */
     indcollDatum = fastgetattr(relation->rd_indextuple,
                                Anum_pg_index_indcollation,
                                GetPgIndexDescriptor(),
                                &isnull);
     Assert(!isnull);
     indcoll = (oidvector *) DatumGetPointer(indcollDatum);
     memcpy(relation->rd_indcollation, indcoll->values, natts * sizeof(Oid));
 
     /*
      * indclass cannot be referenced directly through the C struct, because it
      * comes after the variable-width indkey field.  Must extract the datum
      * the hard way...
      */
     indclassDatum = fastgetattr(relation->rd_indextuple,
                                 Anum_pg_index_indclass,
                                 GetPgIndexDescriptor(),
                                 &isnull);
     Assert(!isnull);
     indclass = (oidvector *) DatumGetPointer(indclassDatum);
 
     /*
      * Fill the support procedure OID array, as well as the info about
      * opfamilies and opclass input types.  (aminfo and supportinfo are left
      * as zeroes, and are filled on-the-fly when used)
      */
     IndexSupportInitialize(indclass, relation->rd_support,
                            relation->rd_opfamily, relation->rd_opcintype,
                            amsupport, natts);
 
     /*
      * Similarly extract indoption and copy it to the cache entry
      */
     indoptionDatum = fastgetattr(relation->rd_indextuple,
                                  Anum_pg_index_indoption,
                                  GetPgIndexDescriptor(),
                                  &isnull);
     Assert(!isnull);
     indoption = (int2vector *) DatumGetPointer(indoptionDatum);
     memcpy(relation->rd_indoption, indoption->values, natts * sizeof(int16));
 
     /*
      * expressions, predicate, exclusion caches will be filled later
      */
     relation->rd_indexprs = NIL;
     relation->rd_indpred = NIL;
     relation->rd_exclops = NULL;
     relation->rd_exclprocs = NULL;
     relation->rd_exclstrats = NULL;
     relation->rd_amcache = NULL;
 }

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

Definition at line 4600 of file relcache.c.

References Assert, CacheMemoryContext, EOXactListAdd, InvalidOid, list_copy(), list_free(), MemoryContextSwitchTo(), RelationData::rd_indexlist, RelationData::rd_indexvalid, RelationData::rd_isnailed, RelationData::rd_oidindex, RelationData::rd_pkindex, and RelationData::rd_replidindex.

Referenced by reindex_relation().

 {
     MemoryContext oldcxt;
 
     Assert(relation->rd_isnailed);
     /* Copy the list into the cache context (could fail for lack of mem) */
     oldcxt = MemoryContextSwitchTo(CacheMemoryContext);
     indexIds = list_copy(indexIds);
     MemoryContextSwitchTo(oldcxt);
     /* Okay to replace old list */
     list_free(relation->rd_indexlist);
     relation->rd_indexlist = indexIds;
     relation->rd_oidindex = oidIndex;
 
     /*
      * For the moment, assume the target rel hasn't got a pk or replica index.
      * We'll load them on demand in the API that wraps access to them.
      */
     relation->rd_pkindex = InvalidOid;
     relation->rd_replidindex = InvalidOid;
     relation->rd_indexvalid = 2;    /* mark list as forced */
     /* Flag relation as needing eoxact cleanup (to reset the list) */
     EOXactListAdd(relation);
 }

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

Definition at line 3420 of file relcache.c.

References Assert, RelFileNodeBackend::backend, CatalogTupleUpdate(), CommandCounterIncrement(), elog, EOXactListAdd, ERROR, GetCurrentSubTransactionId(), GetNewRelFileNode(), GETSTRUCT, heap_close, heap_freetuple(), heap_open(), HeapTupleIsValid, InvalidTransactionId, MultiXactIdIsValid, RelFileNodeBackend::node, NULL, ObjectIdGetDatum, RelationData::rd_backend, RelationData::rd_newRelfilenodeSubid, RelationData::rd_node, RelationData::rd_rel, RelationCreateStorage(), RelationDropStorage(), RelationGetRelid, RelationIsMapped, RelationMapUpdateMap(), RelationRelationId, RELKIND_INDEX, RELKIND_SEQUENCE, RelFileNode::relNode, RELOID, RowExclusiveLock, SearchSysCacheCopy1, smgrclosenode(), HeapTupleData::t_self, and TransactionIdIsNormal.

Referenced by AlterSequence(), ExecuteTruncate(), reindex_index(), and ResetSequence().

 {
     Oid         newrelfilenode;
     RelFileNodeBackend newrnode;
     Relation    pg_class;
     HeapTuple   tuple;
     Form_pg_class classform;
 
     /* Indexes, sequences must have Invalid frozenxid; other rels must not */
     Assert((relation->rd_rel->relkind == RELKIND_INDEX ||
             relation->rd_rel->relkind == RELKIND_SEQUENCE) ?
            freezeXid == InvalidTransactionId :
            TransactionIdIsNormal(freezeXid));
     Assert(TransactionIdIsNormal(freezeXid) == MultiXactIdIsValid(minmulti));
 
     /* Allocate a new relfilenode */
     newrelfilenode = GetNewRelFileNode(relation->rd_rel->reltablespace, NULL,
                                        persistence);
 
     /*
      * Get a writable copy of the pg_class tuple for the given relation.
      */
     pg_class = heap_open(RelationRelationId, RowExclusiveLock);
 
     tuple = SearchSysCacheCopy1(RELOID,
                                 ObjectIdGetDatum(RelationGetRelid(relation)));
     if (!HeapTupleIsValid(tuple))
         elog(ERROR, "could not find tuple for relation %u",
              RelationGetRelid(relation));
     classform = (Form_pg_class) GETSTRUCT(tuple);
 
     /*
      * Create storage for the main fork of the new relfilenode.
      *
      * NOTE: any conflict in relfilenode value will be caught here, if
      * GetNewRelFileNode messes up for any reason.
      */
     newrnode.node = relation->rd_node;
     newrnode.node.relNode = newrelfilenode;
     newrnode.backend = relation->rd_backend;
     RelationCreateStorage(newrnode.node, persistence);
     smgrclosenode(newrnode);
 
     /*
      * Schedule unlinking of the old storage at transaction commit.
      */
     RelationDropStorage(relation);
 
     /*
      * Now update the pg_class row.  However, if we're dealing with a mapped
      * index, pg_class.relfilenode doesn't change; instead we have to send the
      * update to the relation mapper.
      */
     if (RelationIsMapped(relation))
         RelationMapUpdateMap(RelationGetRelid(relation),
                              newrelfilenode,
                              relation->rd_rel->relisshared,
                              false);
     else
         classform->relfilenode = newrelfilenode;
 
     /* These changes are safe even for a mapped relation */
     if (relation->rd_rel->relkind != RELKIND_SEQUENCE)
     {
         classform->relpages = 0;    /* it's empty until further notice */
         classform->reltuples = 0;
         classform->relallvisible = 0;
     }
     classform->relfrozenxid = freezeXid;
     classform->relminmxid = minmulti;
     classform->relpersistence = persistence;
 
     CatalogTupleUpdate(pg_class, &tuple->t_self, tuple);
 
     heap_freetuple(tuple);
 
     heap_close(pg_class, RowExclusiveLock);
 
     /*
      * Make the pg_class row change visible, as well as the relation map
      * change if any.  This will cause the relcache entry to get updated, too.
      */
     CommandCounterIncrement();
 
     /*
      * Mark the rel as having been given a new relfilenode in the current
      * (sub) transaction.  This is a hint that can be used to optimize later
      * operations on the rel in the same transaction.
      */
     relation->rd_newRelfilenodeSubid = GetCurrentSubTransactionId();
 
     /* Flag relation as needing eoxact cleanup (to remove the hint) */
     EOXactListAdd(relation);
 }

Variable Documentation

bool criticalRelcachesBuilt

Definition at line 129 of file relcache.c.

Referenced by IndexScanOK(), load_relcache_init_file(), LookupOpclassInfo(), RelationBuildTupleDesc(), RelationCacheInitializePhase3(), RelationReloadIndexInfo(), and ScanPgRelation().

bool criticalSharedRelcachesBuilt

Definition at line 135 of file relcache.c.

Referenced by GetDatabaseTuple(), GetDatabaseTupleByOid(), IndexScanOK(), load_relcache_init_file(), and RelationCacheInitializePhase3().

Typedefs

Enumerations

Functions

Variables

Typedef Documentation

Enumeration Type Documentation

Function Documentation

Variable Documentation