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"

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

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

Functions
Relation	RelationIdGetRelation (Oid relationId)
void	RelationClose (Relation relation)
List *	RelationGetFKeyList (Relation relation)
List *	RelationGetIndexList (Relation relation)
List *	RelationGetStatExtList (Relation relation)
Oid	RelationGetPrimaryKeyIndex (Relation relation)
Oid	RelationGetReplicaIndex (Relation relation)
List *	RelationGetIndexExpressions (Relation relation)
List *	RelationGetIndexPredicate (Relation relation)
Bitmapset *	RelationGetIndexAttrBitmap (Relation relation, IndexAttrBitmapKind attrKind)
void	RelationGetExclusionInfo (Relation indexRelation, Oid **operators, Oid **procs, uint16 **strategies)
void	RelationInitIndexAccessInfo (Relation relation)
struct PublicationActions *	GetRelationPublicationActions (Relation relation)
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	RelationForgetRelation (Oid rid)
void	RelationCacheInvalidateEntry (Oid relationId)
void	RelationCacheInvalidate (void)
void	RelationCloseSmgrByOid (Oid relationId)
void	AtEOXact_RelationCache (bool isCommit)
void	AtEOSubXact_RelationCache (bool isCommit, SubTransactionId mySubid, SubTransactionId parentSubid)
bool	RelationIdIsInInitFile (Oid relationId)
void	RelationCacheInitFilePreInvalidate (void)
void	RelationCacheInitFilePostInvalidate (void)
void	RelationCacheInitFileRemove (void)

Variables
bool	criticalRelcachesBuilt
bool	criticalSharedRelcachesBuilt

Macro Definition Documentation

RELCACHE_INIT_FILENAME

#define RELCACHE_INIT_FILENAME   "pg_internal.init"

Definition at line 24 of file relcache.h.

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

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_ALL
INDEX_ATTR_BITMAP_KEY
INDEX_ATTR_BITMAP_PRIMARY_KEY
INDEX_ATTR_BITMAP_IDENTITY_KEY

Definition at line 53 of file relcache.h.

{
    INDEX_ATTR_BITMAP_ALL,
    INDEX_ATTR_BITMAP_KEY,
    INDEX_ATTR_BITMAP_PRIMARY_KEY,
    INDEX_ATTR_BITMAP_IDENTITY_KEY
} IndexAttrBitmapKind;

Function Documentation

AtEOSubXact_RelationCache()

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

Definition at line 3076 of file relcache.c.

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

Referenced by AbortSubTransaction(), and CommitSubTransaction().

{
    HASH_SEQ_STATUS status;
    RelIdCacheEnt *idhentry;
    int         i;

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

    /* Don't reset the list; we still need more cleanup later */
}

AtEOXact_RelationCache()

void AtEOXact_RelationCache

(

bool

isCommit

)

Definition at line 2938 of file relcache.c.

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

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

{
    HASH_SEQ_STATUS status;
    RelIdCacheEnt *idhentry;
    int         i;

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

    if (EOXactTupleDescArrayLen > 0)
    {
        Assert(EOXactTupleDescArray != NULL);
        for (i = 0; i < NextEOXactTupleDescNum; i++)
            FreeTupleDesc(EOXactTupleDescArray[i]);
        pfree(EOXactTupleDescArray);
        EOXactTupleDescArray = NULL;
    }

    /* Now we're out of the transaction and can clear the lists */
    eoxact_list_len = 0;
    eoxact_list_overflowed = false;
    NextEOXactTupleDescNum = 0;
    EOXactTupleDescArrayLen = 0;
}

errtable()

int errtable

(

Relation

rel

)

Definition at line 5167 of file relcache.c.

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

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

{
    err_generic_string(PG_DIAG_SCHEMA_NAME,
                       get_namespace_name(RelationGetNamespace(rel)));
    err_generic_string(PG_DIAG_TABLE_NAME, RelationGetRelationName(rel));

    return 0;                   /* return value does not matter */
}

errtablecol()

int errtablecol	(	Relation	rel,
		int	attnum
	)

Definition at line 5184 of file relcache.c.

References attname, errtablecolname(), get_attname(), NameStr, RelationGetDescr, RelationGetRelid, relidcacheent::reldesc, and TupleDescAttr.

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

{
    TupleDesc   reldesc = RelationGetDescr(rel);
    const char *colname;

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

    return errtablecolname(rel, colname);
}

errtablecolname()

int errtablecolname	(	Relation	rel,
		const char *	colname
	)

Definition at line 5208 of file relcache.c.

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

Referenced by errtablecol().

{
    errtable(rel);
    err_generic_string(PG_DIAG_COLUMN_NAME, colname);

    return 0;                   /* return value does not matter */
}

errtableconstraint()

