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

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	IsCatalogRelationOid (Oid relid)

bool	IsCatalogTextUniqueIndexOid (Oid relid)

bool	IsInplaceUpdateOid (Oid relid)

bool	IsCatalogNamespace (Oid namespaceId)

bool	IsToastNamespace (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
	)

Definition at line 450 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(), GetNewObjectId(), GETNEWOID_LOG_MAX_INTERVAL, GETNEWOID_LOG_THRESHOLD, HeapTupleIsValid, IsBinaryUpgrade, IsBootstrapProcessingMode, IsSystemRelation(), sort-test::key, LOG, ObjectIdGetDatum(), RelationGetRelationName, RelationGetRelid, ScanKeyInit(), SnapshotAny, systable_beginscan(), systable_endscan(), and systable_getnext().

Referenced by AddEnumLabel(), AddRoleMems(), AssignTypeArrayOid(), AssignTypeMultirangeArrayOid(), AssignTypeMultirangeOid(), CastCreate(), CollationCreate(), ConversionCreate(), CreateAccessMethod(), CreateConstraintEntry(), createdb(), CreateForeignDataWrapper(), CreateForeignServer(), CreateOpFamily(), CreatePolicy(), CreateProceduralLanguage(), CreatePublication(), CreateRole(), CreateStatistics(), CreateSubscription(), CreateTableSpace(), CreateTransform(), CreateTriggerFiringOn(), CreateUserMapping(), DefineOpClass(), DefineTSConfiguration(), DefineTSDictionary(), DefineTSParser(), DefineTSTemplate(), EnumValuesCreate(), GetNewRelFileNumber(), insert_event_trigger_tuple(), 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
	)

Definition at line 559 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, 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 )

Definition at line 243 of file catalog.c.

{
    return namespaceId == PG_CATALOG_NAMESPACE;
}

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

◆ IsCatalogRelation()

bool IsCatalogRelation ( Relation relation )

Definition at line 104 of file catalog.c.

{
    return IsCatalogRelationOid(RelationGetRelid(relation));
}

References IsCatalogRelationOid(), and RelationGetRelid.

Referenced by CacheInvalidateHeapTupleCommon(), check_publication_add_relation(), 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 )

Definition at line 121 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 )

Definition at line 156 of file catalog.c.

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

Referenced by is_catalog_text_unique_index_oid().

◆ IsInplaceUpdateOid()

bool IsInplaceUpdateOid ( Oid relid )

Definition at line 193 of file catalog.c.

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

Referenced by IsInplaceUpdateRelation().

◆ IsInplaceUpdateRelation()

bool IsInplaceUpdateRelation ( Relation relation )

Definition at line 183 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
	)

Definition at line 372 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 FirstUnpinnedObjectId.

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

◆ IsReservedName()

bool IsReservedName ( const char * name )

Definition at line 278 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_replication_origin_create(), RenameRole(), RenameSchema(), and RenameTableSpace().

◆ IsSharedRelation()

bool IsSharedRelation ( Oid relationId )

Definition at line 304 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 == PgReplicationOriginToastTable ||
        relationId == PgReplicationOriginToastIndex ||
        relationId == PgShdescriptionToastTable ||
        relationId == PgShdescriptionToastIndex ||
        relationId == PgShseclabelToastTable ||
        relationId == PgShseclabelToastIndex ||
        relationId == PgSubscriptionToastTable ||
        relationId == PgSubscriptionToastIndex ||
        relationId == PgTablespaceToastTable ||
        relationId == PgTablespaceToastIndex)
        return true;
    return false;
}

Referenced by CacheInvalidateCatalog(), CacheInvalidateHeapTupleCommon(), classIdGetDbId(), DeleteSecurityLabel(), 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
	)

Definition at line 86 of file catalog.c.

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

References IsCatalogRelationOid(), 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 )

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(), reindex_index(), ReindexRelationConcurrently(), RelationReloadIndexInfo(), RemovePolicyById(), RemoveRewriteRuleById(), RemoveTriggerById(), and systable_inplace_update_begin().

◆ IsToastClass()

bool IsToastClass ( Form_pg_class reltuple )

Definition at line 226 of file catalog.c.

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

References IsToastNamespace().

Referenced by IsSystemClass().

◆ IsToastNamespace()

bool IsToastNamespace ( Oid namespaceId )

Definition at line 261 of file catalog.c.

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

References isTempToastNamespace().

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

◆ IsToastRelation()

bool IsToastRelation ( Relation relation )

Definition at line 206 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(), heap_abort_speculative(), heap_insert(), ReorderBufferProcessTXN(), and ReorderBufferToastAppendChunk().

Functions