relcache.h File Reference

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

Include dependency graph for relcache.h:

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

Go to the source code of this file.

Macros
#define	RELCACHE_INIT_FILENAME   "pg_internal.init"
#define	AssertPendingSyncs_RelationCache()   do {} while (0)

Typedefs
typedef struct RelationData *	Relation
typedef Relation *	RelationPtr
typedef enum IndexAttrBitmapKind	IndexAttrBitmapKind

Enumerations
enum	IndexAttrBitmapKind {   INDEX_ATTR_BITMAP_KEY , INDEX_ATTR_BITMAP_PRIMARY_KEY , INDEX_ATTR_BITMAP_IDENTITY_KEY , INDEX_ATTR_BITMAP_HOT_BLOCKING ,   INDEX_ATTR_BITMAP_SUMMARIZED }

Functions
static void	AssertCouldGetRelation (void)
Relation	RelationIdGetRelation (Oid relationId)
void	RelationClose (Relation relation)
List *	RelationGetFKeyList (Relation relation)
List *	RelationGetIndexList (Relation relation)
List *	RelationGetStatExtList (Relation relation)
Oid	RelationGetPrimaryKeyIndex (Relation relation, bool deferrable_ok)
Oid	RelationGetReplicaIndex (Relation relation)
List *	RelationGetIndexExpressions (Relation relation)
List *	RelationGetDummyIndexExpressions (Relation relation)
List *	RelationGetIndexPredicate (Relation relation)
bytea **	RelationGetIndexAttOptions (Relation relation, bool copy)
Bitmapset *	RelationGetIndexAttrBitmap (Relation relation, IndexAttrBitmapKind attrKind)
Bitmapset *	RelationGetIdentityKeyBitmap (Relation relation)
void	RelationGetExclusionInfo (Relation indexRelation, Oid **operators, Oid **procs, uint16 **strategies)
void	RelationInitIndexAccessInfo (Relation relation)
void	RelationBuildPublicationDesc (Relation relation, struct PublicationDesc *pubdesc)
void	RelationInitTableAccessMethod (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 accessmtd, RelFileNumber relfilenumber, Oid reltablespace, bool shared_relation, bool mapped_relation, char relpersistence, char relkind)
void	RelationSetNewRelfilenumber (Relation relation, char persistence)
void	RelationAssumeNewRelfilelocator (Relation relation)
void	RelationForgetRelation (Oid rid)
void	RelationCacheInvalidateEntry (Oid relationId)
void	RelationCacheInvalidate (bool debug_discard)
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
PGDLLIMPORT bool	criticalRelcachesBuilt
PGDLLIMPORT bool	criticalSharedRelcachesBuilt

Macro Definition Documentation

AssertPendingSyncs_RelationCache

#define AssertPendingSyncs_RelationCache

(

)

do {} while (0)

Definition at line 143 of file relcache.h.

RELCACHE_INIT_FILENAME

#define RELCACHE_INIT_FILENAME   "pg_internal.init"

Definition at line 25 of file relcache.h.

Typedef Documentation

IndexAttrBitmapKind

typedef enum IndexAttrBitmapKind IndexAttrBitmapKind

Relation

typedef struct RelationData* Relation

Definition at line 27 of file relcache.h.

RelationPtr

typedef Relation* RelationPtr

Definition at line 35 of file relcache.h.

Enumeration Type Documentation

IndexAttrBitmapKind

enum IndexAttrBitmapKind

Enumerator
INDEX_ATTR_BITMAP_KEY
INDEX_ATTR_BITMAP_PRIMARY_KEY
INDEX_ATTR_BITMAP_IDENTITY_KEY
INDEX_ATTR_BITMAP_HOT_BLOCKING
INDEX_ATTR_BITMAP_SUMMARIZED

Definition at line 67 of file relcache.h.

{
    INDEX_ATTR_BITMAP_KEY,
    INDEX_ATTR_BITMAP_PRIMARY_KEY,
    INDEX_ATTR_BITMAP_IDENTITY_KEY,
    INDEX_ATTR_BITMAP_HOT_BLOCKING,
    INDEX_ATTR_BITMAP_SUMMARIZED,
} IndexAttrBitmapKind;

Function Documentation

AssertCouldGetRelation()

static void AssertCouldGetRelation ( void  )

inlinestatic

Definition at line 44 of file relcache.h.

{
}

Referenced by AcceptInvalidationMessages(), CacheInvalidateHeapTupleCommon(), ConditionalCatalogCacheInitializeCache(), InitializeClientEncoding(), pg_newlocale_from_collation(), PrepareInplaceInvalidationState(), PrepareInvalidationState(), RelationIdGetRelation(), RelationRebuildRelation(), and RelationReloadNailed().

AtEOSubXact_RelationCache()

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

Definition at line 3378 of file relcache.c.

{
    HASH_SEQ_STATUS status;
    RelIdCacheEnt *idhentry;
    int         i;
 
    /*
     * Forget in_progress_list.  This is relevant when we're aborting due to
     * an error during RelationBuildDesc().  We don't commit subtransactions
     * during RelationBuildDesc().
     */
    Assert(in_progress_list_len == 0 || !isCommit);
    in_progress_list_len = 0;
 
    /*
     * Unless the eoxact_list[] overflowed, we only need to examine the rels
     * listed in it.  Otherwise fall back on a hash_seq_search scan.  Same
     * logic as in AtEOXact_RelationCache.
     */
    if (eoxact_list_overflowed)
    {
        hash_seq_init(&status, RelationIdCache);
        while ((idhentry = (RelIdCacheEnt *) hash_seq_search(&status)) != NULL)
        {
            AtEOSubXact_cleanup(idhentry->reldesc, isCommit,
                                mySubid, parentSubid);
        }
    }
    else
    {
        for (i = 0; i < eoxact_list_len; i++)
        {
            idhentry = (RelIdCacheEnt *) hash_search(RelationIdCache,
                                                     &eoxact_list[i],
                                                     HASH_FIND,
                                                     NULL);
            if (idhentry != NULL)
                AtEOSubXact_cleanup(idhentry->reldesc, isCommit,
                                    mySubid, parentSubid);
        }
    }
 
    /* Don't reset the list; we still need more cleanup later */
}

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

Referenced by AbortSubTransaction(), and CommitSubTransaction().

AtEOXact_RelationCache()

void AtEOXact_RelationCache

(

bool

isCommit

)

Definition at line 3226 of file relcache.c.

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

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

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

errtable()

int errtable

(

Relation

rel

)

Definition at line 6046 of file relcache.c.

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

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

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

errtablecol()

int errtablecol	(	Relation	rel,
		int	attnum
	)

Definition at line 6063 of file relcache.c.

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

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

Referenced by ATRewriteTable(), ReportNotNullViolationError(), validateDomainCheckConstraint(), and validateDomainNotNullConstraint().

errtablecolname()

int errtablecolname	(	Relation	rel,
		const char *	colname
	)

Definition at line 6087 of file relcache.c.

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

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

Referenced by errtablecol().

errtableconstraint()

int errtableconstraint	(	Relation	rel,
		const char *	conname
	)

Definition at line 6100 of file relcache.c.

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

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

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

RelationAssumeNewRelfilelocator()

void RelationAssumeNewRelfilelocator

(

Relation

relation

)

Definition at line 3976 of file relcache.c.

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

References EOXactListAdd, GetCurrentSubTransactionId(), InvalidSubTransactionId, RelationData::rd_firstRelfilelocatorSubid, and RelationData::rd_newRelfilelocatorSubid.

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

RelationBuildLocalRelation()

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

Definition at line 3515 of file relcache.c.

