catalog.h File Reference

#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.

Functions
bool	IsSystemRelation (Relation relation)
bool	IsToastRelation (Relation relation)
bool	IsCatalogRelation (Relation relation)
bool	IsInplaceUpdateRelation (Relation relation)
bool	IsSystemClass (Oid relid, Form_pg_class reltuple)
bool	IsToastClass (Form_pg_class reltuple)
bool	IsConflictLogTableClass (Form_pg_class reltuple)
bool	IsCatalogRelationOid (Oid relid)
bool	IsCatalogTextUniqueIndexOid (Oid relid)
bool	IsInplaceUpdateOid (Oid relid)
bool	IsCatalogNamespace (Oid namespaceId)
bool	IsToastNamespace (Oid namespaceId)
bool	IsConflictLogTableNamespace (Oid namespaceId)
bool	IsReservedName (const char *name)
bool	IsSharedRelation (Oid relationId)
bool	IsPinnedObject (Oid classId, Oid objectId)
Oid	GetNewOidWithIndex (Relation relation, Oid indexId, AttrNumber oidcolumn)
RelFileNumber	GetNewRelFileNumber (Oid reltablespace, Relation pg_class, char relpersistence)

Function Documentation

GetNewOidWithIndex()

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

extern

Definition at line 475 of file catalog.c.

{
    Oid         newOid;
    SysScanDesc scan;
    ScanKeyData key;
    bool        collides;
    uint64      retries = 0;
    uint64      retries_before_log = GETNEWOID_LOG_THRESHOLD;
 
    /* Only system relations are supported */
    Assert(IsSystemRelation(relation));
 
    /* In bootstrap mode, we don't have any indexes to use */
    if (IsBootstrapProcessingMode())
        return GetNewObjectId();
 
    /*
     * 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);
 
    /* 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 SnapshotAny */
        scan = systable_beginscan(relation, indexId, true,
                                  SnapshotAny, 1, &key);
 
        collides = HeapTupleIsValid(systable_getnext(scan));
 
        systable_endscan(scan);
 
        /*
         * Log that we iterate more than GETNEWOID_LOG_THRESHOLD but have not
         * yet found OID unused in the relation. Then repeat logging with
         * exponentially increasing intervals until we iterate more than
         * GETNEWOID_LOG_MAX_INTERVAL. Finally repeat logging every
         * GETNEWOID_LOG_MAX_INTERVAL unless an unused OID is found. This
         * logic is necessary not to fill up the server log with the similar
         * messages.
         */
        if (retries >= retries_before_log)
        {
            ereport(LOG,
                    (errmsg("still searching for an unused OID in relation \"%s\"",
                            RelationGetRelationName(relation)),
                     errdetail_plural("OID candidates have been checked %" PRIu64 " time, but no unused OID has been found yet.",
                                      "OID candidates have been checked %" PRIu64 " times, but no unused OID has been found yet.",
                                      retries,
                                      retries)));
 
            /*
             * Double the number of retries to do before logging next until it
             * reaches GETNEWOID_LOG_MAX_INTERVAL.
             */
            if (retries_before_log * 2 <= GETNEWOID_LOG_MAX_INTERVAL)
                retries_before_log *= 2;
            else
                retries_before_log += GETNEWOID_LOG_MAX_INTERVAL;
        }
 
        retries++;
    } while (collides);
 
    /*
     * If at least one log message is emitted, also log the completion of OID
     * assignment.
     */
    if (retries > GETNEWOID_LOG_THRESHOLD)
    {
        ereport(LOG,
                (errmsg_plural("new OID has been assigned in relation \"%s\" after %" PRIu64 " retry",
                               "new OID has been assigned in relation \"%s\" after %" PRIu64 " retries",
                               retries,
                               RelationGetRelationName(relation), retries)));
    }
 
    return newOid;
}

References Assert, BTEqualStrategyNumber, CHECK_FOR_INTERRUPTS, ereport, errdetail_plural(), errmsg, errmsg_plural(), fb(), GetNewObjectId(), GETNEWOID_LOG_MAX_INTERVAL, GETNEWOID_LOG_THRESHOLD, HeapTupleIsValid, IsBinaryUpgrade, IsBootstrapProcessingMode, IsSystemRelation(), LOG, ObjectIdGetDatum(), RelationGetRelationName, RelationGetRelid, ScanKeyInit(), SnapshotAny, systable_beginscan(), systable_endscan(), and systable_getnext().

