catalog.h File Reference

#include "catalog/catversion.h"
#include "catalog/pg_class.h"
#include "utils/relcache.h"

Include dependency graph for catalog.h:

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

Go to the source code of this file.

Macros
#define	OIDCHARS   10 /* max chars printed by %u */
#define	TABLESPACE_VERSION_DIRECTORY

Functions
bool	IsSystemRelation (Relation relation)
bool	IsToastRelation (Relation relation)
bool	IsCatalogRelation (Relation relation)
bool	IsSystemClass (Oid relid, Form_pg_class reltuple)
bool	IsToastClass (Form_pg_class reltuple)
bool	IsCatalogClass (Oid relid, Form_pg_class reltuple)
bool	IsSystemNamespace (Oid namespaceId)
bool	IsToastNamespace (Oid namespaceId)
bool	IsReservedName (const char *name)
bool	IsSharedRelation (Oid relationId)
Oid	GetNewOid (Relation relation)
Oid	GetNewOidWithIndex (Relation relation, Oid indexId, AttrNumber oidcolumn)
Oid	GetNewRelFileNode (Oid reltablespace, Relation pg_class, char relpersistence)

Macro Definition Documentation

#define OIDCHARS   10 /* max chars printed by %u */

Definition at line 25 of file catalog.h.

Referenced by CreateTableSpace(), parse_filename_for_nontemp_relation(), and ResetUnloggedRelationsInDbspaceDir().

#define TABLESPACE_VERSION_DIRECTORY

Value:

"PG_" PG_MAJORVERSION "_" \
									CppAsString2(CATALOG_VERSION_NO)

Definition at line 26 of file catalog.h.

Referenced by calculate_database_size(), calculate_tablespace_size(), create_tablespace_directories(), CreateTableSpace(), destroy_tablespace_directories(), GetDatabasePath(), GetRelationPath(), OpenTemporaryFileInTablespace(), pg_tablespace_databases(), RelationCacheInitFileRemove(), RemovePgTempFiles(), ResetUnloggedRelations(), and sendTablespace().

Function Documentation

Oid GetNewOid

(

Relation

relation

)

Definition at line 289 of file catalog.c.

References Assert, elog, GetNewObjectId(), GetNewOidWithIndex(), IsBootstrapProcessingMode, IsSystemRelation(), ObjectIdAttributeNumber, OidIsValid, RelationData::rd_rel, RelationGetOidIndex(), RelationGetRelationName, and WARNING.

Referenced by AddEnumLabel(), AssignTypeArrayOid(), createdb(), CreateTrigger(), EnumValuesCreate(), GetNewRelFileNode(), and heap_prepare_insert().

{
    Oid         oidIndex;

    /* If relation doesn't have OIDs at all, caller is confused */
    Assert(relation->rd_rel->relhasoids);

    /* In bootstrap mode, we don't have any indexes to use */
    if (IsBootstrapProcessingMode())
        return GetNewObjectId();

    /* The relcache will cache the identity of the OID index for us */
    oidIndex = RelationGetOidIndex(relation);

    /* If no OID index, just hand back the next OID counter value */
    if (!OidIsValid(oidIndex))
    {
        /*
         * System catalogs that have OIDs should *always* have a unique OID
         * index; we should only take this path for user tables. Give a
         * warning if it looks like somebody forgot an index.
         */
        if (IsSystemRelation(relation))
            elog(WARNING, "generating possibly-non-unique OID for \"%s\"",
                 RelationGetRelationName(relation));

        return GetNewObjectId();
    }

    /* Otherwise, use the index to find a nonconflicting OID */
    return GetNewOidWithIndex(relation, oidIndex, ObjectIdAttributeNumber);
}

Oid GetNewOidWithIndex	(	Relation	relation,
		Oid	indexId,
		AttrNumber	oidcolumn
	)

Definition at line 336 of file catalog.c.

References Assert, BTEqualStrategyNumber, CHECK_FOR_INTERRUPTS, GetNewObjectId(), HeapTupleIsValid, InitDirtySnapshot, IsBinaryUpgrade, ObjectIdGetDatum, RelationGetRelid, ScanKeyInit(), systable_beginscan(), systable_endscan(), systable_getnext(), and TypeRelationId.

Referenced by GetNewOid(), and toast_save_datum().