{
    Relation    rel;
    MemoryContext oldcxt;
    int         natts = tupDesc->natts;
    int         i;
    bool        has_not_null;
    bool        nailit;
 
    Assert(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_newRelfilelocatorSubid = InvalidSubTransactionId;
    rel->rd_firstRelfilelocatorSubid = InvalidSubTransactionId;
    rel->rd_droppedSubid = InvalidSubTransactionId;
 
    /*
     * create a new tuple descriptor from the one passed in.  We do this
     * partly to copy it into the cache context, and partly because the new
     * relation can't have any defaults or constraints yet; they have to be
     * added in later steps, because they require additions to multiple system
     * catalogs.  We can copy attnotnull constraints here, however.
     */
    rel->rd_att = CreateTupleDescCopy(tupDesc);
    rel->rd_att->tdrefcount = 1;    /* mark as refcounted */
    has_not_null = false;
    for (i = 0; i < natts; i++)
    {
        Form_pg_attribute satt = TupleDescAttr(tupDesc, i);
        Form_pg_attribute datt = TupleDescAttr(rel->rd_att, i);
 
        datt->attidentity = satt->attidentity;
        datt->attgenerated = satt->attgenerated;
        datt->attnotnull = satt->attnotnull;
        has_not_null |= satt->attnotnull;
        populate_compact_attribute(rel->rd_att, i);
 
        if (satt->attnotnull)
        {
            CompactAttribute *scatt = TupleDescCompactAttr(tupDesc, i);
            CompactAttribute *dcatt = TupleDescCompactAttr(rel->rd_att, i);
 
            dcatt->attnullability = scatt->attnullability;
        }
    }
 
    if (has_not_null)
    {
        TupleConstr *constr = (TupleConstr *) palloc0(sizeof(TupleConstr));
 
        constr->has_not_null = true;
        rel->rd_att->constr = constr;
    }
 
    /*
     * initialize relation tuple form (caller may add/override data later)
     */
    rel->rd_rel = (Form_pg_class) palloc0(CLASS_TUPLE_SIZE);
 
    namestrcpy(&rel->rd_rel->relname, relname);
    rel->rd_rel->relnamespace = relnamespace;
 
    rel->rd_rel->relkind = relkind;
    rel->rd_rel->relnatts = natts;
    rel->rd_rel->reltype = InvalidOid;
    /* needed when bootstrapping: */
    rel->rd_rel->relowner = BOOTSTRAP_SUPERUSERID;
 
    /* set up persistence and relcache fields dependent on it */
    rel->rd_rel->relpersistence = relpersistence;
    switch (relpersistence)
    {
        case RELPERSISTENCE_UNLOGGED:
        case RELPERSISTENCE_PERMANENT:
            rel->rd_backend = INVALID_PROC_NUMBER;
            rel->rd_islocaltemp = false;
            break;
        case RELPERSISTENCE_TEMP:
            Assert(isTempOrTempToastNamespace(relnamespace));
            rel->rd_backend = ProcNumberForTempRelations();
            rel->rd_islocaltemp = true;
            break;
        default:
            elog(ERROR, "invalid relpersistence: %c", relpersistence);
            break;
    }
 
    /* if it's a materialized view, it's not populated initially */
    if (relkind == RELKIND_MATVIEW)
        rel->rd_rel->relispopulated = false;
    else
        rel->rd_rel->relispopulated = true;
 
    /* set replica identity -- system catalogs and non-tables don't have one */
    if (!IsCatalogNamespace(relnamespace) &&
        (relkind == RELKIND_RELATION ||
         relkind == RELKIND_MATVIEW ||
         relkind == RELKIND_PARTITIONED_TABLE))
        rel->rd_rel->relreplident = REPLICA_IDENTITY_DEFAULT;
    else
        rel->rd_rel->relreplident = REPLICA_IDENTITY_NOTHING;
 
    /*
     * Insert relation physical and logical identifiers (OIDs) into the right
     * places.  For a mapped relation, we set relfilenumber to zero and rely
     * on RelationInitPhysicalAddr to consult the map.
     */
    rel->rd_rel->relisshared = shared_relation;
 
    RelationGetRelid(rel) = relid;
 
    for (i = 0; i < natts; i++)
        TupleDescAttr(rel->rd_att, i)->attrelid = relid;
 
    rel->rd_rel->reltablespace = reltablespace;
 
    if (mapped_relation)
    {
        rel->rd_rel->relfilenode = InvalidRelFileNumber;
        /* Add it to the active mapping information */
        RelationMapUpdateMap(relid, relfilenumber, shared_relation, true);
    }
    else
        rel->rd_rel->relfilenode = relfilenumber;
 
    RelationInitLockInfo(rel);  /* see lmgr.c */
 
    RelationInitPhysicalAddr(rel);
 
    rel->rd_rel->relam = accessmtd;
 
    /*
     * RelationInitTableAccessMethod will do syscache lookups, so we mustn't
     * run it in CacheMemoryContext.  Fortunately, the remaining steps don't
     * require a long-lived current context.
     */
    MemoryContextSwitchTo(oldcxt);
 
    if (RELKIND_HAS_TABLE_AM(relkind) || relkind == RELKIND_SEQUENCE)
        RelationInitTableAccessMethod(rel);
 
    /*
     * Leave index access method uninitialized, because the pg_index row has
     * not been inserted at this stage of index creation yet.  The cache
     * invalidation after pg_index row has been inserted will initialize it.
     */
 
    /*
     * Okay to insert into the relcache hash table.
     *
     * Ordinarily, there should certainly not be an existing hash entry for
     * the same OID; but during bootstrap, when we create a "real" relcache
     * entry for one of the bootstrap relations, we'll be overwriting the
     * phony one created with formrdesc.  So allow that to happen for nailed
     * rels.
     */
    RelationCacheInsert(rel, nailit);
 
    /*
     * Flag relation as needing eoxact cleanup (to clear rd_createSubid). We
     * can't do this before storing relid in it.
     */
    EOXactListAdd(rel);
 
    /* It's fully valid */
    rel->rd_isvalid = true;
 
    /*
     * Caller expects us to pin the returned entry.
     */
    RelationIncrementReferenceCount(rel);
 
    return rel;
}

References Assert(), CompactAttribute::attnullability, CacheMemoryContext, CLASS_TUPLE_SIZE, TupleDescData::constr, CreateCacheMemoryContext(), CreateTupleDescCopy(), elog, EOXactListAdd, ERROR, GetCurrentSubTransactionId(), TupleConstr::has_not_null, i, INVALID_PROC_NUMBER, InvalidOid, InvalidRelFileNumber, InvalidSubTransactionId, IsCatalogNamespace(), IsSharedRelation(), isTempOrTempToastNamespace(), MemoryContextSwitchTo(), namestrcpy(), TupleDescData::natts, palloc0(), populate_compact_attribute(), ProcNumberForTempRelations, RelationData::rd_att, RelationData::rd_backend, RelationData::rd_createSubid, RelationData::rd_droppedSubid, RelationData::rd_firstRelfilelocatorSubid, RelationData::rd_islocaltemp, RelationData::rd_isnailed, RelationData::rd_isvalid, RelationData::rd_newRelfilelocatorSubid, RelationData::rd_refcnt, RelationData::rd_rel, RelationData::rd_smgr, RelationCacheInsert, RelationGetRelid, RelationIncrementReferenceCount(), RelationInitLockInfo(), RelationInitPhysicalAddr(), RelationInitTableAccessMethod(), RelationMapUpdateMap(), relname, TupleDescData::tdrefcount, TupleDescAttr(), and TupleDescCompactAttr().

Referenced by heap_create().

RelationBuildPublicationDesc()

void RelationBuildPublicationDesc	(	Relation	relation,
		struct PublicationDesc *	pubdesc
	)

Definition at line 5791 of file relcache.c.

{
    List       *puboids;
    ListCell   *lc;
    MemoryContext oldcxt;
    Oid         schemaid;
    List       *ancestors = NIL;
    Oid         relid = RelationGetRelid(relation);
 
    /*
     * If not publishable, it publishes no actions.  (pgoutput_change() will
     * ignore it.)
     */
    if (!is_publishable_relation(relation))
    {
        memset(pubdesc, 0, sizeof(PublicationDesc));
        pubdesc->rf_valid_for_update = true;
        pubdesc->rf_valid_for_delete = true;
        pubdesc->cols_valid_for_update = true;
        pubdesc->cols_valid_for_delete = true;
        pubdesc->gencols_valid_for_update = true;
        pubdesc->gencols_valid_for_delete = true;
        return;
    }
 
    if (relation->rd_pubdesc)
    {
        memcpy(pubdesc, relation->rd_pubdesc, sizeof(PublicationDesc));
        return;
    }
 
    memset(pubdesc, 0, sizeof(PublicationDesc));
    pubdesc->rf_valid_for_update = true;
    pubdesc->rf_valid_for_delete = true;
    pubdesc->cols_valid_for_update = true;
    pubdesc->cols_valid_for_delete = true;
    pubdesc->gencols_valid_for_update = true;
    pubdesc->gencols_valid_for_delete = true;
 
    /* Fetch the publication membership info. */
    puboids = GetRelationPublications(relid);
    schemaid = RelationGetNamespace(relation);
    puboids = list_concat_unique_oid(puboids, GetSchemaPublications(schemaid));
 
    if (relation->rd_rel->relispartition)
    {
        /* Add publications that the ancestors are in too. */
        ancestors = get_partition_ancestors(relid);
 
        foreach(lc, ancestors)
        {
            Oid         ancestor = lfirst_oid(lc);
 
            puboids = list_concat_unique_oid(puboids,
                                             GetRelationPublications(ancestor));
            schemaid = get_rel_namespace(ancestor);
            puboids = list_concat_unique_oid(puboids,
                                             GetSchemaPublications(schemaid));
        }
    }
    puboids = list_concat_unique_oid(puboids, GetAllTablesPublications());
 
    foreach(lc, puboids)
    {
        Oid         pubid = lfirst_oid(lc);
        HeapTuple   tup;
        Form_pg_publication pubform;
        bool        invalid_column_list;
        bool        invalid_gen_col;
 
        tup = SearchSysCache1(PUBLICATIONOID, ObjectIdGetDatum(pubid));
 
        if (!HeapTupleIsValid(tup))
            elog(ERROR, "cache lookup failed for publication %u", pubid);
 
        pubform = (Form_pg_publication) GETSTRUCT(tup);
 
        pubdesc->pubactions.pubinsert |= pubform->pubinsert;
        pubdesc->pubactions.pubupdate |= pubform->pubupdate;
        pubdesc->pubactions.pubdelete |= pubform->pubdelete;
        pubdesc->pubactions.pubtruncate |= pubform->pubtruncate;
 
        /*
         * Check if all columns referenced in the filter expression are part
         * of the REPLICA IDENTITY index or not.
         *
         * If the publication is FOR ALL TABLES then it means the table has no
         * row filters and we can skip the validation.
         */
        if (!pubform->puballtables &&
            (pubform->pubupdate || pubform->pubdelete) &&
            pub_rf_contains_invalid_column(pubid, relation, ancestors,
                                           pubform->pubviaroot))
        {
            if (pubform->pubupdate)
                pubdesc->rf_valid_for_update = false;
            if (pubform->pubdelete)
                pubdesc->rf_valid_for_delete = false;
        }
 
        /*
         * Check if all columns are part of the REPLICA IDENTITY index or not.
         *
         * Check if all generated columns included in the REPLICA IDENTITY are
         * published.
         */
        if ((pubform->pubupdate || pubform->pubdelete) &&
            pub_contains_invalid_column(pubid, relation, ancestors,
                                        pubform->pubviaroot,
                                        pubform->pubgencols,
                                        &invalid_column_list,
                                        &invalid_gen_col))
        {
            if (pubform->pubupdate)
            {
                pubdesc->cols_valid_for_update = !invalid_column_list;
                pubdesc->gencols_valid_for_update = !invalid_gen_col;
            }
 
            if (pubform->pubdelete)
            {
                pubdesc->cols_valid_for_delete = !invalid_column_list;
                pubdesc->gencols_valid_for_delete = !invalid_gen_col;
            }
        }
 
        ReleaseSysCache(tup);
 
        /*
         * If we know everything is replicated and the row filter is invalid
         * for update and delete, there is no point to check for other
         * publications.
         */
        if (pubdesc->pubactions.pubinsert && pubdesc->pubactions.pubupdate &&
            pubdesc->pubactions.pubdelete && pubdesc->pubactions.pubtruncate &&
            !pubdesc->rf_valid_for_update && !pubdesc->rf_valid_for_delete)
            break;
 
        /*
         * If we know everything is replicated and the column list is invalid
         * for update and delete, there is no point to check for other
         * publications.
         */
        if (pubdesc->pubactions.pubinsert && pubdesc->pubactions.pubupdate &&
            pubdesc->pubactions.pubdelete && pubdesc->pubactions.pubtruncate &&
            !pubdesc->cols_valid_for_update && !pubdesc->cols_valid_for_delete)
            break;
 
        /*
         * If we know everything is replicated and replica identity has an
         * unpublished generated column, there is no point to check for other
         * publications.
         */
        if (pubdesc->pubactions.pubinsert && pubdesc->pubactions.pubupdate &&
            pubdesc->pubactions.pubdelete && pubdesc->pubactions.pubtruncate &&
            !pubdesc->gencols_valid_for_update &&
            !pubdesc->gencols_valid_for_delete)
            break;
    }
 
    if (relation->rd_pubdesc)
    {
        pfree(relation->rd_pubdesc);
        relation->rd_pubdesc = NULL;
    }
 
    /* Now save copy of the descriptor in the relcache entry. */
    oldcxt = MemoryContextSwitchTo(CacheMemoryContext);
    relation->rd_pubdesc = palloc(sizeof(PublicationDesc));
    memcpy(relation->rd_pubdesc, pubdesc, sizeof(PublicationDesc));
    MemoryContextSwitchTo(oldcxt);
}

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

Referenced by CheckCmdReplicaIdentity().

RelationCacheInitFilePostInvalidate()

void RelationCacheInitFilePostInvalidate

(

void

)

Definition at line 6882 of file relcache.c.

{
    LWLockRelease(RelCacheInitLock);
}

References LWLockRelease().

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

RelationCacheInitFilePreInvalidate()

void RelationCacheInitFilePreInvalidate

(

void

)

Definition at line 6857 of file relcache.c.

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

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

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

RelationCacheInitFileRemove()

void RelationCacheInitFileRemove

(

void

)

Definition at line 6897 of file relcache.c.

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

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

Referenced by StartupXLOG().

RelationCacheInitialize()

void RelationCacheInitialize

(

void

)

Definition at line 4002 of file relcache.c.

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

References CacheMemoryContext, CreateCacheMemoryContext(), ctl, HASH_BLOBS, hash_create(), HASH_ELEM, in_progress_list, in_progress_list_maxlen, INITRELCACHESIZE, MemoryContextAlloc(), RelationIdCache, and RelationMapInitialize().

Referenced by InitPostgres().

RelationCacheInitializePhase2()

void RelationCacheInitializePhase2

(

void

)

Definition at line 4048 of file relcache.c.

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

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

Referenced by InitPostgres().

RelationCacheInitializePhase3()

void RelationCacheInitializePhase3

(

void

)

Definition at line 4107 of file relcache.c.

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

References Assert(), CacheMemoryContext, CLASS_TUPLE_SIZE, criticalRelcachesBuilt, criticalSharedRelcachesBuilt, Desc_pg_attribute, Desc_pg_class, Desc_pg_proc, Desc_pg_type, elog, ereport, errcode(), errmsg_internal(), ERROR, FATAL, formrdesc(), GETSTRUCT(), hash_seq_init(), hash_seq_search(), hash_seq_term(), HeapTupleIsValid, InitCatalogCachePhase2(), InvalidOid, IsBootstrapProcessingMode, load_critical_index(), load_relcache_init_file(), MemoryContextSwitchTo(), ObjectIdGetDatum(), pfree(), RelationData::rd_att, RelationData::rd_options, RelationData::rd_rel, RelationData::rd_rsdesc, RelationData::rd_rules, RelationData::rd_tableam, RelationBuildRowSecurity(), RelationBuildRuleLock(), RelationBuildTriggers(), RelationDecrementReferenceCount(), RelationGetRelationName, RelationGetRelid, RelationIdCache, RelationIncrementReferenceCount(), RelationInitTableAccessMethod(), RelationMapInitializePhase3(), RelationParseRelOptions(), relidcacheent::reldesc, ReleaseSysCache(), SearchSysCache1(), TupleDescData::tdtypeid, TupleDescData::tdtypmod, RelationData::trigdesc, and write_relcache_init_file().

Referenced by InitPostgres().

RelationCacheInvalidate()

void RelationCacheInvalidate

(

bool

debug_discard

)

Definition at line 2994 of file relcache.c.

{
    HASH_SEQ_STATUS status;
    RelIdCacheEnt *idhentry;
    Relation    relation;
    List       *rebuildFirstList = NIL;
    List       *rebuildList = NIL;
    ListCell   *l;
    int         i;
 
    /*
     * Reload relation mapping data before starting to reconstruct cache.
     */
    RelationMapInvalidateAll();
 
    /* Phase 1 */
    hash_seq_init(&status, RelationIdCache);
 
    while ((idhentry = (RelIdCacheEnt *) hash_seq_search(&status)) != NULL)
    {
        relation = idhentry->reldesc;
 
        /*
         * Ignore new relations; no other backend will manipulate them before
         * we commit.  Likewise, before replacing a relation's relfilelocator,
         * we shall have acquired AccessExclusiveLock and drained any
         * applicable pending invalidations.
         */
        if (relation->rd_createSubid != InvalidSubTransactionId ||
            relation->rd_firstRelfilelocatorSubid != InvalidSubTransactionId)
            continue;
 
        relcacheInvalsReceived++;
 
        if (RelationHasReferenceCountZero(relation))
        {
            /* Delete this entry immediately */
            RelationClearRelation(relation);
        }
        else
        {
            /*
             * If it's a mapped relation, immediately update its rd_locator in
             * case its relfilenumber 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))
            {
                RelationCloseSmgr(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);
        }
    }
 
    /*
     * We cannot destroy the SMgrRelations as there might still be references
     * to them, but close the underlying file descriptors.
     */
    smgrreleaseall();
 
    /*
     * Phase 2: rebuild (or invalidate) the items found to need rebuild in
     * phase 1
     */
    foreach(l, rebuildFirstList)
    {
        relation = (Relation) lfirst(l);
        if (!IsTransactionState() || (relation->rd_isnailed && relation->rd_refcnt == 1))
            RelationInvalidateRelation(relation);
        else
            RelationRebuildRelation(relation);
    }
    list_free(rebuildFirstList);
    foreach(l, rebuildList)
    {
        relation = (Relation) lfirst(l);
        if (!IsTransactionState() || (relation->rd_isnailed && relation->rd_refcnt == 1))
            RelationInvalidateRelation(relation);
        else
            RelationRebuildRelation(relation);
    }
    list_free(rebuildList);
 
    if (!debug_discard)
        /* Any RelationBuildDesc() on the stack must start over. */
        for (i = 0; i < in_progress_list_len; i++)
            in_progress_list[i].invalidated = true;
}

References hash_seq_init(), hash_seq_search(), i, in_progress_list, in_progress_list_len, InvalidSubTransactionId, IsTransactionState(), lappend(), lcons(), lfirst, list_free(), NIL, RelationData::rd_createSubid, RelationData::rd_firstRelfilelocatorSubid, RelationData::rd_isnailed, RelationData::rd_refcnt, RelationClearRelation(), RelationCloseSmgr(), RelationGetRelid, RelationHasReferenceCountZero, RelationIdCache, RelationInitPhysicalAddr(), RelationInvalidateRelation(), RelationIsMapped, RelationMapInvalidateAll(), RelationRebuildRelation(), relcacheInvalsReceived, relidcacheent::reldesc, and smgrreleaseall().

Referenced by InvalidateSystemCachesExtended(), and LocalExecuteInvalidationMessage().

RelationCacheInvalidateEntry()

void RelationCacheInvalidateEntry

(

Oid

relationId

)

Definition at line 2938 of file relcache.c.

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

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

Referenced by LocalExecuteInvalidationMessage().

RelationClose()

void RelationClose

(

Relation

relation

)

Definition at line 2220 of file relcache.c.

{
    /* Note: no locking manipulations needed */
    RelationDecrementReferenceCount(relation);
 
    RelationCloseCleanup(relation);
}

References RelationCloseCleanup(), and RelationDecrementReferenceCount().

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

RelationForgetRelation()

void RelationForgetRelation

(

Oid

rid

)

Definition at line 2893 of file relcache.c.

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

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

Referenced by heap_drop_with_catalog(), and index_drop().

RelationGetDummyIndexExpressions()

List * RelationGetDummyIndexExpressions

(

Relation

relation

)

Definition at line 5153 of file relcache.c.

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

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

Referenced by BuildDummyIndexInfo().

RelationGetExclusionInfo()

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

Definition at line 5650 of file relcache.c.

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

References AccessShareLock, ARR_DATA_PTR, ARR_DIMS, ARR_ELEMTYPE, ARR_HASNULL, ARR_NDIM, BTEqualStrategyNumber, DatumGetArrayTypeP, elog, ERROR, fastgetattr(), get_op_opfamily_strategy(), get_opcode(), GETSTRUCT(), HeapTupleIsValid, i, IndexRelationGetNumberOfKeyAttributes, InvalidStrategy, MemoryContextSwitchTo(), ObjectIdGetDatum(), palloc(), RelationData::rd_att, RelationData::rd_exclops, RelationData::rd_exclprocs, RelationData::rd_exclstrats, RelationData::rd_index, RelationData::rd_indexcxt, RelationData::rd_opfamily, RelationGetRelationName, RelationGetRelid, ScanKeyInit(), systable_beginscan(), systable_endscan(), systable_getnext(), table_close(), table_open(), and val.

Referenced by BuildIndexInfo(), and CheckIndexCompatible().

RelationGetFKeyList()

List * RelationGetFKeyList

(

Relation

relation

)

Definition at line 4728 of file relcache.c.

{
    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;
 
    /*
     * 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 = table_open(ConstraintRelationId, AccessShareLock);
    conscan = systable_beginscan(conrel, ConstraintRelidTypidNameIndexId, true,
                                 NULL, 1, &skey);
 
    while (HeapTupleIsValid(htup = systable_getnext(conscan)))
    {
        Form_pg_constraint constraint = (Form_pg_constraint) GETSTRUCT(htup);
        ForeignKeyCacheInfo *info;
 
        /* consider only foreign keys */
        if (constraint->contype != CONSTRAINT_FOREIGN)
            continue;
 
        info = makeNode(ForeignKeyCacheInfo);
        info->conoid = constraint->oid;
        info->conrelid = constraint->conrelid;
        info->confrelid = constraint->confrelid;
        info->conenforced = constraint->conenforced;
 
        DeconstructFkConstraintRow(htup, &info->nkeys,
                                   info->conkey,
                                   info->confkey,
                                   info->conpfeqop,
                                   NULL, NULL, NULL, NULL);
 
        /* Add FK's node to the result list */
        result = lappend(result, info);
    }
 
    systable_endscan(conscan);
    table_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;
}

References AccessShareLock, BTEqualStrategyNumber, CacheMemoryContext, ForeignKeyCacheInfo::conenforced, ForeignKeyCacheInfo::confrelid, ForeignKeyCacheInfo::conoid, ForeignKeyCacheInfo::conrelid, copyObject, DeconstructFkConstraintRow(), GETSTRUCT(), HeapTupleIsValid, lappend(), list_free_deep(), makeNode, MemoryContextSwitchTo(), NIL, ForeignKeyCacheInfo::nkeys, ObjectIdGetDatum(), RelationData::rd_fkeylist, RelationData::rd_fkeyvalid, RelationGetRelid, ScanKeyInit(), systable_beginscan(), systable_endscan(), systable_getnext(), table_close(), and table_open().

Referenced by addFkRecurseReferencing(), CloneFkReferencing(), DetachPartitionFinalize(), and get_relation_foreign_keys().

RelationGetIdentityKeyBitmap()

Bitmapset * RelationGetIdentityKeyBitmap

(

Relation

relation

)

Definition at line 5573 of file relcache.c.

{
    Bitmapset  *idindexattrs = NULL;    /* columns in the replica identity */
    Relation    indexDesc;
    int         i;
    Oid         replidindex;
    MemoryContext oldcxt;
 
    /* Quick exit if we already computed the result */
    if (relation->rd_idattr != NULL)
        return bms_copy(relation->rd_idattr);
 
    /* Fast path if definitely no indexes */
    if (!RelationGetForm(relation)->relhasindex)
        return NULL;
 
    /* Historic snapshot must be set. */
    Assert(HistoricSnapshotActive());
 
    replidindex = RelationGetReplicaIndex(relation);
 
    /* Fall out if there is no replica identity index */
    if (!OidIsValid(replidindex))
        return NULL;
 
    /* Look up the description for the replica identity index */
    indexDesc = RelationIdGetRelation(replidindex);
 
    if (!RelationIsValid(indexDesc))
        elog(ERROR, "could not open relation with OID %u",
             relation->rd_replidindex);
 
    /* Add referenced attributes to idindexattrs */
    for (i = 0; i < indexDesc->rd_index->indnatts; i++)
    {
        int         attrnum = indexDesc->rd_index->indkey.values[i];
 
        /*
         * We don't include non-key columns into idindexattrs bitmaps. See
         * RelationGetIndexAttrBitmap.
         */
        if (attrnum != 0)
        {
            if (i < indexDesc->rd_index->indnkeyatts)
                idindexattrs = bms_add_member(idindexattrs,
                                              attrnum - FirstLowInvalidHeapAttributeNumber);
        }
    }
 
    RelationClose(indexDesc);
 
    /* Don't leak the old values of these bitmaps, if any */
    bms_free(relation->rd_idattr);
    relation->rd_idattr = NULL;
 
    /* Now save copy of the bitmap in the relcache entry */
    oldcxt = MemoryContextSwitchTo(CacheMemoryContext);
    relation->rd_idattr = bms_copy(idindexattrs);
    MemoryContextSwitchTo(oldcxt);
 
    /* We return our original working copy for caller to play with */
    return idindexattrs;
}

References Assert(), bms_add_member(), bms_copy(), bms_free(), CacheMemoryContext, elog, ERROR, FirstLowInvalidHeapAttributeNumber, HistoricSnapshotActive(), i, MemoryContextSwitchTo(), OidIsValid, RelationData::rd_idattr, RelationData::rd_index, RelationData::rd_replidindex, RelationClose(), RelationGetForm, RelationGetReplicaIndex(), RelationIdGetRelation(), and RelationIsValid.

Referenced by logicalrep_write_attrs().

RelationGetIndexAttOptions()

bytea ** RelationGetIndexAttOptions	(	Relation	relation,
		bool	copy
	)

Definition at line 5985 of file relcache.c.

{
    MemoryContext oldcxt;
    bytea     **opts = relation->rd_opcoptions;
    Oid         relid = RelationGetRelid(relation);
    int         natts = RelationGetNumberOfAttributes(relation);    /* XXX
                                                                     * IndexRelationGetNumberOfKeyAttributes */
    int         i;
 
    /* Try to copy cached options. */
    if (opts)
        return copy ? CopyIndexAttOptions(opts, natts) : opts;
 
    /* Get and parse opclass options. */
    opts = palloc0(sizeof(*opts) * natts);
 
    for (i = 0; i < natts; i++)
    {
        if (criticalRelcachesBuilt && relid != AttributeRelidNumIndexId)
        {
            Datum       attoptions = get_attoptions(relid, i + 1);
 
            opts[i] = index_opclass_options(relation, i + 1, attoptions, false);
 
            if (attoptions != (Datum) 0)
                pfree(DatumGetPointer(attoptions));
        }
    }
 
    /* Copy parsed options to the cache. */
    oldcxt = MemoryContextSwitchTo(relation->rd_indexcxt);
    relation->rd_opcoptions = CopyIndexAttOptions(opts, natts);
    MemoryContextSwitchTo(oldcxt);
 
    if (copy)
        return opts;
 
    for (i = 0; i < natts; i++)
    {
        if (opts[i])
            pfree(opts[i]);
    }
 
    pfree(opts);
 
    return relation->rd_opcoptions;
}

References CopyIndexAttOptions(), criticalRelcachesBuilt, DatumGetPointer(), get_attoptions(), i, index_opclass_options(), MemoryContextSwitchTo(), opts, palloc0(), pfree(), RelationData::rd_indexcxt, RelationData::rd_opcoptions, RelationGetNumberOfAttributes, and RelationGetRelid.

Referenced by get_relation_info(), index_getprocinfo(), load_critical_index(), and RelationInitIndexAccessInfo().

RelationGetIndexAttrBitmap()

Bitmapset * RelationGetIndexAttrBitmap	(	Relation	relation,
		IndexAttrBitmapKind	attrKind
	)

Definition at line 5300 of file relcache.c.

{
    Bitmapset  *uindexattrs;    /* columns in unique indexes */
    Bitmapset  *pkindexattrs;   /* columns in the primary index */
    Bitmapset  *idindexattrs;   /* columns in the replica identity */
    Bitmapset  *hotblockingattrs;   /* columns with HOT blocking indexes */
    Bitmapset  *summarizedattrs;    /* columns with summarizing indexes */
    List       *indexoidlist;
    List       *newindexoidlist;
    Oid         relpkindex;
    Oid         relreplindex;
    ListCell   *l;
    MemoryContext oldcxt;
 
    /* Quick exit if we already computed the result. */
    if (relation->rd_attrsvalid)
    {
        switch (attrKind)
        {
            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);
            case INDEX_ATTR_BITMAP_HOT_BLOCKING:
                return bms_copy(relation->rd_hotblockingattr);
            case INDEX_ATTR_BITMAP_SUMMARIZED:
                return bms_copy(relation->rd_summarizedattr);
            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.
     */
    uindexattrs = NULL;
    pkindexattrs = NULL;
    idindexattrs = NULL;
    hotblockingattrs = NULL;
    summarizedattrs = NULL;
    foreach(l, indexoidlist)
    {
        Oid         indexOid = lfirst_oid(l);
        Relation    indexDesc;
        Datum       datum;
        bool        isnull;
        Node       *indexExpressions;
        Node       *indexPredicate;
        int         i;
        bool        isKey;      /* candidate key */
        bool        isPK;       /* primary key */
        bool        isIDKey;    /* replica identity index */
        Bitmapset **attrs;
 
        indexDesc = index_open(indexOid, AccessShareLock);
 
        /*
         * Extract index expressions and index predicate.  Note: Don't use
         * RelationGetIndexExpressions()/RelationGetIndexPredicate(), because
         * those might run constant expressions evaluation, which needs a
         * snapshot, which we might not have here.  (Also, it's probably more
         * sound to collect the bitmaps before any transformations that might
         * eliminate columns, but the practical impact of this is limited.)
         */
 
        datum = heap_getattr(indexDesc->rd_indextuple, Anum_pg_index_indexprs,
                             GetPgIndexDescriptor(), &isnull);
        if (!isnull)
            indexExpressions = stringToNode(TextDatumGetCString(datum));
        else
            indexExpressions = NULL;
 
        datum = heap_getattr(indexDesc->rd_indextuple, Anum_pg_index_indpred,
                             GetPgIndexDescriptor(), &isnull);
        if (!isnull)
            indexPredicate = stringToNode(TextDatumGetCString(datum));
        else
            indexPredicate = NULL;
 
        /* Can this index be referenced by a foreign key? */
        isKey = indexDesc->rd_index->indisunique &&
            indexExpressions == NULL &&
            indexPredicate == NULL;
 
        /* Is this a primary key? */
        isPK = (indexOid == relpkindex);
 
        /* Is this index the configured (or default) replica identity? */
        isIDKey = (indexOid == relreplindex);
 
        /*
         * If the index is summarizing, it doesn't block HOT updates, but we
         * may still need to update it (if the attributes were modified). So
         * decide which bitmap we'll update in the following loop.
         */
        if (indexDesc->rd_indam->amsummarizing)
            attrs = &summarizedattrs;
        else
            attrs = &hotblockingattrs;
 
        /* Collect simple attribute references */
        for (i = 0; i < indexDesc->rd_index->indnatts; i++)
        {
            int         attrnum = indexDesc->rd_index->indkey.values[i];
 
            /*
             * Since we have covering indexes with non-key columns, we must
             * handle them accurately here. non-key columns must be added into
             * hotblockingattrs or summarizedattrs, since they are in index,
             * and update shouldn't miss them.
             *
             * Summarizing indexes do not block HOT, but do need to be updated
             * when the column value changes, thus require a separate
             * attribute bitmapset.
             *
             * Obviously, non-key columns couldn't be referenced by foreign
             * key or identity key. Hence we do not include them into
             * uindexattrs, pkindexattrs and idindexattrs bitmaps.
             */
            if (attrnum != 0)
            {
                *attrs = bms_add_member(*attrs,
                                        attrnum - FirstLowInvalidHeapAttributeNumber);
 
                if (isKey && i < indexDesc->rd_index->indnkeyatts)
                    uindexattrs = bms_add_member(uindexattrs,
                                                 attrnum - FirstLowInvalidHeapAttributeNumber);
 
                if (isPK && i < indexDesc->rd_index->indnkeyatts)
                    pkindexattrs = bms_add_member(pkindexattrs,
                                                  attrnum - FirstLowInvalidHeapAttributeNumber);
 
                if (isIDKey && i < indexDesc->rd_index->indnkeyatts)
                    idindexattrs = bms_add_member(idindexattrs,
                                                  attrnum - FirstLowInvalidHeapAttributeNumber);
            }
        }
 
        /* Collect all attributes used in expressions, too */
        pull_varattnos(indexExpressions, 1, attrs);
 
        /* Collect all attributes in the index predicate, too */
        pull_varattnos(indexPredicate, 1, attrs);
 
        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(hotblockingattrs);
        bms_free(summarizedattrs);
 
        goto restart;
    }
 
    /* Don't leak the old values of these bitmaps, if any */
    relation->rd_attrsvalid = false;
    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;
    bms_free(relation->rd_hotblockingattr);
    relation->rd_hotblockingattr = NULL;
    bms_free(relation->rd_summarizedattr);
    relation->rd_summarizedattr = NULL;
 
    /*
     * Now save copies of the bitmaps in the relcache entry.  We intentionally
     * set rd_attrsvalid 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_hotblockingattr = bms_copy(hotblockingattrs);
    relation->rd_summarizedattr = bms_copy(summarizedattrs);
    relation->rd_attrsvalid = true;
    MemoryContextSwitchTo(oldcxt);
 
    /* We return our original working copy for caller to play with */
    switch (attrKind)
    {
        case INDEX_ATTR_BITMAP_KEY:
            return uindexattrs;
        case INDEX_ATTR_BITMAP_PRIMARY_KEY:
            return pkindexattrs;
        case INDEX_ATTR_BITMAP_IDENTITY_KEY:
            return idindexattrs;
        case INDEX_ATTR_BITMAP_HOT_BLOCKING:
            return hotblockingattrs;
        case INDEX_ATTR_BITMAP_SUMMARIZED:
            return summarizedattrs;
        default:
            elog(ERROR, "unknown attrKind %u", attrKind);
            return NULL;
    }
}

References AccessShareLock, IndexAmRoutine::amsummarizing, bms_add_member(), bms_copy(), bms_free(), CacheMemoryContext, elog, equal(), ERROR, FirstLowInvalidHeapAttributeNumber, GetPgIndexDescriptor(), heap_getattr(), i, INDEX_ATTR_BITMAP_HOT_BLOCKING, INDEX_ATTR_BITMAP_IDENTITY_KEY, INDEX_ATTR_BITMAP_KEY, INDEX_ATTR_BITMAP_PRIMARY_KEY, INDEX_ATTR_BITMAP_SUMMARIZED, index_close(), index_open(), lfirst_oid, list_free(), MemoryContextSwitchTo(), NIL, pull_varattnos(), RelationData::rd_attrsvalid, RelationData::rd_hotblockingattr, RelationData::rd_idattr, RelationData::rd_indam, RelationData::rd_index, RelationData::rd_indextuple, RelationData::rd_keyattr, RelationData::rd_pkattr, RelationData::rd_pkindex, RelationData::rd_replidindex, RelationData::rd_summarizedattr, RelationGetForm, RelationGetIndexList(), stringToNode(), and TextDatumGetCString.

Referenced by dropconstraint_internal(), ExecUpdateLockMode(), ExtractReplicaIdentity(), GetParentedForeignKeyRefs(), heap_update(), logicalrep_rel_mark_updatable(), pub_contains_invalid_column(), and pub_rf_contains_invalid_column().

RelationGetIndexExpressions()

List * RelationGetIndexExpressions

(

Relation

relation

)

Definition at line 5094 of file relcache.c.

{
    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, NULL))
        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 must not use canonicalize_qual, however,
     * since these aren't qual expressions.
     */
    result = (List *) eval_const_expressions(NULL, (Node *) 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;
}

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

Referenced by ATExecReplicaIdentity(), BuildIndexInfo(), get_attr_expr(), get_relation_info(), GetIndexInputType(), index_unchanged_by_update(), infer_arbiter_indexes(), plan_create_index_workers(), ReindexRelationConcurrently(), and transformIndexConstraint().

RelationGetIndexList()

List * RelationGetIndexList

(

Relation

relation

)

Definition at line 4833 of file relcache.c.

{
    Relation    indrel;
    SysScanDesc indscan;
    ScanKeyData skey;
    HeapTuple   htup;
    List       *result;
    List       *oldlist;
    char        replident = relation->rd_rel->relreplident;
    Oid         pkeyIndex = InvalidOid;
    Oid         candidateIndex = InvalidOid;
    bool        pkdeferrable = false;
    MemoryContext oldcxt;
 
    /* Quick exit if we already computed the list. */
    if (relation->rd_indexvalid)
        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;
 
    /* Prepare to scan pg_index for entries having indrelid = this rel. */
    ScanKeyInit(&skey,
                Anum_pg_index_indrelid,
                BTEqualStrategyNumber, F_OIDEQ,
                ObjectIdGetDatum(RelationGetRelid(relation)));
 
    indrel = table_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);
 
        /*
         * 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 (!index->indislive)
            continue;
 
        /* add index's OID to result list */
        result = lappend_oid(result, index->indexrelid);
 
        /*
         * Non-unique or predicate indexes aren't interesting for either oid
         * indexes or replication identity indexes, so don't check them.
         * Deferred ones are not useful for replication identity either; but
         * we do include them if they are PKs.
         */
        if (!index->indisunique ||
            !heap_attisnull(htup, Anum_pg_index_indpred, NULL))
            continue;
 
        /*
         * Remember primary key index, if any.  For regular tables we do this
         * only if the index is valid; but for partitioned tables, then we do
         * it even if it's invalid.
         *
         * The reason for returning invalid primary keys for partitioned
         * tables is that we need it to prevent drop of not-null constraints
         * that may underlie such a primary key, which is only a problem for
         * partitioned tables.
         */
        if (index->indisprimary &&
            (index->indisvalid ||
             relation->rd_rel->relkind == RELKIND_PARTITIONED_TABLE))
        {
            pkeyIndex = index->indexrelid;
            pkdeferrable = !index->indimmediate;
        }
 
        if (!index->indimmediate)
            continue;
 
        if (!index->indisvalid)
            continue;
 
        /* remember explicitly chosen replica index */
        if (index->indisreplident)
            candidateIndex = index->indexrelid;
    }
 
    systable_endscan(indscan);
 
    table_close(indrel, AccessShareLock);
 
    /* Sort the result list into OID order, per API spec. */
    list_sort(result, list_oid_cmp);
 
    /* 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_pkindex = pkeyIndex;
    relation->rd_ispkdeferrable = pkdeferrable;
    if (replident == REPLICA_IDENTITY_DEFAULT && OidIsValid(pkeyIndex) && !pkdeferrable)
        relation->rd_replidindex = pkeyIndex;
    else if (replident == REPLICA_IDENTITY_INDEX && OidIsValid(candidateIndex))
        relation->rd_replidindex = candidateIndex;
    else
        relation->rd_replidindex = InvalidOid;
    relation->rd_indexvalid = true;
    MemoryContextSwitchTo(oldcxt);
 
    /* Don't leak the old list, if there is one */
    list_free(oldlist);
 
    return result;
}