int errtableconstraint	(	Relation	rel,
		const char *	conname
	)

Definition at line 5221 of file relcache.c.

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

{
    errtable(rel);
    err_generic_string(PG_DIAG_CONSTRAINT_NAME, conname);

    return 0;                   /* return value does not matter */
}

GetRelationPublicationActions()

struct PublicationActions* GetRelationPublicationActions

(

Relation

relation

)

Definition at line 5088 of file relcache.c.

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

Referenced by CheckCmdReplicaIdentity().

{
    List       *puboids;
    ListCell   *lc;
    MemoryContext oldcxt;
    PublicationActions *pubactions = palloc0(sizeof(PublicationActions));

    /*
     * If not publishable, it publishes no actions.  (pgoutput_change() will
     * ignore it.)
     */
    if (!is_publishable_relation(relation))
        return pubactions;

    if (relation->rd_pubactions)
        return memcpy(pubactions, relation->rd_pubactions,
                      sizeof(PublicationActions));

    /* Fetch the publication membership info. */
    puboids = GetRelationPublications(RelationGetRelid(relation));
    puboids = list_concat_unique_oid(puboids, GetAllTablesPublications());

    foreach(lc, puboids)
    {
        Oid         pubid = lfirst_oid(lc);
        HeapTuple   tup;
        Form_pg_publication pubform;

        tup = SearchSysCache1(PUBLICATIONOID, ObjectIdGetDatum(pubid));

        if (!HeapTupleIsValid(tup))
            elog(ERROR, "cache lookup failed for publication %u", pubid);

        pubform = (Form_pg_publication) GETSTRUCT(tup);

        pubactions->pubinsert |= pubform->pubinsert;
        pubactions->pubupdate |= pubform->pubupdate;
        pubactions->pubdelete |= pubform->pubdelete;
        pubactions->pubtruncate |= pubform->pubtruncate;

        ReleaseSysCache(tup);

        /*
         * If we know everything is replicated, there is no point to check for
         * other publications.
         */
        if (pubactions->pubinsert && pubactions->pubupdate &&
            pubactions->pubdelete && pubactions->pubtruncate)
            break;
    }

    if (relation->rd_pubactions)
    {
        pfree(relation->rd_pubactions);
        relation->rd_pubactions = NULL;
    }

    /* Now save copy of the actions in the relcache entry. */
    oldcxt = MemoryContextSwitchTo(CacheMemoryContext);
    relation->rd_pubactions = palloc(sizeof(PublicationActions));
    memcpy(relation->rd_pubactions, pubactions, sizeof(PublicationActions));
    MemoryContextSwitchTo(oldcxt);

    return pubactions;
}

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

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_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(), relfilenode, relkind, relpersistence, TupleDescData::tdrefcount, and TupleDescAttr.

Referenced by heap_create().

{
    Relation    rel;
    MemoryContext oldcxt;
    int         natts = tupDesc->natts;
    int         i;
    bool        has_not_null;
    bool        nailit;

    AssertArg(natts >= 0);

    /*
     * check for creation of a rel that must be nailed in cache.
     *
     * XXX this list had better match the relations specially handled in
     * RelationCacheInitializePhase2/3.
     */
    switch (relid)
    {
        case DatabaseRelationId:
        case AuthIdRelationId:
        case AuthMemRelationId:
        case RelationRelationId:
        case AttributeRelationId:
        case ProcedureRelationId:
        case TypeRelationId:
            nailit = true;
            break;
        default:
            nailit = false;
            break;
    }

    /*
     * check that hardwired list of shared rels matches what's in the
     * bootstrap .bki file.  If you get a failure here during initdb, you
     * probably need to fix IsSharedRelation() to match whatever you've done
     * to the set of shared relations.
     */
    if (shared_relation != IsSharedRelation(relid))
        elog(ERROR, "shared_relation flag for \"%s\" does not match IsSharedRelation(%u)",
             relname, relid);

    /* Shared relations had better be mapped, too */
    Assert(mapped_relation || !shared_relation);

    /*
     * switch to the cache context to create the relcache entry.
     */
    if (!CacheMemoryContext)
        CreateCacheMemoryContext();

    oldcxt = MemoryContextSwitchTo(CacheMemoryContext);

    /*
     * allocate a new relation descriptor and fill in basic state fields.
     */
    rel = (Relation) palloc0(sizeof(RelationData));

    /* make sure relation is marked as having no open file yet */
    rel->rd_smgr = NULL;

    /* mark it nailed if appropriate */
    rel->rd_isnailed = nailit;

    rel->rd_refcnt = nailit ? 1 : 0;

    /* it's being created in this transaction */
    rel->rd_createSubid = GetCurrentSubTransactionId();
    rel->rd_newRelfilenodeSubid = InvalidSubTransactionId;

    /*
     * create a new tuple descriptor from the one passed in.  We do this
     * partly to copy it into the cache context, and partly because the new
     * relation can't have any defaults or constraints yet; they have to be
     * added in later steps, because they require additions to multiple system
     * catalogs.  We can copy attnotnull constraints here, however.
     */
    rel->rd_att = CreateTupleDescCopy(tupDesc);
    rel->rd_att->tdrefcount = 1;    /* mark as refcounted */
    has_not_null = false;
    for (i = 0; i < natts; i++)
    {
        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;

    if (relkind == RELKIND_RELATION ||
        relkind == RELKIND_SEQUENCE ||
        relkind == RELKIND_TOASTVALUE ||
        relkind == RELKIND_MATVIEW)
        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);

    /*
     * done building relcache entry.
     */
    MemoryContextSwitchTo(oldcxt);

    /* It's fully valid */
    rel->rd_isvalid = true;

    /*
     * Caller expects us to pin the returned entry.
     */
    RelationIncrementReferenceCount(rel);

    return rel;
}