Referenced by AddEnumLabel(), AddRoleMems(), AssignTypeArrayOid(), AssignTypeMultirangeArrayOid(), AssignTypeMultirangeOid(), CastCreate(), CollationCreate(), ConversionCreate(), copy_attribute_defaults(), copy_index_constraints(), CreateAccessMethod(), CreateConstraintEntry(), createdb(), CreateForeignDataWrapper(), CreateForeignServer(), CreateOpFamily(), CreatePolicy(), CreateProceduralLanguage(), CreatePublication(), CreateRole(), CreateStatistics(), CreateTableSpace(), CreateTransform(), CreateTriggerFiringOn(), CreateUserMapping(), DefineOpClass(), DefineTSConfiguration(), DefineTSDictionary(), DefineTSParser(), DefineTSTemplate(), EnumValuesCreate(), GetNewRelFileNumber(), insert_element_record(), insert_event_trigger_tuple(), insert_label_record(), insert_property_record(), InsertExtensionTuple(), InsertRule(), LargeObjectCreate(), NamespaceCreate(), OperatorCreate(), OperatorShellMake(), ParameterAclCreate(), pg_nextoid(), ProcedureCreate(), publication_add_relation(), publication_add_schema(), SetDefaultACL(), StoreAttrDefault(), storeOperators(), storeProcedures(), toast_save_datum(), TypeCreate(), and TypeShellMake().

GetNewRelFileNumber()

RelFileNumber GetNewRelFileNumber ( Oid  reltablespace, Relation  pg_class, char  relpersistence  )

extern

Definition at line 584 of file catalog.c.

{
    RelFileLocatorBackend rlocator;
    RelPathStr  rpath;
    bool        collides;
    ProcNumber  procNumber;
 
    /*
     * If we ever get here during pg_upgrade, there's something wrong; all
     * relfilenumber assignments during a binary-upgrade run should be
     * determined by commands in the dump script.
     */
    Assert(!IsBinaryUpgrade);
 
    switch (relpersistence)
    {
        case RELPERSISTENCE_TEMP:
            procNumber = ProcNumberForTempRelations();
            break;
        case RELPERSISTENCE_UNLOGGED:
        case RELPERSISTENCE_PERMANENT:
            procNumber = INVALID_PROC_NUMBER;
            break;
        default:
            elog(ERROR, "invalid relpersistence: %c", relpersistence);
            return InvalidRelFileNumber;    /* placate compiler */
    }
 
    /* This logic should match RelationInitPhysicalAddr */
    rlocator.locator.spcOid = reltablespace ? reltablespace : MyDatabaseTableSpace;
    rlocator.locator.dbOid =
        (rlocator.locator.spcOid == GLOBALTABLESPACE_OID) ?
        InvalidOid : MyDatabaseId;
 
    /*
     * The relpath will vary based on the backend number, so we must
     * initialize that properly here to make sure that any collisions based on
     * filename are properly detected.
     */
    rlocator.backend = procNumber;
 
    do
    {
        CHECK_FOR_INTERRUPTS();
 
        /* Generate the OID */
        if (pg_class)
            rlocator.locator.relNumber = GetNewOidWithIndex(pg_class, ClassOidIndexId,
                                                            Anum_pg_class_oid);
        else
            rlocator.locator.relNumber = GetNewObjectId();
 
        /* Check for existing file of same name */
        rpath = relpath(rlocator, MAIN_FORKNUM);
 
        if (access(rpath.str, F_OK) == 0)
        {
            /* definite collision */
            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
             * 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;
        }
    } while (collides);
 
    return rlocator.locator.relNumber;
}

References Assert, RelFileLocatorBackend::backend, CHECK_FOR_INTERRUPTS, RelFileLocator::dbOid, elog, ERROR, fb(), GetNewObjectId(), GetNewOidWithIndex(), INVALID_PROC_NUMBER, InvalidOid, InvalidRelFileNumber, IsBinaryUpgrade, RelFileLocatorBackend::locator, MAIN_FORKNUM, MyDatabaseId, MyDatabaseTableSpace, ProcNumberForTempRelations, RelFileLocator::relNumber, relpath, RelFileLocator::spcOid, and RelPathStr::str.

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

IsCatalogNamespace()