References AccessShareLock, BTEqualStrategyNumber, CacheMemoryContext, GETSTRUCT(), heap_attisnull(), HeapTupleIsValid, InvalidOid, lappend_oid(), list_copy(), list_free(), list_oid_cmp(), list_sort(), MemoryContextSwitchTo(), NIL, ObjectIdGetDatum(), OidIsValid, RelationData::rd_indexlist, RelationData::rd_indexvalid, RelationData::rd_ispkdeferrable, RelationData::rd_pkindex, RelationData::rd_rel, RelationData::rd_replidindex, RelationGetRelid, ScanKeyInit(), systable_beginscan(), systable_endscan(), systable_getnext(), table_close(), and table_open().

Referenced by AlterIndexNamespaces(), apply_handle_delete_internal(), apply_handle_insert_internal(), ATExecChangeOwner(), ATExecSetTableSpace(), AttachPartitionEnsureIndexes(), calculate_indexes_size(), calculate_toast_table_size(), cluster(), DefineIndex(), DefineRelation(), DetachPartitionFinalize(), do_analyze_rel(), ExecInitPartitionInfo(), ExecOpenIndices(), expandTableLikeClause(), FindUsableIndexForReplicaIdentityFull(), get_relation_info(), GetParentedForeignKeyRefs(), index_get_partition(), infer_arbiter_indexes(), mark_index_clustered(), refresh_by_match_merge(), RefreshMatViewByOid(), reindex_relation(), ReindexRelationConcurrently(), relation_mark_replica_identity(), RelationGetIndexAttrBitmap(), RelationGetPrimaryKeyIndex(), RelationGetReplicaIndex(), relationHasPrimaryKey(), RelationTruncateIndexes(), SetIndexStorageProperties(), toast_open_indexes(), transformFkeyCheckAttrs(), transformFkeyGetPrimaryKey(), triggered_change_notification(), and vac_open_indexes().