{
    Oid         newOid;
    SnapshotData SnapshotDirty;
    SysScanDesc scan;
    ScanKeyData key;
    bool        collides;

    /*
     * We should never be asked to generate a new pg_type OID during
     * pg_upgrade; doing so would risk collisions with the OIDs it wants to
     * assign.  Hitting this assert means there's some path where we failed to
     * ensure that a type OID is determined by commands in the dump script.
     */
    Assert(!IsBinaryUpgrade || RelationGetRelid(relation) != TypeRelationId);

    InitDirtySnapshot(SnapshotDirty);

    /* Generate new OIDs until we find one not in the table */
    do
    {
        CHECK_FOR_INTERRUPTS();

        newOid = GetNewObjectId();

        ScanKeyInit(&key,
                    oidcolumn,
                    BTEqualStrategyNumber, F_OIDEQ,
                    ObjectIdGetDatum(newOid));

        /* see notes above about using SnapshotDirty */
        scan = systable_beginscan(relation, indexId, true,
                                  &SnapshotDirty, 1, &key);

        collides = HeapTupleIsValid(systable_getnext(scan));

        systable_endscan(scan);
    } while (collides);

    return newOid;
}

Oid GetNewRelFileNode	(	Oid	reltablespace,
		Relation	pg_class,
		char	relpersistence
	)

Definition at line 395 of file catalog.c.

References Assert, RelFileNodeBackend::backend, BackendIdForTempRelations, BasicOpenFile(), CHECK_FOR_INTERRUPTS, close, RelFileNode::dbNode, elog, ERROR, fd(), GetNewObjectId(), GetNewOid(), GLOBALTABLESPACE_OID, InvalidBackendId, InvalidOid, IsBinaryUpgrade, MAIN_FORKNUM, MyDatabaseId, MyDatabaseTableSpace, RelFileNodeBackend::node, pfree(), PG_BINARY, RelFileNode::relNode, relpath, RELPERSISTENCE_PERMANENT, RELPERSISTENCE_TEMP, RELPERSISTENCE_UNLOGGED, and RelFileNode::spcNode.

Referenced by ATExecSetTableSpace(), heap_create_with_catalog(), index_create(), and RelationSetNewRelfilenode().

{
    RelFileNodeBackend rnode;
    char       *rpath;
    int         fd;
    bool        collides;
    BackendId   backend;

    /*
     * If we ever get here during pg_upgrade, there's something wrong; all
     * relfilenode assignments during a binary-upgrade run should be
     * determined by commands in the dump script.
     */
    Assert(!IsBinaryUpgrade);

    switch (relpersistence)
    {
        case RELPERSISTENCE_TEMP:
            backend = BackendIdForTempRelations();
            break;
        case RELPERSISTENCE_UNLOGGED:
        case RELPERSISTENCE_PERMANENT:
            backend = InvalidBackendId;
            break;
        default:
            elog(ERROR, "invalid relpersistence: %c", relpersistence);
            return InvalidOid;  /* placate compiler */
    }

    /* This logic should match RelationInitPhysicalAddr */
    rnode.node.spcNode = reltablespace ? reltablespace : MyDatabaseTableSpace;
    rnode.node.dbNode = (rnode.node.spcNode == GLOBALTABLESPACE_OID) ? InvalidOid : MyDatabaseId;

    /*
     * The relpath will vary based on the backend ID, so we must initialize
     * that properly here to make sure that any collisions based on filename
     * are properly detected.
     */
    rnode.backend = backend;

    do
    {
        CHECK_FOR_INTERRUPTS();

        /* Generate the OID */
        if (pg_class)
            rnode.node.relNode = GetNewOid(pg_class);
        else
            rnode.node.relNode = GetNewObjectId();

        /* Check for existing file of same name */
        rpath = relpath(rnode, MAIN_FORKNUM);
        fd = BasicOpenFile(rpath, O_RDONLY | PG_BINARY, 0);

        if (fd >= 0)
        {
            /* definite collision */
            close(fd);
            collides = true;
        }
        else
        {
            /*
             * Here we have a little bit of a dilemma: if errno is something
             * other than ENOENT, should we declare a collision and loop? In
             * particular one might think this advisable for, say, EPERM.
             * However there really shouldn't be any unreadable files in a
             * tablespace directory, and if the EPERM is actually complaining
             * that we can't read the directory itself, we'd be in an infinite
             * loop.  In practice it seems best to go ahead regardless of the
             * errno.  If there is a colliding file we will get an smgr
             * failure when we attempt to create the new relation file.
             */
            collides = false;
        }

        pfree(rpath);
    } while (collides);

    return rnode.node.relNode;
}

