catalog.c File Reference

#include "postgres.h"
#include <fcntl.h>
#include <unistd.h>
#include "access/genam.h"
#include "access/htup_details.h"
#include "access/table.h"
#include "access/transam.h"
#include "catalog/catalog.h"
#include "catalog/namespace.h"
#include "catalog/pg_auth_members.h"
#include "catalog/pg_authid.h"
#include "catalog/pg_database.h"
#include "catalog/pg_db_role_setting.h"
#include "catalog/pg_largeobject.h"
#include "catalog/pg_namespace.h"
#include "catalog/pg_parameter_acl.h"
#include "catalog/pg_replication_origin.h"
#include "catalog/pg_shdepend.h"
#include "catalog/pg_shdescription.h"
#include "catalog/pg_shseclabel.h"
#include "catalog/pg_subscription.h"
#include "catalog/pg_tablespace.h"
#include "catalog/pg_type.h"
#include "miscadmin.h"
#include "utils/fmgroids.h"
#include "utils/fmgrprotos.h"
#include "utils/rel.h"
#include "utils/snapmgr.h"
#include "utils/syscache.h"

Include dependency graph for catalog.c:

Go to the source code of this file.

Macros
#define	GETNEWOID_LOG_THRESHOLD   1000000
#define	GETNEWOID_LOG_MAX_INTERVAL   128000000

Functions
bool	IsSystemRelation (Relation relation)
bool	IsSystemClass (Oid relid, Form_pg_class reltuple)
bool	IsCatalogRelation (Relation relation)
bool	IsCatalogRelationOid (Oid relid)
bool	IsInplaceUpdateRelation (Relation relation)
bool	IsInplaceUpdateOid (Oid relid)
bool	IsToastRelation (Relation relation)
bool	IsToastClass (Form_pg_class reltuple)
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)
Datum	pg_nextoid (PG_FUNCTION_ARGS)
Datum	pg_stop_making_pinned_objects (PG_FUNCTION_ARGS)

Macro Definition Documentation

GETNEWOID_LOG_MAX_INTERVAL

#define GETNEWOID_LOG_MAX_INTERVAL   128000000

Definition at line 55 of file catalog.c.

GETNEWOID_LOG_THRESHOLD

#define GETNEWOID_LOG_THRESHOLD   1000000

Definition at line 54 of file catalog.c.

Function Documentation

GetNewOidWithIndex()

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

Definition at line 419 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 %llu time, but no unused OID has been found yet.",
                                      "OID candidates have been checked %llu times, but no unused OID has been found yet.",
                                      retries,
                                      (unsigned long long) 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 %llu retry",
                               "new OID has been assigned in relation \"%s\" after %llu retries",
                               retries,
                               RelationGetRelationName(relation), (unsigned long long) 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 528 of file catalog.c.

{
    RelFileLocatorBackend rlocator;
    char       *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, 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;
        }
 
        pfree(rpath);
    } 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, pfree(), ProcNumberForTempRelations, RelFileLocator::relNumber, relpath, and RelFileLocator::spcOid.

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

IsCatalogNamespace()

bool IsCatalogNamespace

(

Oid

namespaceId

)

Definition at line 212 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 103 of file catalog.c.

{
    return IsCatalogRelationOid(RelationGetRelid(relation));
}

References IsCatalogRelationOid(), and RelationGetRelid.

Referenced by CacheInvalidateHeapTuple(), check_publication_add_relation(), ExecSimpleRelationUpdate(), GlobalVisHorizonKindForRel(), heap_index_delete_tuples(), heap_multi_insert(), index_create(), needs_toast_table(), read_stream_begin_impl(), RelationInitTableAccessMethod(), and transformOnConflictArbiter().

IsCatalogRelationOid()

bool IsCatalogRelationOid

(

Oid

relid

)

Definition at line 120 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(), read_stream_begin_impl(), ReindexMultipleTables(), and ReindexRelationConcurrently().

IsInplaceUpdateOid()

bool IsInplaceUpdateOid

(

Oid

relid

)

Definition at line 162 of file catalog.c.

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

Referenced by CatalogCacheCreateEntry(), and IsInplaceUpdateRelation().

IsInplaceUpdateRelation()

bool IsInplaceUpdateRelation