bool IsCatalogNamespace ( Oid  namespaceId )

extern

Definition at line 259 of file catalog.c.

{
    return namespaceId == PG_CATALOG_NAMESPACE;
}

References fb().

Referenced by AlterTableMoveAll(), check_publication_add_schema(), heap_create(), and RelationBuildLocalRelation().

IsCatalogRelation()

bool IsCatalogRelation ( Relation  relation )

extern

Definition at line 106 of file catalog.c.

{
    return IsCatalogRelationOid(RelationGetRelid(relation));
}

References IsCatalogRelationOid(), and RelationGetRelid.

Referenced by CacheInvalidateHeapTupleCommon(), check_concurrent_repack_requirements(), check_publication_add_relation(), cluster_rel(), ExecSimpleRelationUpdate(), GlobalVisHorizonKindForRel(), heap_index_delete_tuples(), heap_multi_insert(), index_create(), needs_toast_table(), read_stream_begin_impl(), RelationBuildTupleDesc(), RelationInitTableAccessMethod(), and transformOnConflictArbiter().

IsCatalogRelationOid()

bool IsCatalogRelationOid ( Oid  relid )

extern

Definition at line 123 of file catalog.c.

{
    /*
     * We consider a relation to be a system catalog if it has a pinned OID.
     * This includes all the defined catalogs, their indexes, and their TOAST
     * tables and indexes.
     *
     * This rule excludes the relations in information_schema, which are not
     * integral to the system and can be treated the same as user relations.
     * (Since it's valid to drop and recreate information_schema, any rule
     * that did not act this way would be wrong.)
     *
     * This test is reliable since an OID wraparound will skip this range of
     * OIDs; see GetNewObjectId().
     */
    return (relid < (Oid) FirstUnpinnedObjectId);
}

References FirstUnpinnedObjectId.

Referenced by check_relation_privileges(), is_publishable_class(), IsCatalogRelation(), IsSystemClass(), populate_compact_attribute_internal(), read_stream_begin_impl(), ReindexMultipleTables(), and ReindexRelationConcurrently().

IsCatalogTextUniqueIndexOid()

bool IsCatalogTextUniqueIndexOid ( Oid  relid )

extern

Definition at line 158 of file catalog.c.

{
    switch (relid)
    {
        case ParameterAclParnameIndexId:
        case ReplicationOriginNameIndex:
        case SecLabelObjectIndexId:
        case SharedSecLabelObjectIndexId:
            return true;
    }
    return false;
}

References fb().

Referenced by is_catalog_text_unique_index_oid().

IsConflictLogTableClass()

bool IsConflictLogTableClass ( Form_pg_class  reltuple )

extern

Definition at line 242 of file catalog.c.

{
    Oid         relnamespace = reltuple->relnamespace;
 
    return IsConflictLogTableNamespace(relnamespace);
}

References fb(), and IsConflictLogTableNamespace().

Referenced by ATAddForeignKeyConstraint(), ATSimplePermissions(), CreateStatistics(), CreateTriggerFiringOn(), DefineQueryRewrite(), is_publishable_class(), IsSystemClass(), pg_class_aclmask_ext(), RangeVarCallbackForAlterRelation(), RangeVarCallbackForPolicy(), RangeVarCallbackForRenameRule(), RangeVarCallbackForRenameTrigger(), RangeVarCallbackOwnsRelation(), renameatt_check(), and truncate_check_rel().

IsConflictLogTableNamespace()

bool IsConflictLogTableNamespace ( Oid  namespaceId )

extern

Definition at line 290 of file catalog.c.

{
    return namespaceId == PG_CONFLICT_NAMESPACE;
}

References fb().

Referenced by AlterTableMoveAll(), check_publication_add_relation(), check_publication_add_schema(), CheckValidResultRel(), CheckValidRowMarkRel(), IsConflictLogTableClass(), LockViewRecurse_walker(), MergeAttributes(), and pg_namespace_aclmask_ext().

IsInplaceUpdateOid()

bool IsInplaceUpdateOid ( Oid  relid )

extern

Definition at line 195 of file catalog.c.

{
    return (relid == RelationRelationId ||
            relid == DatabaseRelationId);
}

References fb().

Referenced by IsInplaceUpdateRelation().

IsInplaceUpdateRelation()

bool IsInplaceUpdateRelation ( Relation  relation )

extern

Definition at line 185 of file catalog.c.