RelationGetIndexPredicate()

List * RelationGetIndexPredicate

(

Relation

relation

)

Definition at line 5207 of file relcache.c.

{
    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, NULL))
        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, false);
 
    /* 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;
}

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

Referenced by ATExecReplicaIdentity(), BuildIndexInfo(), get_relation_info(), infer_arbiter_indexes(), is_usable_unique_index(), plan_create_index_workers(), ReindexRelationConcurrently(), and transformIndexConstraint().

RelationGetPrimaryKeyIndex()

Oid RelationGetPrimaryKeyIndex	(	Relation	relation,
		bool	deferrable_ok
	)

Definition at line 5044 of file relcache.c.

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

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

Referenced by dropconstraint_internal(), and GetRelationIdentityOrPK().

RelationGetReplicaIndex()

Oid RelationGetReplicaIndex

(

Relation

relation

)

Definition at line 5069 of file relcache.c.

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

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

Referenced by CheckCmdReplicaIdentity(), GetRelationIdentityOrPK(), pg_get_replica_identity_index(), and RelationGetIdentityKeyBitmap().

RelationGetStatExtList()

List * RelationGetStatExtList

(

Relation

relation

)

Definition at line 4974 of file relcache.c.

{
    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 = table_open(StatisticExtRelationId, AccessShareLock);
    indscan = systable_beginscan(indrel, StatisticExtRelidIndexId, true,
                                 NULL, 1, &skey);
 
    while (HeapTupleIsValid(htup = systable_getnext(indscan)))
    {
        Oid         oid = ((Form_pg_statistic_ext) GETSTRUCT(htup))->oid;
 
        result = lappend_oid(result, oid);
    }
 
    systable_endscan(indscan);
 
    table_close(indrel, AccessShareLock);
 
    /* Sort the result list into OID order, per API spec. */
    list_sort(result, list_oid_cmp);
 
    /* 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;
}

References AccessShareLock, BTEqualStrategyNumber, CacheMemoryContext, GETSTRUCT(), HeapTupleIsValid, lappend_oid(), list_copy(), list_free(), list_oid_cmp(), list_sort(), MemoryContextSwitchTo(), NIL, ObjectIdGetDatum(), RelationData::rd_statlist, RelationData::rd_statvalid, RelationGetRelid, ScanKeyInit(), systable_beginscan(), systable_endscan(), systable_getnext(), table_close(), and table_open().

Referenced by expandTableLikeClause(), and get_relation_statistics().

RelationIdGetRelation()

Relation RelationIdGetRelation

(

Oid

relationId

)

Definition at line 2099 of file relcache.c.

{
    Relation    rd;
 
    AssertCouldGetRelation();
 
    /*
     * first try to find reldesc in the cache
     */
    RelationIdCacheLookup(relationId, rd);
 
    if (RelationIsValid(rd))
    {
        /* return NULL for dropped relations */
        if (rd->rd_droppedSubid != InvalidSubTransactionId)
        {
            Assert(!rd->rd_isvalid);
            return NULL;
        }
 
        RelationIncrementReferenceCount(rd);
        /* revalidate cache entry if necessary */
        if (!rd->rd_isvalid)
        {
            RelationRebuildRelation(rd);
 
            /*
             * Normally entries need to be valid here, but before the relcache
             * has been initialized, not enough infrastructure exists to
             * perform pg_class lookups. The structure of such entries doesn't
             * change, but we still want to update the rd_rel entry. So
             * rd_isvalid = false is left in place for a later lookup.
             */
            Assert(rd->rd_isvalid ||
                   (rd->rd_isnailed && !criticalRelcachesBuilt));
        }
        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;
}

