relcache.h File Reference

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

Include dependency graph for relcache.h:

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

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 }

Functions
Relation	RelationIdGetRelation (Oid relationId)
void	RelationClose (Relation relation)
List *	RelationGetFKeyList (Relation relation)
List *	RelationGetIndexList (Relation relation)
List *	RelationGetStatExtList (Relation relation)
Oid	RelationGetPrimaryKeyIndex (Relation relation)
Oid	RelationGetReplicaIndex (Relation relation)
List *	RelationGetIndexExpressions (Relation relation)
List *	RelationGetDummyIndexExpressions (Relation relation)
List *	RelationGetIndexPredicate (Relation relation)
Datum *	RelationGetIndexRawAttOptions (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, Oid relfilenode, Oid reltablespace, bool shared_relation, bool mapped_relation, char relpersistence, char relkind)
void	RelationSetNewRelfilenode (Relation relation, char persistence)
void	RelationAssumeNewRelfilenode (Relation relation)
void	RelationForgetRelation (Oid rid)
void	RelationCacheInvalidateEntry (Oid relationId)
void	RelationCacheInvalidate (bool debug_discard)
void	RelationCloseSmgrByOid (Oid relationId)
void	AtEOXact_RelationCache (bool isCommit)
void	AtEOSubXact_RelationCache (bool isCommit, SubTransactionId mySubid, SubTransactionId parentSubid)
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 133 of file relcache.h.

RELCACHE_INIT_FILENAME

#define RELCACHE_INIT_FILENAME   "pg_internal.init"

Definition at line 24 of file relcache.h.

Typedef Documentation

IndexAttrBitmapKind

typedef enum IndexAttrBitmapKind IndexAttrBitmapKind

Relation

typedef struct RelationData* Relation

Definition at line 26 of file relcache.h.

RelationPtr

typedef Relation* RelationPtr

Definition at line 34 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

Definition at line 56 of file relcache.h.

{
    INDEX_ATTR_BITMAP_KEY,
    INDEX_ATTR_BITMAP_PRIMARY_KEY,
    INDEX_ATTR_BITMAP_IDENTITY_KEY,
    INDEX_ATTR_BITMAP_HOT_BLOCKING
} IndexAttrBitmapKind;

Function Documentation

AtEOSubXact_RelationCache()

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

Definition at line 3320 of file relcache.c.

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

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

Referenced by AbortSubTransaction(), and CommitSubTransaction().

AtEOXact_RelationCache()

void AtEOXact_RelationCache

(

bool

isCommit

)

Definition at line 3168 of file relcache.c.

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

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

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

errtable()

int errtable

(

Relation

rel

)

Definition at line 5819 of file relcache.c.

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

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

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

errtablecol()

int errtablecol	(	Relation	rel,
		int	attnum
	)

Definition at line 5836 of file relcache.c.

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

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

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

errtablecolname()

int errtablecolname	(	Relation	rel,
		const char *	colname
	)

Definition at line 5860 of file relcache.c.

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

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

Referenced by errtablecol().

errtableconstraint()

int errtableconstraint	(	Relation	rel,
		const char *	conname
	)

Definition at line 5873 of file relcache.c.

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

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

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

RelationAssumeNewRelfilenode()

void RelationAssumeNewRelfilenode

(

Relation

relation

)

Definition at line 3844 of file relcache.c.

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

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

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

RelationBuildLocalRelation()

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

Definition at line 3457 of file relcache.c.

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

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

Referenced by heap_create().

RelationBuildPublicationDesc()

void RelationBuildPublicationDesc	(	Relation	relation,
		struct PublicationDesc *	pubdesc
	)

Definition at line 5561 of file relcache.c.

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

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

Referenced by CheckCmdReplicaIdentity().

RelationCacheInitFilePostInvalidate()

void RelationCacheInitFilePostInvalidate

(

void

)

Definition at line 6646 of file relcache.c.

{
    LWLockRelease(RelCacheInitLock);
}

References LWLockRelease().

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

RelationCacheInitFilePreInvalidate()

void RelationCacheInitFilePreInvalidate

(

void

)

Definition at line 6621 of file relcache.c.

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

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

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

RelationCacheInitFileRemove()

void RelationCacheInitFileRemove

(

void

)

Definition at line 6661 of file relcache.c.

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

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

Referenced by StartupXLOG().

RelationCacheInitialize()

void RelationCacheInitialize

(

void

)

Definition at line 3870 of file relcache.c.

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

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

Referenced by InitPostgres().

RelationCacheInitializePhase2()

void RelationCacheInitializePhase2

(

void

)

Definition at line 3916 of file relcache.c.

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

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

Referenced by InitPostgres().