RelationCacheInitFilePostInvalidate()

void RelationCacheInitFilePostInvalidate

(

void

)

Definition at line 5963 of file relcache.c.

References LWLockRelease().

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

{
    LWLockRelease(RelCacheInitLock);
}

RelationCacheInitFilePreInvalidate()

void RelationCacheInitFilePreInvalidate

(

void

)

Definition at line 5938 of file relcache.c.

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

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

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

RelationCacheInitFileRemove()

void RelationCacheInitFileRemove

(

void

)

Definition at line 5978 of file relcache.c.

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

Referenced by StartupXLOG().

{
    const char *tblspcdir = "pg_tblspc";
    DIR        *dir;
    struct dirent *de;
    char        path[MAXPGPATH + 10 + sizeof(TABLESPACE_VERSION_DIRECTORY)];

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

RelationCacheInitialize()

void RelationCacheInitialize

(

void

)

Definition at line 3579 of file relcache.c.

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

Referenced by InitPostgres().

{
    HASHCTL     ctl;

    /*
     * make sure cache memory context exists
     */
    if (!CacheMemoryContext)
        CreateCacheMemoryContext();

    /*
     * create hashtable that indexes the relcache
     */
    MemSet(&ctl, 0, sizeof(ctl));
    ctl.keysize = sizeof(Oid);
    ctl.entrysize = sizeof(RelIdCacheEnt);
    RelationIdCache = hash_create("Relcache by OID", INITRELCACHESIZE,
                                  &ctl, HASH_ELEM | HASH_BLOBS);

    /*
     * relation mapper needs to be initialized too
     */
    RelationMapInitialize();
}

RelationCacheInitializePhase2()

void RelationCacheInitializePhase2

(

void

)

Definition at line 3616 of file relcache.c.

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

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

RelationCacheInitializePhase3()

void RelationCacheInitializePhase3

(

void

)

Definition at line 3675 of file relcache.c.

References AccessMethodProcedureIndexId, Assert, AttributeRelidNumIndexId, AuthIdOidIndexId, AuthIdRolnameIndexId, AuthMemMemRoleIndexId, CacheMemoryContext, CLASS_TUPLE_SIZE, ClassOidIndexId, criticalRelcachesBuilt, criticalSharedRelcachesBuilt, DatabaseNameIndexId, DatabaseOidIndexId, 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, IndexRelidIndexId, InitCatalogCachePhase2(), InvalidOid, IsBootstrapProcessingMode, load_critical_index(), load_relcache_init_file(), MemoryContextSwitchTo(), ObjectIdGetDatum, OpclassOidIndexId, pfree(), RelationData::rd_att, RelationData::rd_options, RelationData::rd_partdesc, RelationData::rd_partkey, RelationData::rd_rel, RelationData::rd_rsdesc, RelationData::rd_rules, RelationData::rd_tableam, RelationBuildPartitionDesc(), RelationBuildPartitionKey(), RelationBuildRowSecurity(), RelationBuildRuleLock(), RelationBuildTriggers(), RelationDecrementReferenceCount(), RelationGetRelationName, RelationGetRelid, RelationIncrementReferenceCount(), RelationInitTableAccessMethod(), RelationMapInitializePhase3(), RelationParseRelOptions(), relidcacheent::reldesc, ReleaseSysCache(), RELOID, RewriteRelRulenameIndexId, SearchSysCache1(), SharedSecLabelObjectIndexId, status(), TupleDescData::tdtypeid, TupleDescData::tdtypmod, RelationData::trigdesc, TriggerRelidNameIndexId, and write_relcache_init_file().

Referenced by InitPostgres().

{
    HASH_SEQ_STATUS status;
    RelIdCacheEnt *idhentry;
    MemoryContext oldcxt;
    bool        needNewCacheFile = !criticalSharedRelcachesBuilt;

    /*
     * relation mapper needs initialized too
     */
    RelationMapInitializePhase3();

    /*
     * switch to cache memory context
     */
    oldcxt = MemoryContextSwitchTo(CacheMemoryContext);

    /*
     * Try to load the local relcache cache file.  If unsuccessful, bootstrap
     * the cache with pre-made descriptors for the critical "nailed-in" system
     * catalogs.
     */
    if (IsBootstrapProcessingMode() ||
        !load_relcache_init_file(false))
    {
        needNewCacheFile = true;

        formrdesc("pg_class", RelationRelation_Rowtype_Id, false,
                  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 the partition key and descriptor for a partitioned table.
         */
        if (relation->rd_rel->relkind == RELKIND_PARTITIONED_TABLE &&
            relation->rd_partkey == NULL)
        {
            RelationBuildPartitionKey(relation);
            Assert(relation->rd_partkey != NULL);

            restart = true;
        }

        if (relation->rd_rel->relkind == RELKIND_PARTITIONED_TABLE &&
            relation->rd_partdesc == NULL)
        {
            RelationBuildPartitionDesc(relation);
            Assert(relation->rd_partdesc != NULL);

            restart = true;
        }

        if (relation->rd_tableam == NULL &&
            (relation->rd_rel->relkind == RELKIND_RELATION ||
             relation->rd_rel->relkind == RELKIND_SEQUENCE ||
             relation->rd_rel->relkind == RELKIND_TOASTVALUE ||
             relation->rd_rel->relkind == RELKIND_MATVIEW))
        {
            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);
    }
}

RelationCacheInvalidate()

void RelationCacheInvalidate

(

void

)

Definition at line 2778 of file relcache.c.

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

Referenced by InvalidateSystemCaches(), and LocalExecuteInvalidationMessage().

{
    HASH_SEQ_STATUS status;
    RelIdCacheEnt *idhentry;
    Relation    relation;
    List       *rebuildFirstList = NIL;
    List       *rebuildList = NIL;
    ListCell   *l;

    /*
     * Reload relation mapping data before starting to reconstruct cache.
     */
    RelationMapInvalidateAll();

    /* Phase 1 */
    hash_seq_init(&status, RelationIdCache);

    while ((idhentry = (RelIdCacheEnt *) hash_seq_search(&status)) != NULL)
    {
        relation = idhentry->reldesc;

        /* Must close all smgr references to avoid leaving dangling ptrs */
        RelationCloseSmgr(relation);

        /*
         * Ignore new relations; no other backend will manipulate them before
         * we commit.  Likewise, before replacing a relation's relfilenode, we
         * shall have acquired AccessExclusiveLock and drained any applicable
         * pending invalidations.
         */
        if (relation->rd_createSubid != InvalidSubTransactionId ||
            relation->rd_newRelfilenodeSubid != InvalidSubTransactionId)
            continue;

        relcacheInvalsReceived++;

        if (RelationHasReferenceCountZero(relation))
        {
            /* Delete this entry immediately */
            Assert(!relation->rd_isnailed);
            RelationClearRelation(relation, false);
        }
        else
        {
            /*
             * If it's a mapped relation, immediately update its rd_node in
             * case its relfilenode changed.  We must do this during phase 1
             * in case the relation is consulted during rebuild of other
             * relcache entries in phase 2.  It's safe since consulting the
             * map doesn't involve any access to relcache entries.
             */
            if (RelationIsMapped(relation))
                RelationInitPhysicalAddr(relation);

            /*
             * Add this entry to list of stuff to rebuild in second pass.
             * pg_class goes to the front of rebuildFirstList while
             * pg_class_oid_index goes to the back of rebuildFirstList, so
             * they are done first and second respectively.  Other nailed
             * relations go to the front of rebuildList, so they'll be done
             * next in no particular order; and everything else goes to the
             * back of rebuildList.
             */
            if (RelationGetRelid(relation) == RelationRelationId)
                rebuildFirstList = lcons(relation, rebuildFirstList);
            else if (RelationGetRelid(relation) == ClassOidIndexId)
                rebuildFirstList = lappend(rebuildFirstList, relation);
            else if (relation->rd_isnailed)
                rebuildList = lcons(relation, rebuildList);
            else
                rebuildList = lappend(rebuildList, relation);
        }
    }

    /*
     * Now zap any remaining smgr cache entries.  This must happen before we
     * start to rebuild entries, since that may involve catalog fetches which
     * will re-open catalog files.
     */
    smgrcloseall();

    /* Phase 2: rebuild the items found to need rebuild in phase 1 */
    foreach(l, rebuildFirstList)
    {
        relation = (Relation) lfirst(l);
        RelationClearRelation(relation, true);
    }
    list_free(rebuildFirstList);
    foreach(l, rebuildList)
    {
        relation = (Relation) lfirst(l);
        RelationClearRelation(relation, true);
    }
    list_free(rebuildList);
}

RelationCacheInvalidateEntry()

void RelationCacheInvalidateEntry

(

Oid

relationId

)

Definition at line 2734 of file relcache.c.

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

Referenced by LocalExecuteInvalidationMessage().

{
    Relation    relation;

    RelationIdCacheLookup(relationId, relation);

    if (PointerIsValid(relation))
    {
        relcacheInvalsReceived++;
        RelationFlushRelation(relation);
    }
}

RelationClose()

void RelationClose

(

Relation

relation

)

Definition at line 2088 of file relcache.c.

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

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

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

#ifdef RELCACHE_FORCE_RELEASE
    if (RelationHasReferenceCountZero(relation) &&
        relation->rd_createSubid == InvalidSubTransactionId &&
        relation->rd_newRelfilenodeSubid == InvalidSubTransactionId)
        RelationClearRelation(relation, false);
#endif
}

RelationCloseSmgrByOid()

void RelationCloseSmgrByOid

(

Oid

relationId

)

Definition at line 2881 of file relcache.c.

References PointerIsValid, RelationCloseSmgr, and RelationIdCacheLookup.

Referenced by swap_relation_files().

{
    Relation    relation;

    RelationIdCacheLookup(relationId, relation);

    if (!PointerIsValid(relation))
        return;                 /* not in cache, nothing to do */

    RelationCloseSmgr(relation);
}

RelationForgetRelation()

void RelationForgetRelation

(

Oid

rid

)

Definition at line 2702 of file relcache.c.

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

Referenced by heap_drop_with_catalog(), and index_drop().

{
    Relation    relation;

    RelationIdCacheLookup(rid, relation);

    if (!PointerIsValid(relation))
        return;                 /* not in cache, nothing to do */

    if (!RelationHasReferenceCountZero(relation))
        elog(ERROR, "relation %u is still open", rid);

    /* Unconditionally destroy the relcache entry */
    RelationClearRelation(relation, false);
}

RelationGetExclusionInfo()

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

Definition at line 4964 of file relcache.c.

References AccessShareLock, ARR_DATA_PTR, ARR_DIMS, ARR_ELEMTYPE, ARR_HASNULL, ARR_NDIM, BTEqualStrategyNumber, ConstraintRelidTypidNameIndexId, 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().

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

RelationGetFKeyList()

List* RelationGetFKeyList

(

Relation

relation

)

Definition at line 4238 of file relcache.c.

References AccessShareLock, BTEqualStrategyNumber, CacheMemoryContext, ForeignKeyCacheInfo::confkey, ForeignKeyCacheInfo::confrelid, ForeignKeyCacheInfo::conkey, ForeignKeyCacheInfo::conoid, ForeignKeyCacheInfo::conpfeqop, ForeignKeyCacheInfo::conrelid, ConstraintRelidTypidNameIndexId, 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(), ATExecDetachPartition(), CloneFkReferencing(), and get_relation_foreign_keys().

{
    List       *result;
    Relation    conrel;
    SysScanDesc conscan;
    ScanKeyData skey;
    HeapTuple   htup;
    List       *oldlist;
    MemoryContext oldcxt;

    /* Quick exit if we already computed the list. */
    if (relation->rd_fkeyvalid)
        return relation->rd_fkeylist;

    /* Fast path: 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);

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

RelationGetIndexAttrBitmap()

Bitmapset* RelationGetIndexAttrBitmap	(	Relation	relation,
		IndexAttrBitmapKind	attrKind
	)

Definition at line 4726 of file relcache.c.

References AccessShareLock, bms_add_member(), bms_copy(), bms_free(), CacheMemoryContext, elog, equal(), ERROR, FirstLowInvalidHeapAttributeNumber, GetPgIndexDescriptor(), heap_getattr, i, INDEX_ATTR_BITMAP_ALL, INDEX_ATTR_BITMAP_IDENTITY_KEY, INDEX_ATTR_BITMAP_KEY, INDEX_ATTR_BITMAP_PRIMARY_KEY, index_close(), index_open(), lfirst_oid, list_free(), MemoryContextSwitchTo(), NIL, pull_varattnos(), RelationData::rd_idattr, RelationData::rd_index, RelationData::rd_indexattr, RelationData::rd_indextuple, RelationData::rd_keyattr, RelationData::rd_pkattr, RelationData::rd_pkindex, RelationData::rd_replidindex, RelationGetForm, RelationGetIndexList(), relhasindex, stringToNode(), and TextDatumGetCString.

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

{
    Bitmapset  *indexattrs;     /* indexed columns */
    Bitmapset  *uindexattrs;    /* columns in unique indexes */
    Bitmapset  *pkindexattrs;   /* columns in the primary index */
    Bitmapset  *idindexattrs;   /* columns in the replica identity */
    List       *indexoidlist;
    List       *newindexoidlist;
    Oid         relpkindex;
    Oid         relreplindex;
    ListCell   *l;
    MemoryContext oldcxt;

    /* Quick exit if we already computed the result. */
    if (relation->rd_indexattr != NULL)
    {
        switch (attrKind)
        {
            case INDEX_ATTR_BITMAP_ALL:
                return bms_copy(relation->rd_indexattr);
            case INDEX_ATTR_BITMAP_KEY:
                return bms_copy(relation->rd_keyattr);
            case INDEX_ATTR_BITMAP_PRIMARY_KEY:
                return bms_copy(relation->rd_pkattr);
            case INDEX_ATTR_BITMAP_IDENTITY_KEY:
                return bms_copy(relation->rd_idattr);
            default:
                elog(ERROR, "unknown attrKind %u", attrKind);
        }
    }

    /* Fast path if definitely no indexes */
    if (!RelationGetForm(relation)->relhasindex)
        return NULL;

    /*
     * Get cached list of index OIDs. If we have to start over, we do so here.
     */
restart:
    indexoidlist = RelationGetIndexList(relation);

    /* Fall out if no indexes (but relhasindex was set) */
    if (indexoidlist == NIL)
        return NULL;

    /*
     * Copy the rd_pkindex and rd_replidindex values computed by
     * RelationGetIndexList before proceeding.  This is needed because a
     * relcache flush could occur inside index_open below, resetting the
     * fields managed by RelationGetIndexList.  We need to do the work with
     * stable values of these fields.
     */
    relpkindex = relation->rd_pkindex;
    relreplindex = relation->rd_replidindex;

    /*
     * For each index, add referenced attributes to indexattrs.
     *
     * Note: we consider all indexes returned by RelationGetIndexList, even if
     * they are not indisready or indisvalid.  This is important because an
     * index for which CREATE INDEX CONCURRENTLY has just started must be
     * included in HOT-safety decisions (see README.HOT).  If a DROP INDEX
     * CONCURRENTLY is far enough along that we should ignore the index, it
     * won't be returned at all by RelationGetIndexList.
     */
    indexattrs = NULL;
    uindexattrs = NULL;
    pkindexattrs = NULL;
    idindexattrs = NULL;
    foreach(l, indexoidlist)
    {
        Oid         indexOid = lfirst_oid(l);
        Relation    indexDesc;
        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)
            {
                indexattrs = bms_add_member(indexattrs,
                                            attrnum - FirstLowInvalidHeapAttributeNumber);

                if (isKey && i < indexDesc->rd_index->indnkeyatts)
                    uindexattrs = bms_add_member(uindexattrs,
                                                 attrnum - FirstLowInvalidHeapAttributeNumber);

                if (isPK && i < indexDesc->rd_index->indnkeyatts)
                    pkindexattrs = bms_add_member(pkindexattrs,
                                                  attrnum - FirstLowInvalidHeapAttributeNumber);

                if (isIDKey && i < indexDesc->rd_index->indnkeyatts)
                    idindexattrs = bms_add_member(idindexattrs,
                                                  attrnum - FirstLowInvalidHeapAttributeNumber);
            }
        }

        /* Collect all attributes used in expressions, too */
        pull_varattnos(indexExpressions, 1, &indexattrs);

        /* Collect all attributes in the index predicate, too */
        pull_varattnos(indexPredicate, 1, &indexattrs);

        index_close(indexDesc, AccessShareLock);
    }

    /*
     * During one of the index_opens in the above loop, we might have received
     * a relcache flush event on this relcache entry, which might have been
     * signaling a change in the rel's index list.  If so, we'd better start
     * over to ensure we deliver up-to-date attribute bitmaps.
     */
    newindexoidlist = RelationGetIndexList(relation);
    if (equal(indexoidlist, newindexoidlist) &&
        relpkindex == relation->rd_pkindex &&
        relreplindex == relation->rd_replidindex)
    {
        /* Still the same index set, so proceed */
        list_free(newindexoidlist);
        list_free(indexoidlist);
    }
    else
    {
        /* Gotta do it over ... might as well not leak memory */
        list_free(newindexoidlist);
        list_free(indexoidlist);
        bms_free(uindexattrs);
        bms_free(pkindexattrs);
        bms_free(idindexattrs);
        bms_free(indexattrs);

        goto restart;
    }

    /* Don't leak the old values of these bitmaps, if any */
    bms_free(relation->rd_indexattr);
    relation->rd_indexattr = NULL;
    bms_free(relation->rd_keyattr);
    relation->rd_keyattr = NULL;
    bms_free(relation->rd_pkattr);
    relation->rd_pkattr = NULL;
    bms_free(relation->rd_idattr);
    relation->rd_idattr = NULL;

    /*
     * Now save copies of the bitmaps in the relcache entry.  We intentionally
     * set rd_indexattr last, because that's the one that signals validity of
     * the values; if we run out of memory before making that copy, we won't
     * leave the relcache entry looking like the other ones are valid but
     * empty.
     */
    oldcxt = MemoryContextSwitchTo(CacheMemoryContext);
    relation->rd_keyattr = bms_copy(uindexattrs);
    relation->rd_pkattr = bms_copy(pkindexattrs);
    relation->rd_idattr = bms_copy(idindexattrs);
    relation->rd_indexattr = bms_copy(indexattrs);
    MemoryContextSwitchTo(oldcxt);

    /* We return our original working copy for caller to play with */
    switch (attrKind)
    {
        case INDEX_ATTR_BITMAP_ALL:
            return indexattrs;
        case INDEX_ATTR_BITMAP_KEY:
            return uindexattrs;
        case INDEX_ATTR_BITMAP_PRIMARY_KEY:
            return pkindexattrs;
        case INDEX_ATTR_BITMAP_IDENTITY_KEY:
            return idindexattrs;
        default:
            elog(ERROR, "unknown attrKind %u", attrKind);
            return NULL;
    }
}