References Assert(), AssertCouldGetRelation(), criticalRelcachesBuilt, InvalidSubTransactionId, RelationData::rd_droppedSubid, RelationData::rd_isnailed, RelationData::rd_isvalid, RelationBuildDesc(), RelationIdCacheLookup, RelationIncrementReferenceCount(), RelationIsValid, and RelationRebuildRelation().

Referenced by check_and_init_gencol(), init_tuple_slot(), maybe_send_schema(), pgoutput_change(), pgoutput_column_list_init(), pgoutput_ensure_entry_cxt(), pgoutput_row_filter_init(), relation_open(), RelationGetIdentityKeyBitmap(), ReorderBufferProcessTXN(), ReorderBufferToastReplace(), and try_relation_open().

RelationIdIsInInitFile()

bool RelationIdIsInInitFile

(

Oid

relationId

)

Definition at line 6817 of file relcache.c.

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

References Assert(), and RelationSupportsSysCache().

Referenced by RegisterRelcacheInvalidation(), and write_relcache_init_file().

RelationInitIndexAccessInfo()

void RelationInitIndexAccessInfo

(

Relation

relation

)

Definition at line 1445 of file relcache.c.

{
    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         indnatts;
    int         indnkeyatts;
    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
     */
    Assert(relation->rd_rel->relam != InvalidOid);
    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);
 
    indnatts = RelationGetNumberOfAttributes(relation);
    if (indnatts != IndexRelationGetNumberOfAttributes(relation))
        elog(ERROR, "relnatts disagrees with indnatts for index %u",
             RelationGetRelid(relation));
    indnkeyatts = IndexRelationGetNumberOfKeyAttributes(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,
                                     "index info",
                                     ALLOCSET_SMALL_SIZES);
    relation->rd_indexcxt = indexcxt;
    MemoryContextCopyAndSetIdentifier(indexcxt,
                                      RelationGetRelationName(relation));
 
    /*
     * Now we can fetch the index AM's API struct
     */
    InitIndexAmRoutine(relation);
 
    /*
     * Allocate arrays to hold data. Opclasses are not used for included
     * columns, so allocate them for indnkeyatts only.
     */
    relation->rd_opfamily = (Oid *)
        MemoryContextAllocZero(indexcxt, indnkeyatts * sizeof(Oid));
    relation->rd_opcintype = (Oid *)
        MemoryContextAllocZero(indexcxt, indnkeyatts * sizeof(Oid));
 
    amsupport = relation->rd_indam->amsupport;
    if (amsupport > 0)
    {
        int         nsupport = indnatts * 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, indnkeyatts * sizeof(Oid));
 
    relation->rd_indoption = (int16 *)
        MemoryContextAllocZero(indexcxt, indnkeyatts * 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, indnkeyatts * 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, indnkeyatts);
 
    /*
     * 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, indnkeyatts * sizeof(int16));
 
    (void) RelationGetIndexAttOptions(relation, false);
 
    /*
     * 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;
}

References ALLOCSET_SMALL_SIZES, AllocSetContextCreate, IndexAmRoutine::amsupport, Assert(), CacheMemoryContext, DatumGetPointer(), elog, ERROR, fastgetattr(), GetPgIndexDescriptor(), GETSTRUCT(), heap_copytuple(), HeapTupleIsValid, IndexRelationGetNumberOfAttributes, IndexRelationGetNumberOfKeyAttributes, IndexSupportInitialize(), InitIndexAmRoutine(), InvalidOid, MemoryContextAllocZero(), MemoryContextCopyAndSetIdentifier, MemoryContextSwitchTo(), NIL, ObjectIdGetDatum(), RelationData::rd_amcache, RelationData::rd_amhandler, RelationData::rd_exclops, RelationData::rd_exclprocs, RelationData::rd_exclstrats, RelationData::rd_indam, 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, RelationGetIndexAttOptions(), RelationGetNumberOfAttributes, RelationGetRelationName, RelationGetRelid, ReleaseSysCache(), SearchSysCache1(), int2vector::values, and oidvector::values.

Referenced by index_create(), and RelationBuildDesc().

RelationInitTableAccessMethod()

void RelationInitTableAccessMethod

(

Relation

relation

)

Definition at line 1829 of file relcache.c.

{
    HeapTuple   tuple;
    Form_pg_am  aform;
 
    if (relation->rd_rel->relkind == RELKIND_SEQUENCE)
    {
        /*
         * Sequences are currently accessed like heap tables, but it doesn't
         * seem prudent to show that in the catalog. So just overwrite it
         * here.
         */
        Assert(relation->rd_rel->relam == InvalidOid);
        relation->rd_amhandler = F_HEAP_TABLEAM_HANDLER;
    }
    else if (IsCatalogRelation(relation))
    {
        /*
         * Avoid doing a syscache lookup for catalog tables.
         */
        Assert(relation->rd_rel->relam == HEAP_TABLE_AM_OID);
        relation->rd_amhandler = F_HEAP_TABLEAM_HANDLER;
    }
    else
    {
        /*
         * Look up the table access method, save the OID of its handler
         * function.
         */
        Assert(relation->rd_rel->relam != InvalidOid);
        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);
    }
 
    /*
     * Now we can fetch the table AM's API struct
     */
    InitTableAmRoutine(relation);
}