RelationCacheInitializePhase3()

void RelationCacheInitializePhase3

(

void

)

Definition at line 3975 of file relcache.c.

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

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

Referenced by InitPostgres().

RelationCacheInvalidate()

void RelationCacheInvalidate

(

bool

debug_discard

)

Definition at line 2924 of file relcache.c.

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

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

Referenced by InvalidateSystemCachesExtended(), and LocalExecuteInvalidationMessage().

RelationCacheInvalidateEntry()

void RelationCacheInvalidateEntry

(

Oid

relationId

)

Definition at line 2868 of file relcache.c.

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

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

Referenced by LocalExecuteInvalidationMessage().

RelationClose()

void RelationClose

(

Relation

relation

)

Definition at line 2159 of file relcache.c.

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

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

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

RelationCloseSmgrByOid()

void RelationCloseSmgrByOid

(

Oid

relationId

)

Definition at line 3033 of file relcache.c.

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

References PointerIsValid, RelationCloseSmgr, and RelationIdCacheLookup.

Referenced by swap_relation_files().

RelationForgetRelation()

void RelationForgetRelation

(

Oid

rid

)

Definition at line 2824 of file relcache.c.

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

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

Referenced by heap_drop_with_catalog(), and index_drop().

RelationGetDummyIndexExpressions()

List* RelationGetDummyIndexExpressions

(

Relation

relation

)

Definition at line 4968 of file relcache.c.

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

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

Referenced by BuildDummyIndexInfo().

RelationGetExclusionInfo()

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

Definition at line 5429 of file relcache.c.

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

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 4566 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;
 
    /* Fast path: non-partitioned tables without triggers can't have FKs */
    if (!relation->rd_rel->relhastriggers &&
        relation->rd_rel->relkind != RELKIND_PARTITIONED_TABLE)
        return NIL;
 
    /*
     * We build the list we intend to return (in the caller's context) while
     * doing the scan.  After successfully completing the scan, we copy that
     * list into the relcache entry.  This avoids cache-context memory leakage
     * if we get some sort of error partway through.
     */
    result = NIL;
 
    /* Prepare to scan pg_constraint for entries having conrelid = this rel. */
    ScanKeyInit(&skey,
                Anum_pg_constraint_conrelid,
                BTEqualStrategyNumber, F_OIDEQ,
                ObjectIdGetDatum(RelationGetRelid(relation)));
 
    conrel = 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;
 
        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::confkey, ForeignKeyCacheInfo::confrelid, ForeignKeyCacheInfo::conkey, ForeignKeyCacheInfo::conoid, ForeignKeyCacheInfo::conpfeqop, ForeignKeyCacheInfo::conrelid, copyObject, DeconstructFkConstraintRow(), GETSTRUCT, HeapTupleIsValid, lappend(), list_free_deep(), makeNode, MemoryContextSwitchTo(), NIL, ForeignKeyCacheInfo::nkeys, ObjectIdGetDatum, RelationData::rd_fkeylist, RelationData::rd_fkeyvalid, RelationData::rd_rel, 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 5355 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 5758 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 5105 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 */
    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);
            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 appropriate bitmaps.
     *
     * 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;
    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 */
 
        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);
 
        /* 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
             * indexattrs, since they are in index, and HOT-update shouldn't
             * miss them. 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)
            {
                if (indexDesc->rd_indam->amhotblocking)
                    hotblockingattrs = bms_add_member(hotblockingattrs,
                                                      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 */
        if (indexDesc->rd_indam->amhotblocking)
            pull_varattnos(indexExpressions, 1, &hotblockingattrs);
 
        /*
         * Collect all attributes in the index predicate, too. We have to
         * ignore amhotblocking flag, because the row might become indexable,
         * in which case we have to add it to the index.
         */
        pull_varattnos(indexPredicate, 1, &hotblockingattrs);
 
        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);
 
        goto restart;
    }
 
    /* Don't leak the old values of these bitmaps, if any */
    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;
 
    /*
     * Now save copies of the bitmaps in the relcache entry.  We intentionally
     * set rd_attrsvalid last, because that's what 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_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;
        default:
            elog(ERROR, "unknown attrKind %u", attrKind);
            return NULL;
    }
}

References AccessShareLock, IndexAmRoutine::amhotblocking, 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_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, RelationGetForm, RelationGetIndexList(), stringToNode(), and TextDatumGetCString.

Referenced by ExecUpdateLockMode(), ExtractReplicaIdentity(), GetParentedForeignKeyRefs(), heap_update(), logicalrep_rel_open(), pub_collist_contains_invalid_column(), and pub_rf_contains_invalid_column().

RelationGetIndexExpressions()

List* RelationGetIndexExpressions

(

Relation

relation

)

Definition at line 4909 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_relation_info(), GetIndexInputType(), index_unchanged_by_update(), infer_arbiter_indexes(), plan_create_index_workers(), and transformIndexConstraint().

RelationGetIndexList()

List* RelationGetIndexList

(

Relation

relation

)

Definition at line 4675 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;
    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);
 
        /*
         * Invalid, non-unique, non-immediate or predicate indexes aren't
         * interesting for either oid indexes or replication identity indexes,
         * so don't check them.
         */
        if (!index->indisvalid || !index->indisunique ||
            !index->indimmediate ||
            !heap_attisnull(htup, Anum_pg_index_indpred, NULL))
            continue;
 
        /* remember primary key index if any */
        if (index->indisprimary)
            pkeyIndex = index->indexrelid;
 
        /* remember explicitly chosen replica index */
        if (index->indisreplident)
            candidateIndex = index->indexrelid;
    }
 
    systable_endscan(indscan);
 
    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;
    if (replident == REPLICA_IDENTITY_DEFAULT && OidIsValid(pkeyIndex))
        relation->rd_replidindex = pkeyIndex;
    else if (replident == REPLICA_IDENTITY_INDEX && OidIsValid(candidateIndex))
        relation->rd_replidindex = candidateIndex;
    else
        relation->rd_replidindex = InvalidOid;
    relation->rd_indexvalid = 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_pkindex, RelationData::rd_rel, RelationData::rd_replidindex, RelationGetRelid, ScanKeyInit(), systable_beginscan(), systable_endscan(), systable_getnext(), table_close(), and table_open().