bool IsCatalogClass	(	Oid	relid,
		Form_pg_class	reltuple
	)

Definition at line 104 of file catalog.c.

References FirstNormalObjectId, IsSystemNamespace(), and IsToastNamespace().

Referenced by is_publishable_class(), IsCatalogRelation(), and IsSystemClass().

{
    Oid         relnamespace = reltuple->relnamespace;

    /*
     * Never consider relations outside pg_catalog/pg_toast to be catalog
     * relations.
     */
    if (!IsSystemNamespace(relnamespace) && !IsToastNamespace(relnamespace))
        return false;

    /* ----
     * Check whether the oid was assigned during initdb, when creating the
     * initial template database. Minus the relations in information_schema
     * excluded above, these are integral part of the system.
     * We could instead check whether the relation is pinned in pg_depend, but
     * this is noticeably cheaper and doesn't require catalog access.
     *
     * This test is safe since even an oid wraparound will preserve this
     * property (c.f. GetNewObjectId()) and it has the advantage that it works
     * correctly even if a user decides to create a relation in the pg_catalog
     * namespace.
     * ----
     */
    return relid < FirstNormalObjectId;
}

bool IsCatalogRelation

(

Relation

relation

)

Definition at line 92 of file catalog.c.

References IsCatalogClass(), RelationData::rd_rel, and RelationGetRelid.

Referenced by CacheInvalidateHeapTuple(), check_publication_add_relation(), heap_multi_insert(), heap_page_prune_opt(), and transformOnConflictArbiter().

{
    return IsCatalogClass(RelationGetRelid(relation), relation->rd_rel);
}

bool IsReservedName

(

const char *

name

)

Definition at line 194 of file catalog.c.

Referenced by check_rolespec_name(), CreateRole(), CreateSchemaCommand(), CreateTableSpace(), RenameRole(), RenameSchema(), and RenameTableSpace().

{
    /* ugly coding for speed */
    return (name[0] == 'p' &&
            name[1] == 'g' &&
            name[2] == '_');
}

bool IsSharedRelation

(

Oid

relationId

)

Definition at line 220 of file catalog.c.

References AuthIdOidIndexId, AuthIdRelationId, AuthIdRolnameIndexId, AuthMemMemRoleIndexId, AuthMemRelationId, AuthMemRoleMemIndexId, DatabaseNameIndexId, DatabaseOidIndexId, DatabaseRelationId, DbRoleSettingDatidRolidIndexId, DbRoleSettingRelationId, PgDbRoleSettingToastIndex, PgDbRoleSettingToastTable, PgShdescriptionToastIndex, PgShdescriptionToastTable, PgShseclabelToastIndex, PgShseclabelToastTable, PLTemplateNameIndexId, PLTemplateRelationId, ReplicationOriginIdentIndex, ReplicationOriginNameIndex, ReplicationOriginRelationId, SharedDependDependerIndexId, SharedDependReferenceIndexId, SharedDependRelationId, SharedDescriptionObjIndexId, SharedDescriptionRelationId, SharedSecLabelObjectIndexId, SharedSecLabelRelationId, SubscriptionNameIndexId, SubscriptionObjectIndexId, SubscriptionRelationId, TablespaceNameIndexId, TablespaceOidIndexId, and TableSpaceRelationId.

Referenced by CacheInvalidateCatalog(), CacheInvalidateHeapTuple(), classIdGetDbId(), DeleteSecurityLabel(), get_object_address(), GetSecurityLabel(), RelationBuildLocalRelation(), SetLocktagRelationOid(), SetSecurityLabel(), and UpdateLogicalMappings().