(

Relation

relation

)

Definition at line 152 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 341 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(), and updateAclDependenciesWorker().

IsReservedName()

bool IsReservedName

(

const char *

name

)

Definition at line 247 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 273 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(), CacheInvalidateHeapTuple(), 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 85 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 73 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 195 of file catalog.c.

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

References IsToastNamespace().

Referenced by IsSystemClass().

IsToastNamespace()

bool IsToastNamespace

(

Oid

namespaceId

)

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

pg_nextoid()

Datum pg_nextoid

(

PG_FUNCTION_ARGS

)

Definition at line 614 of file catalog.c.

{
    Oid         reloid = PG_GETARG_OID(0);
    Name        attname = PG_GETARG_NAME(1);
    Oid         idxoid = PG_GETARG_OID(2);
    Relation    rel;
    Relation    idx;
    HeapTuple   atttuple;
    Form_pg_attribute attform;
    AttrNumber  attno;
    Oid         newoid;
 
    /*
     * As this function is not intended to be used during normal running, and
     * only supports system catalogs (which require superuser permissions to
     * modify), just checking for superuser ought to not obstruct valid
     * usecases.
     */
    if (!superuser())
        ereport(ERROR,
                (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
                 errmsg("must be superuser to call %s()",
                        "pg_nextoid")));
 
    rel = table_open(reloid, RowExclusiveLock);
    idx = index_open(idxoid, RowExclusiveLock);
 
    if (!IsSystemRelation(rel))
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                 errmsg("pg_nextoid() can only be used on system catalogs")));
 
    if (idx->rd_index->indrelid != RelationGetRelid(rel))
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                 errmsg("index \"%s\" does not belong to table \"%s\"",
                        RelationGetRelationName(idx),
                        RelationGetRelationName(rel))));
 
    atttuple = SearchSysCacheAttName(reloid, NameStr(*attname));
    if (!HeapTupleIsValid(atttuple))
        ereport(ERROR,
                (errcode(ERRCODE_UNDEFINED_COLUMN),
                 errmsg("column \"%s\" of relation \"%s\" does not exist",
                        NameStr(*attname), RelationGetRelationName(rel))));
 
    attform = ((Form_pg_attribute) GETSTRUCT(atttuple));
    attno = attform->attnum;
 
    if (attform->atttypid != OIDOID)
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                 errmsg("column \"%s\" is not of type oid",
                        NameStr(*attname))));
 
    if (IndexRelationGetNumberOfKeyAttributes(idx) != 1 ||
        idx->rd_index->indkey.values[0] != attno)
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                 errmsg("index \"%s\" is not the index for column \"%s\"",
                        RelationGetRelationName(idx),
                        NameStr(*attname))));
 
    newoid = GetNewOidWithIndex(rel, idxoid, attno);
 
    ReleaseSysCache(atttuple);
    table_close(rel, RowExclusiveLock);
    index_close(idx, RowExclusiveLock);
 
    PG_RETURN_OID(newoid);
}

References attname, ereport, errcode(), errmsg(), ERROR, GetNewOidWithIndex(), GETSTRUCT, HeapTupleIsValid, idx(), index_close(), index_open(), IndexRelationGetNumberOfKeyAttributes, IsSystemRelation(), NameStr, PG_GETARG_NAME, PG_GETARG_OID, PG_RETURN_OID, RelationGetRelationName, RelationGetRelid, ReleaseSysCache(), RowExclusiveLock, SearchSysCacheAttName(), superuser(), table_close(), and table_open().

pg_stop_making_pinned_objects()

Datum pg_stop_making_pinned_objects

(

PG_FUNCTION_ARGS

)

Definition at line 693 of file catalog.c.

{
    /*
     * Belt-and-suspenders check, since StopGeneratingPinnedObjectIds will
     * fail anyway in non-single-user mode.
     */
    if (!superuser())
        ereport(ERROR,
                (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
                 errmsg("must be superuser to call %s()",
                        "pg_stop_making_pinned_objects")));
 
    StopGeneratingPinnedObjectIds();
 
    PG_RETURN_VOID();
}

References ereport, errcode(), errmsg(), ERROR, PG_RETURN_VOID, StopGeneratingPinnedObjectIds(), and superuser().