References Assert(), elog, ERROR, GETSTRUCT(), HeapTupleIsValid, InitTableAmRoutine(), InvalidOid, IsCatalogRelation(), ObjectIdGetDatum(), RelationData::rd_amhandler, RelationData::rd_rel, ReleaseSysCache(), and SearchSysCache1().

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

RelationSetNewRelfilenumber()

void RelationSetNewRelfilenumber	(	Relation	relation,
		char	persistence
	)

Definition at line 3773 of file relcache.c.

{
    RelFileNumber newrelfilenumber;
    Relation    pg_class;
    ItemPointerData otid;
    HeapTuple   tuple;
    Form_pg_class classform;
    MultiXactId minmulti = InvalidMultiXactId;
    TransactionId freezeXid = InvalidTransactionId;
    RelFileLocator newrlocator;
 
    if (!IsBinaryUpgrade)
    {
        /* Allocate a new relfilenumber */
        newrelfilenumber = GetNewRelFileNumber(relation->rd_rel->reltablespace,
                                               NULL, persistence);
    }
    else if (relation->rd_rel->relkind == RELKIND_INDEX)
    {
        if (!OidIsValid(binary_upgrade_next_index_pg_class_relfilenumber))
            ereport(ERROR,
                    (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                     errmsg("index relfilenumber value not set when in binary upgrade mode")));
 
        newrelfilenumber = binary_upgrade_next_index_pg_class_relfilenumber;
        binary_upgrade_next_index_pg_class_relfilenumber = InvalidOid;
    }
    else if (relation->rd_rel->relkind == RELKIND_RELATION)
    {
        if (!OidIsValid(binary_upgrade_next_heap_pg_class_relfilenumber))
            ereport(ERROR,
                    (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                     errmsg("heap relfilenumber value not set when in binary upgrade mode")));
 
        newrelfilenumber = binary_upgrade_next_heap_pg_class_relfilenumber;
        binary_upgrade_next_heap_pg_class_relfilenumber = InvalidOid;
    }
    else
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                 errmsg("unexpected request for new relfilenumber in binary upgrade mode")));
 
    /*
     * Get a writable copy of the pg_class tuple for the given relation.
     */
    pg_class = table_open(RelationRelationId, RowExclusiveLock);
 
    tuple = SearchSysCacheLockedCopy1(RELOID,
                                      ObjectIdGetDatum(RelationGetRelid(relation)));
    if (!HeapTupleIsValid(tuple))
        elog(ERROR, "could not find tuple for relation %u",
             RelationGetRelid(relation));
    otid = tuple->t_self;
    classform = (Form_pg_class) GETSTRUCT(tuple);
 
    /*
     * Schedule unlinking of the old storage at transaction commit, except
     * when performing a binary upgrade, when we must do it immediately.
     */
    if (IsBinaryUpgrade)
    {
        SMgrRelation srel;
 
        /*
         * During a binary upgrade, we use this code path to ensure that
         * pg_largeobject and its index have the same relfilenumbers as in the
         * old cluster. This is necessary because pg_upgrade treats
         * pg_largeobject like a user table, not a system table. It is however
         * possible that a table or index may need to end up with the same
         * relfilenumber in the new cluster as what it had in the old cluster.
         * Hence, we can't wait until commit time to remove the old storage.
         *
         * In general, this function needs to have transactional semantics,
         * and removing the old storage before commit time surely isn't.
         * However, it doesn't really matter, because if a binary upgrade
         * fails at this stage, the new cluster will need to be recreated
         * anyway.
         */
        srel = smgropen(relation->rd_locator, relation->rd_backend);
        smgrdounlinkall(&srel, 1, false);
        smgrclose(srel);
    }
    else
    {
        /* Not a binary upgrade, so just schedule it to happen later. */
        RelationDropStorage(relation);
    }
 
    /*
     * Create storage for the main fork of the new relfilenumber.  If it's a
     * table-like object, call into the table AM to do so, which'll also
     * create the table's init fork if needed.
     *
     * NOTE: If relevant for the AM, any conflict in relfilenumber value will
     * be caught here, if GetNewRelFileNumber messes up for any reason.
     */
    newrlocator = relation->rd_locator;
    newrlocator.relNumber = newrelfilenumber;
 
    if (RELKIND_HAS_TABLE_AM(relation->rd_rel->relkind))
    {
        table_relation_set_new_filelocator(relation, &newrlocator,
                                           persistence,
                                           &freezeXid, &minmulti);
    }
    else if (RELKIND_HAS_STORAGE(relation->rd_rel->relkind))
    {
        /* handle these directly, at least for now */
        SMgrRelation srel;
 
        srel = RelationCreateStorage(newrlocator, persistence, true);
        smgrclose(srel);
    }
    else
    {
        /* we shouldn't be called for anything else */
        elog(ERROR, "relation \"%s\" does not have storage",
             RelationGetRelationName(relation));
    }
 
    /*
     * 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.
     *
     * For mapped indexes, we don't actually change the pg_class entry at all;
     * this is essential when reindexing pg_class itself.  That leaves us with
     * possibly-inaccurate values of relpages etc, but those will be fixed up
     * later.
     */
    if (RelationIsMapped(relation))
    {
        /* This case is only supported for indexes */
        Assert(relation->rd_rel->relkind == RELKIND_INDEX);
 
        /* Since we're not updating pg_class, these had better not change */
        Assert(classform->relfrozenxid == freezeXid);
        Assert(classform->relminmxid == minmulti);
        Assert(classform->relpersistence == persistence);
 
        /*
         * In some code paths it's possible that the tuple update we'd
         * otherwise do here is the only thing that would assign an XID for
         * the current transaction.  However, we must have an XID to delete
         * files, so make sure one is assigned.
         */
        (void) GetCurrentTransactionId();
 
        /* Do the deed */
        RelationMapUpdateMap(RelationGetRelid(relation),
                             newrelfilenumber,
                             relation->rd_rel->relisshared,
                             false);
 
        /* Since we're not updating pg_class, must trigger inval manually */
        CacheInvalidateRelcache(relation);
    }
    else
    {
        /* Normal case, update the pg_class entry */
        classform->relfilenode = newrelfilenumber;
 
        /* relpages etc. never change for sequences */
        if (relation->rd_rel->relkind != RELKIND_SEQUENCE)
        {
            classform->relpages = 0;    /* it's empty until further notice */
            classform->reltuples = -1;
            classform->relallvisible = 0;
            classform->relallfrozen = 0;
        }
        classform->relfrozenxid = freezeXid;
        classform->relminmxid = minmulti;
        classform->relpersistence = persistence;
 
        CatalogTupleUpdate(pg_class, &otid, tuple);
    }
 
    UnlockTuple(pg_class, &otid, InplaceUpdateTupleLock);
    heap_freetuple(tuple);
 
    table_close(pg_class, RowExclusiveLock);
 
    /*
     * Make the pg_class row change or relation map change visible.  This will
     * cause the relcache entry to get updated, too.
     */
    CommandCounterIncrement();
 
    RelationAssumeNewRelfilelocator(relation);
}