Referenced by AlterIndexNamespaces(), ATExecChangeOwner(), ATExecDropNotNull(), ATExecSetTableSpace(), AttachPartitionEnsureIndexes(), calculate_indexes_size(), calculate_toast_table_size(), cluster(), DefineIndex(), DefineRelation(), DetachPartitionFinalize(), do_analyze_rel(), ExecInitPartitionInfo(), ExecOpenIndices(), ExecRefreshMatView(), expandTableLikeClause(), get_relation_info(), GetParentedForeignKeyRefs(), index_get_partition(), infer_arbiter_indexes(), mark_index_clustered(), refresh_by_match_merge(), 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 5022 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(), and transformIndexConstraint().

RelationGetIndexRawAttOptions()

Datum* RelationGetIndexRawAttOptions

(

Relation

relation

)

Definition at line 5712 of file relcache.c.

{
    Oid         indexrelid = RelationGetRelid(indexrel);
    int16       natts = RelationGetNumberOfAttributes(indexrel);
    Datum      *options = NULL;
    int16       attnum;
 
    for (attnum = 1; attnum <= natts; attnum++)
    {
        if (indexrel->rd_indam->amoptsprocnum == 0)
            continue;
 
        if (!OidIsValid(index_getprocid(indexrel, attnum,
                                        indexrel->rd_indam->amoptsprocnum)))
            continue;
 
        if (!options)
            options = palloc0(sizeof(Datum) * natts);
 
        options[attnum - 1] = get_attoptions(indexrelid, attnum);
    }
 
    return options;
}

References IndexAmRoutine::amoptsprocnum, attnum, get_attoptions(), index_getprocid(), OidIsValid, options, palloc0(), RelationData::rd_indam, RelationGetNumberOfAttributes, and RelationGetRelid.

Referenced by BuildIndexInfo(), and CheckIndexCompatible().

RelationGetPrimaryKeyIndex()

Oid RelationGetPrimaryKeyIndex

(

Relation

relation

)

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

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

Referenced by build_replindex_scan_key(), and GetRelationIdentityOrPK().

RelationGetReplicaIndex()

Oid RelationGetReplicaIndex

(

Relation

relation

)

Definition at line 4884 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 build_replindex_scan_key(), CheckCmdReplicaIdentity(), GetRelationIdentityOrPK(), pg_get_replica_identity_index(), and RelationGetIdentityKeyBitmap().

RelationGetStatExtList()

List* RelationGetStatExtList

(

Relation

relation

)

Definition at line 4794 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 get_relation_statistics(), and transformTableLikeClause().

RelationIdGetRelation()

Relation RelationIdGetRelation

(

Oid

relationId

)

Definition at line 2053 of file relcache.c.