{
    return IsInplaceUpdateOid(RelationGetRelid(relation));
}

References IsInplaceUpdateOid(), and RelationGetRelid.

Referenced by CheckValidResultRel(), InitResultRelInfo(), and systable_inplace_update_begin().

IsPinnedObject()

bool IsPinnedObject ( Oid  classId, Oid  objectId  )

extern

Definition at line 397 of file catalog.c.

{
    /*
     * Objects with OIDs above FirstUnpinnedObjectId are never pinned.  Since
     * the OID generator skips this range when wrapping around, this check
     * guarantees that user-defined objects are never considered pinned.
     */
    if (objectId >= FirstUnpinnedObjectId)
        return false;
 
    /*
     * Large objects are never pinned.  We need this special case because
     * their OIDs can be user-assigned.
     */
    if (classId == LargeObjectRelationId)
        return false;
 
    /*
     * There are a few objects defined in the catalog .dat files that, as a
     * matter of policy, we prefer not to treat as pinned.  We used to handle
     * that by excluding them from pg_depend, but it's just as easy to
     * hard-wire their OIDs here.  (If the user does indeed drop and recreate
     * them, they'll have new but certainly-unpinned OIDs, so no problem.)
     *
     * Checking both classId and objectId is overkill, since OIDs below
     * FirstGenbkiObjectId should be globally unique, but do it anyway for
     * robustness.
     */
 
    /* the public namespace is not pinned */
    if (classId == NamespaceRelationId &&
        objectId == PG_PUBLIC_NAMESPACE)
        return false;
 
    /*
     * Databases are never pinned.  It might seem that it'd be prudent to pin
     * at least template0; but we do this intentionally so that template0 and
     * template1 can be rebuilt from each other, thus letting them serve as
     * mutual backups (as long as you've not modified template1, anyway).
     */
    if (classId == DatabaseRelationId)
        return false;
 
    /*
     * All other initdb-created objects are pinned.  This is overkill (the
     * system doesn't really depend on having every last weird datatype, for
     * instance) but generating only the minimum required set of dependencies
     * seems hard, and enforcing an accurate list would be much more expensive
     * than the simple range test used here.
     */
    return true;
}

References fb(), and FirstUnpinnedObjectId.

Referenced by checkSharedDependencies(), dependencyLockAndCheckObject(), DropTableSpace(), findDependentObjects(), isObjectPinned(), recordSharedDependencyOn(), shdepChangeDep(), shdepDropOwned(), shdepReassignOwned(), typeDepNeeded(), and updateAclDependenciesWorker().

IsReservedName()

bool IsReservedName ( const char *  name )

extern

Definition at line 305 of file catalog.c.

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

References name.

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

IsSharedRelation()

bool IsSharedRelation ( Oid  relationId )

extern

Definition at line 331 of file catalog.c.

{
    /* These are the shared catalogs (look for BKI_SHARED_RELATION) */
    if (relationId == AuthIdRelationId ||
        relationId == AuthMemRelationId ||
        relationId == DatabaseRelationId ||
        relationId == DbRoleSettingRelationId ||
        relationId == ParameterAclRelationId ||
        relationId == ReplicationOriginRelationId ||
        relationId == SharedDependRelationId ||
        relationId == SharedDescriptionRelationId ||
        relationId == SharedSecLabelRelationId ||
        relationId == SubscriptionRelationId ||
        relationId == TableSpaceRelationId)
        return true;
    /* These are their indexes */
    if (relationId == AuthIdOidIndexId ||
        relationId == AuthIdRolnameIndexId ||
        relationId == AuthMemMemRoleIndexId ||
        relationId == AuthMemRoleMemIndexId ||
        relationId == AuthMemOidIndexId ||
        relationId == AuthMemGrantorIndexId ||
        relationId == DatabaseNameIndexId ||
        relationId == DatabaseOidIndexId ||
        relationId == DbRoleSettingDatidRolidIndexId ||
        relationId == ParameterAclOidIndexId ||
        relationId == ParameterAclParnameIndexId ||
        relationId == ReplicationOriginIdentIndex ||
        relationId == ReplicationOriginNameIndex ||
        relationId == SharedDependDependerIndexId ||
        relationId == SharedDependReferenceIndexId ||
        relationId == SharedDescriptionObjIndexId ||
        relationId == SharedSecLabelObjectIndexId ||
        relationId == SubscriptionNameIndexId ||
        relationId == SubscriptionObjectIndexId ||
        relationId == TablespaceNameIndexId ||
        relationId == TablespaceOidIndexId)
        return true;
    /* These are their toast tables and toast indexes */
    if (relationId == PgDatabaseToastTable ||
        relationId == PgDatabaseToastIndex ||
        relationId == PgDbRoleSettingToastTable ||
        relationId == PgDbRoleSettingToastIndex ||
        relationId == PgParameterAclToastTable ||
        relationId == PgParameterAclToastIndex ||
        relationId == PgShdescriptionToastTable ||
        relationId == PgShdescriptionToastIndex ||
        relationId == PgShseclabelToastTable ||
        relationId == PgShseclabelToastIndex ||
        relationId == PgSubscriptionToastTable ||
        relationId == PgSubscriptionToastIndex ||
        relationId == PgTablespaceToastTable ||
        relationId == PgTablespaceToastIndex)
        return true;
    return false;
}