References Assert(), binary_upgrade_next_heap_pg_class_relfilenumber, binary_upgrade_next_index_pg_class_relfilenumber, CacheInvalidateRelcache(), CatalogTupleUpdate(), CommandCounterIncrement(), elog, ereport, errcode(), errmsg(), ERROR, GetCurrentTransactionId(), GetNewRelFileNumber(), GETSTRUCT(), heap_freetuple(), HeapTupleIsValid, InplaceUpdateTupleLock, InvalidMultiXactId, InvalidOid, InvalidTransactionId, IsBinaryUpgrade, ObjectIdGetDatum(), OidIsValid, RelationData::rd_backend, RelationData::rd_locator, RelationData::rd_rel, RelationAssumeNewRelfilelocator(), RelationCreateStorage(), RelationDropStorage(), RelationGetRelationName, RelationGetRelid, RelationIsMapped, RelationMapUpdateMap(), RelFileLocator::relNumber, RowExclusiveLock, SearchSysCacheLockedCopy1(), smgrclose(), smgrdounlinkall(), smgropen(), HeapTupleData::t_self, table_close(), table_open(), table_relation_set_new_filelocator(), and UnlockTuple().

Referenced by AlterSequence(), ExecuteTruncateGuts(), reindex_index(), ResetSequence(), and SequenceChangePersistence().

Variable Documentation

criticalRelcachesBuilt

PGDLLIMPORT bool criticalRelcachesBuilt

extern

Definition at line 140 of file relcache.c.

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

criticalSharedRelcachesBuilt

PGDLLIMPORT bool criticalSharedRelcachesBuilt

extern

Definition at line 146 of file relcache.c.

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