{
    Relation    rd;
 
    /* Make sure we're in an xact, even if this ends up being a cache hit */
    Assert(IsTransactionState());
 
    /*
     * first try to find reldesc in the cache
     */
    RelationIdCacheLookup(relationId, rd);
 
    if (RelationIsValid(rd))
    {
        /* 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)
        {
            /*
             * Indexes only have a limited number of possible schema changes,
             * and we don't want to use the full-blown procedure because it's
             * a headache for indexes that reload itself depends on.
             */
            if (rd->rd_rel->relkind == RELKIND_INDEX ||
                rd->rd_rel->relkind == RELKIND_PARTITIONED_INDEX)
                RelationReloadIndexInfo(rd);
            else
                RelationClearRelation(rd, true);
 
            /*
             * 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(), criticalRelcachesBuilt, InvalidSubTransactionId, IsTransactionState(), RelationData::rd_droppedSubid, RelationData::rd_isnailed, RelationData::rd_isvalid, RelationData::rd_rel, RelationBuildDesc(), RelationClearRelation(), RelationIdCacheLookup, RelationIncrementReferenceCount(), RelationIsValid, and RelationReloadIndexInfo().

Referenced by init_tuple_slot(), maybe_send_schema(), pgoutput_change(), 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 6581 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 1416 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, AMOID, IndexAmRoutine::amsupport, Assert(), CacheMemoryContext, DatumGetPointer, elog, ERROR, fastgetattr(), GetPgIndexDescriptor(), GETSTRUCT, heap_copytuple(), HeapTupleIsValid, IndexRelationGetNumberOfAttributes, IndexRelationGetNumberOfKeyAttributes, INDEXRELID, 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 1800 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 AMOID, 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().

RelationSetNewRelfilenode()

void RelationSetNewRelfilenode	(	Relation	relation,
		char	persistence
	)

Definition at line 3700 of file relcache.c.

{
    Oid         newrelfilenode;
    Relation    pg_class;
    HeapTuple   tuple;
    Form_pg_class classform;
    MultiXactId minmulti = InvalidMultiXactId;
    TransactionId freezeXid = InvalidTransactionId;
    RelFileNode newrnode;
 
    /* Allocate a new relfilenode */
    newrelfilenode = GetNewRelFileNode(relation->rd_rel->reltablespace, NULL,
                                       persistence);
 
    /*
     * Get a writable copy of the pg_class tuple for the given relation.
     */
    pg_class = table_open(RelationRelationId, RowExclusiveLock);
 
    tuple = SearchSysCacheCopy1(RELOID,
                                ObjectIdGetDatum(RelationGetRelid(relation)));
    if (!HeapTupleIsValid(tuple))
        elog(ERROR, "could not find tuple for relation %u",
             RelationGetRelid(relation));
    classform = (Form_pg_class) GETSTRUCT(tuple);
 
    /*
     * Schedule unlinking of the old storage at transaction commit.
     */
    RelationDropStorage(relation);
 
    /*
     * Create storage for the main fork of the new relfilenode.  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 relfilenode value will be
     * caught here, if GetNewRelFileNode messes up for any reason.
     */
    newrnode = relation->rd_node;
    newrnode.relNode = newrelfilenode;
 
    if (RELKIND_HAS_TABLE_AM(relation->rd_rel->relkind))
    {
        table_relation_set_new_filenode(relation, &newrnode,
                                        persistence,
                                        &freezeXid, &minmulti);
    }
    else if (RELKIND_HAS_STORAGE(relation->rd_rel->relkind))
    {
        /* handle these directly, at least for now */
        SMgrRelation srel;
 
        srel = RelationCreateStorage(newrnode, 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),
                             newrelfilenode,
                             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 = newrelfilenode;
 
        /* 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->relfrozenxid = freezeXid;
        classform->relminmxid = minmulti;
        classform->relpersistence = persistence;
 
        CatalogTupleUpdate(pg_class, &tuple->t_self, tuple);
    }
 
    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();
 
    RelationAssumeNewRelfilenode(relation);
}

References Assert(), CacheInvalidateRelcache(), CatalogTupleUpdate(), CommandCounterIncrement(), elog, ERROR, GetCurrentTransactionId(), GetNewRelFileNode(), GETSTRUCT, heap_freetuple(), HeapTupleIsValid, InvalidMultiXactId, InvalidTransactionId, ObjectIdGetDatum, RelationData::rd_node, RelationData::rd_rel, RelationAssumeNewRelfilenode(), RelationCreateStorage(), RelationDropStorage(), RelationGetRelationName, RelationGetRelid, RelationIsMapped, RelationMapUpdateMap(), RelFileNode::relNode, RELOID, RowExclusiveLock, SearchSysCacheCopy1, smgrclose(), HeapTupleData::t_self, table_close(), table_open(), and table_relation_set_new_filenode().

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

Variable Documentation

criticalRelcachesBuilt

PGDLLIMPORT bool criticalRelcachesBuilt

extern

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

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