{
    /* These are the shared catalogs (look for BKI_SHARED_RELATION) */
    if (relationId == AuthIdRelationId ||
        relationId == AuthMemRelationId ||
        relationId == DatabaseRelationId ||
        relationId == PLTemplateRelationId ||
        relationId == SharedDescriptionRelationId ||
        relationId == SharedDependRelationId ||
        relationId == SharedSecLabelRelationId ||
        relationId == TableSpaceRelationId ||
        relationId == DbRoleSettingRelationId ||
        relationId == ReplicationOriginRelationId ||
        relationId == SubscriptionRelationId)
        return true;
    /* These are their indexes (see indexing.h) */
    if (relationId == AuthIdRolnameIndexId ||
        relationId == AuthIdOidIndexId ||
        relationId == AuthMemRoleMemIndexId ||
        relationId == AuthMemMemRoleIndexId ||
        relationId == DatabaseNameIndexId ||
        relationId == DatabaseOidIndexId ||
        relationId == PLTemplateNameIndexId ||
        relationId == SharedDescriptionObjIndexId ||
        relationId == SharedDependDependerIndexId ||
        relationId == SharedDependReferenceIndexId ||
        relationId == SharedSecLabelObjectIndexId ||
        relationId == TablespaceOidIndexId ||
        relationId == TablespaceNameIndexId ||
        relationId == DbRoleSettingDatidRolidIndexId ||
        relationId == ReplicationOriginIdentIndex ||
        relationId == ReplicationOriginNameIndex ||
        relationId == SubscriptionObjectIndexId ||
        relationId == SubscriptionNameIndexId)
        return true;
    /* These are their toast tables and toast indexes (see toasting.h) */
    if (relationId == PgShdescriptionToastTable ||
        relationId == PgShdescriptionToastIndex ||
        relationId == PgDbRoleSettingToastTable ||
        relationId == PgDbRoleSettingToastIndex ||
        relationId == PgShseclabelToastTable ||
        relationId == PgShseclabelToastIndex)
        return true;
    return false;
}

bool IsSystemClass	(	Oid	relid,
		Form_pg_class	reltuple
	)

Definition at line 75 of file catalog.c.

References IsCatalogClass(), and IsToastClass().

Referenced by IsSystemRelation(), pg_class_aclmask(), RangeVarCallbackForAlterRelation(), RangeVarCallbackForDropRelation(), RangeVarCallbackForPolicy(), RangeVarCallbackForRenameRule(), RangeVarCallbackForRenameTrigger(), RangeVarCallbackOwnsRelation(), ReindexMultipleTables(), renameatt_check(), and swap_relation_files().

{
    return IsToastClass(reltuple) || IsCatalogClass(relid, reltuple);
}

bool IsSystemNamespace

(

Oid

namespaceId

)

Definition at line 163 of file catalog.c.

References PG_CATALOG_NAMESPACE.

Referenced by AlterTableMoveAll(), check_relation_privileges(), heap_create(), IsCatalogClass(), and RelationBuildLocalRelation().

{
    return namespaceId == PG_CATALOG_NAMESPACE;
}

bool IsSystemRelation

(

Relation

relation

)

Definition at line 63 of file catalog.c.

References IsSystemClass(), RelationData::rd_rel, and RelationGetRelid.

Referenced by ATAddForeignKeyConstraint(), ATRewriteTables(), ATSimplePermissions(), copy_heap_data(), CreateTrigger(), DefineQueryRewrite(), get_relation_info(), GetNewOid(), index_constraint_create(), index_create(), IndexBuildHeapRangeScan(), rebuild_relation(), RelationReloadIndexInfo(), RemovePolicyById(), RemoveRoleFromObjectPolicy(), RemoveTriggerById(), and truncate_check_rel().

{
    return IsSystemClass(RelationGetRelid(relation), relation->rd_rel);
}

bool IsToastClass

(

Form_pg_class

reltuple

)

Definition at line 148 of file catalog.c.

References IsToastNamespace().

Referenced by IsSystemClass().

{
    Oid         relnamespace = reltuple->relnamespace;

    return IsToastNamespace(relnamespace);
}

bool IsToastNamespace

(

Oid

namespaceId

)

Definition at line 177 of file catalog.c.

References isTempToastNamespace(), and PG_TOAST_NAMESPACE.

Referenced by heap_create(), IsCatalogClass(), IsToastClass(), and IsToastRelation().

{
    return (namespaceId == PG_TOAST_NAMESPACE) ||
        isTempToastNamespace(namespaceId);
}

bool IsToastRelation

(

Relation

relation

)

Definition at line 136 of file catalog.c.

References IsToastNamespace(), and RelationGetNamespace.

Referenced by CacheInvalidateHeapTuple(), heap_abort_speculative(), ReorderBufferCommit(), and ReorderBufferToastAppendChunk().

{
    return IsToastNamespace(RelationGetNamespace(relation));
}