RelationGetIndexExpressions()

List* RelationGetIndexExpressions

(

Relation

relation

)

Definition at line 4581 of file relcache.c.

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(), infer_arbiter_indexes(), plan_create_index_workers(), and transformIndexConstraint().

{
    List       *result;
    Datum       exprsDatum;
    bool        isnull;
    char       *exprsString;
    MemoryContext oldcxt;

    /* Quick exit if we already computed the result. */
    if (relation->rd_indexprs)
        return copyObject(relation->rd_indexprs);

    /* Quick exit if there is nothing to do. */
    if (relation->rd_indextuple == NULL ||
        heap_attisnull(relation->rd_indextuple, Anum_pg_index_indexprs, 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;
}

RelationGetIndexList()

List* RelationGetIndexList

(

Relation

relation

)

Definition at line 4347 of file relcache.c.

References AccessShareLock, BTEqualStrategyNumber, CacheMemoryContext, GETSTRUCT, heap_attisnull(), HeapTupleIsValid, IndexIndrelidIndexId, 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(), ATExecDetachPartition(), ATExecDropNotNull(), ATExecSetTableSpace(), AttachPartitionEnsureIndexes(), calculate_indexes_size(), calculate_toast_table_size(), cluster(), DefineIndex(), DefineRelation(), ExecInitPartitionInfo(), ExecOpenIndices(), ExecRefreshMatView(), 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(), toast_open_indexes(), transformFkeyCheckAttrs(), transformFkeyGetPrimaryKey(), transformTableLikeClause(), triggered_change_notification(), and vac_open_indexes().

{
    Relation    indrel;
    SysScanDesc indscan;
    ScanKeyData skey;
    HeapTuple   htup;
    List       *result;
    List       *oldlist;
    char        replident = relation->rd_rel->relreplident;
    Oid         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;
}

RelationGetIndexPredicate()

List* RelationGetIndexPredicate

(

Relation

relation

)

Definition at line 4643 of file relcache.c.

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

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

RelationGetPrimaryKeyIndex()

Oid RelationGetPrimaryKeyIndex

(

Relation

relation

)

Definition at line 4535 of file relcache.c.

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

Referenced by GetRelationIdentityOrPK().

{
    List       *ilist;

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

    return relation->rd_pkindex;
}

RelationGetReplicaIndex()

Oid RelationGetReplicaIndex

(

Relation

relation

)

Definition at line 4556 of file relcache.c.

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

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

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

RelationGetStatExtList()

List* RelationGetStatExtList

(

Relation

relation

)

Definition at line 4466 of file relcache.c.

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(), StatisticExtRelidIndexId, systable_beginscan(), systable_endscan(), systable_getnext(), table_close(), and table_open().

Referenced by get_relation_statistics(), and transformTableLikeClause().

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

RelationIdGetRelation()

Relation RelationIdGetRelation

(

Oid

relationId

)

Definition at line 1989 of file relcache.c.

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

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

{
    Relation    rd;

    /* Make sure we're in an xact, even if this ends up being a cache hit */
    Assert(IsTransactionState());

    /*
     * first try to find reldesc in the cache
     */
    RelationIdCacheLookup(relationId, rd);

    if (RelationIsValid(rd))
    {
        RelationIncrementReferenceCount(rd);
        /* revalidate cache entry if necessary */
        if (!rd->rd_isvalid)
        {
            /*
             * Indexes only have a limited number of possible schema changes,
             * and we don't want to use the full-blown procedure because it's
             * a headache for indexes that reload itself depends on.
             */
            if (rd->rd_rel->relkind == RELKIND_INDEX ||
                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;
}

RelationIdIsInInitFile()

bool RelationIdIsInInitFile

(

Oid

relationId

)

Definition at line 5898 of file relcache.c.

References Assert, DatabaseNameIndexId, RelationSupportsSysCache(), SharedSecLabelObjectIndexId, and TriggerRelidNameIndexId.

Referenced by RegisterRelcacheInvalidation(), and write_relcache_init_file().

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

RelationInitIndexAccessInfo()

void RelationInitIndexAccessInfo

(

Relation

relation

)

Definition at line 1361 of file relcache.c.

References ALLOCSET_SMALL_SIZES, AllocSetContextCreate, AMOID, IndexAmRoutine::amsupport, Assert, CacheMemoryContext, DatumGetPointer, elog, ERROR, fastgetattr, GetPgIndexDescriptor(), GETSTRUCT, heap_copytuple(), HeapTupleIsValid, IndexRelationGetNumberOfAttributes, IndexRelationGetNumberOfKeyAttributes, INDEXRELID, IndexSupportInitialize(), InitIndexAmRoutine(), 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, RelationGetNumberOfAttributes, RelationGetRelationName, RelationGetRelid, ReleaseSysCache(), SearchSysCache1(), int2vector::values, and oidvector::values.

Referenced by index_create(), and RelationBuildDesc().

{
    HeapTuple   tuple;
    Form_pg_am  aform;
    Datum       indcollDatum;
    Datum       indclassDatum;
    Datum       indoptionDatum;
    bool        isnull;
    oidvector  *indcoll;
    oidvector  *indclass;
    int2vector *indoption;
    MemoryContext indexcxt;
    MemoryContext oldcontext;
    int         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
     */
    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));

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

RelationInitTableAccessMethod()

void RelationInitTableAccessMethod

(

Relation

relation

)

Definition at line 1739 of file relcache.c.

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

{
    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.
         */
        relation->rd_amhandler = HEAP_TABLE_AM_HANDLER_OID;
    }
    else if (IsCatalogRelation(relation))
    {
        /*
         * Avoid doing a syscache lookup for catalog tables.
         */
        Assert(relation->rd_rel->relam == HEAP_TABLE_AM_OID);
        relation->rd_amhandler = HEAP_TABLE_AM_HANDLER_OID;
    }
    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);
}

RelationSetNewRelfilenode()

void RelationSetNewRelfilenode	(	Relation	relation,
		char	persistence
	)

Definition at line 3417 of file relcache.c.

References Assert, CacheInvalidateRelcache(), CatalogTupleUpdate(), CommandCounterIncrement(), elog, EOXactListAdd, ERROR, GetCurrentSubTransactionId(), GetCurrentTransactionId(), GetNewRelFileNode(), GETSTRUCT, heap_freetuple(), HeapTupleIsValid, InvalidMultiXactId, InvalidTransactionId, ObjectIdGetDatum, RelationData::rd_newRelfilenodeSubid, RelationData::rd_node, RelationData::rd_rel, 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(), and ResetSequence().

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

    switch (relation->rd_rel->relkind)
    {
        case RELKIND_INDEX:
        case RELKIND_SEQUENCE:
            {
                /* handle these directly, at least for now */
                SMgrRelation srel;

                srel = RelationCreateStorage(newrnode, persistence);
                smgrclose(srel);
            }
            break;

        case RELKIND_RELATION:
        case RELKIND_TOASTVALUE:
        case RELKIND_MATVIEW:
            table_relation_set_new_filenode(relation, &newrnode,
                                            persistence,
                                            &freezeXid, &minmulti);
            break;

        default:
            /* we shouldn't be called for anything else */
            elog(ERROR, "relation \"%s\" does not have storage",
                 RelationGetRelationName(relation));
            break;
    }

    /*
     * 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 = 0;
            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();

    /*
     * Mark the rel as having been given a new relfilenode in the current
     * (sub) transaction.  This is a hint that can be used to optimize later
     * operations on the rel in the same transaction.
     */
    relation->rd_newRelfilenodeSubid = GetCurrentSubTransactionId();

    /* Flag relation as needing eoxact cleanup (to remove the hint) */
    EOXactListAdd(relation);
}

Variable Documentation

criticalRelcachesBuilt

bool criticalRelcachesBuilt

Definition at line 140 of file relcache.c.

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

criticalSharedRelcachesBuilt

bool criticalSharedRelcachesBuilt

Definition at line 146 of file relcache.c.

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