References fb().

Referenced by CacheInvalidateCatalog(), CacheInvalidateHeapTupleCommon(), classIdGetDbId(), DeleteSecurityLabel(), dependencyLockAndCheckObject(), findDependentObjects(), get_object_address(), GetSecurityLabel(), pg_stat_reset_single_table_counters(), pgstat_fetch_stat_tabentry(), RelationBuildLocalRelation(), SetLocktagRelationOid(), SetSecurityLabel(), and UpdateLogicalMappings().

IsSystemClass()

bool IsSystemClass ( Oid  relid, Form_pg_class  reltuple  )

extern

Definition at line 86 of file catalog.c.

{
    /* IsCatalogRelationOid is a bit faster, so test that first */
    return (IsCatalogRelationOid(relid) ||
            IsToastClass(reltuple) ||
            IsConflictLogTableClass(reltuple));
}

References fb(), IsCatalogRelationOid(), IsConflictLogTableClass(), and IsToastClass().

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

IsSystemRelation()

bool IsSystemRelation ( Relation  relation )

extern

Definition at line 74 of file catalog.c.

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

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

Referenced by ATAddForeignKeyConstraint(), ATRewriteTables(), ATSimplePermissions(), CreateStatistics(), CreateTriggerFiringOn(), DefineQueryRewrite(), get_relation_info(), GetNewOidWithIndex(), heapam_index_build_range_scan(), heapam_relation_copy_for_cluster(), index_constraint_create(), index_create(), pg_nextoid(), rebuild_relation(), rebuild_relation_finish_concurrent(), reindex_index(), ReindexRelationConcurrently(), RelationReloadIndexInfo(), RemovePolicyById(), RemoveRewriteRuleById(), RemoveTriggerById(), and systable_inplace_update_begin().

IsToastClass()

bool IsToastClass ( Form_pg_class  reltuple )

extern

Definition at line 228 of file catalog.c.

{
    Oid         relnamespace = reltuple->relnamespace;
 
    return IsToastNamespace(relnamespace);
}

References fb(), and IsToastNamespace().

Referenced by IsSystemClass().

IsToastNamespace()

bool IsToastNamespace ( Oid  namespaceId )

extern

Definition at line 277 of file catalog.c.

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

References fb(), and isTempToastNamespace().

Referenced by AlterTableMoveAll(), check_publication_add_schema(), heap_create(), IsToastClass(), IsToastRelation(), reindex_index(), reindex_relation(), and ReindexRelationConcurrently().

IsToastRelation()

bool IsToastRelation ( Relation  relation )

extern

Definition at line 208 of file catalog.c.

{
    /*
     * What we actually check is whether the relation belongs to a pg_toast
     * namespace.  This should be equivalent because of restrictions that are
     * enforced elsewhere against creating user relations in, or moving
     * relations into/out of, a pg_toast namespace.  Notice also that this
     * will not say "true" for toast tables belonging to other sessions' temp
     * tables; we expect that other mechanisms will prevent access to those.
     */
    return IsToastNamespace(RelationGetNamespace(relation));
}

References IsToastNamespace(), and RelationGetNamespace.

Referenced by CacheInvalidateHeapTupleCommon(), check_concurrent_repack_requirements(), heap_abort_speculative(), heap_insert(), ReorderBufferProcessTXN(), and ReorderBufferToastAppendChunk().