tablecmds.h File Reference

#include "access/htup.h"
#include "catalog/dependency.h"
#include "catalog/objectaddress.h"
#include "nodes/parsenodes.h"
#include "storage/lock.h"
#include "utils/relcache.h"

Include dependency graph for tablecmds.h:

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

Go to the source code of this file.

Typedefs
typedef struct AlterTableUtilityContext	AlterTableUtilityContext

Functions
ObjectAddress	DefineRelation (CreateStmt *stmt, char relkind, Oid ownerId, ObjectAddress *typaddress, const char *queryString)
TupleDesc	BuildDescForRelation (const List *columns)
void	RemoveRelations (DropStmt *drop)
Oid	AlterTableLookupRelation (AlterTableStmt *stmt, LOCKMODE lockmode)
void	AlterTable (AlterTableStmt *stmt, LOCKMODE lockmode, AlterTableUtilityContext *context)
LOCKMODE	AlterTableGetLockLevel (List *cmds)
void	ATExecChangeOwner (Oid relationOid, Oid newOwnerId, bool recursing, LOCKMODE lockmode)
void	AlterTableInternal (Oid relid, List *cmds, bool recurse)
Oid	AlterTableMoveAll (AlterTableMoveAllStmt *stmt)
ObjectAddress	AlterTableNamespace (AlterObjectSchemaStmt *stmt, Oid *oldschema)
void	AlterTableNamespaceInternal (Relation rel, Oid oldNspOid, Oid nspOid, ObjectAddresses *objsMoved)
void	AlterRelationNamespaceInternal (Relation classRel, Oid relOid, Oid oldNspOid, Oid newNspOid, bool hasDependEntry, ObjectAddresses *objsMoved)
void	CheckTableNotInUse (Relation rel, const char *stmt)
void	ExecuteTruncate (TruncateStmt *stmt)
void	ExecuteTruncateGuts (List *explicit_rels, List *relids, List *relids_logged, DropBehavior behavior, bool restart_seqs, bool run_as_table_owner)
void	SetRelationHasSubclass (Oid relationId, bool relhassubclass)
bool	CheckRelationTableSpaceMove (Relation rel, Oid newTableSpaceId)
void	SetRelationTableSpace (Relation rel, Oid newTableSpaceId, RelFileNumber newRelFilenumber)
ObjectAddress	renameatt (RenameStmt *stmt)
ObjectAddress	RenameConstraint (RenameStmt *stmt)
ObjectAddress	RenameRelation (RenameStmt *stmt)
void	RenameRelationInternal (Oid myrelid, const char *newrelname, bool is_internal, bool is_index)
void	ResetRelRewrite (Oid myrelid)
void	find_composite_type_dependencies (Oid typeOid, Relation origRelation, const char *origTypeName)
void	check_of_type (HeapTuple typetuple)
void	register_on_commit_action (Oid relid, OnCommitAction action)
void	remove_on_commit_action (Oid relid)
void	PreCommit_on_commit_actions (void)
void	AtEOXact_on_commit_actions (bool isCommit)
void	AtEOSubXact_on_commit_actions (bool isCommit, SubTransactionId mySubid, SubTransactionId parentSubid)
void	RangeVarCallbackMaintainsTable (const RangeVar *relation, Oid relId, Oid oldRelId, void *arg)
void	RangeVarCallbackOwnsRelation (const RangeVar *relation, Oid relId, Oid oldRelId, void *arg)
bool	PartConstraintImpliedByRelConstraint (Relation scanrel, List *partConstraint)

Typedef Documentation

AlterTableUtilityContext

typedef struct AlterTableUtilityContext AlterTableUtilityContext

Definition at line 24 of file tablecmds.h.

Function Documentation

AlterRelationNamespaceInternal()

void AlterRelationNamespaceInternal	(	Relation	classRel,
		Oid	relOid,
		Oid	oldNspOid,
		Oid	newNspOid,
		bool	hasDependEntry,
		ObjectAddresses *	objsMoved
	)

Definition at line 19080 of file tablecmds.c.

{
    HeapTuple   classTup;
    Form_pg_class classForm;
    ObjectAddress thisobj;
    bool        already_done = false;
 
    /* no rel lock for relkind=c so use LOCKTAG_TUPLE */
    classTup = SearchSysCacheLockedCopy1(RELOID, ObjectIdGetDatum(relOid));
    if (!HeapTupleIsValid(classTup))
        elog(ERROR, "cache lookup failed for relation %u", relOid);
    classForm = (Form_pg_class) GETSTRUCT(classTup);
 
    Assert(classForm->relnamespace == oldNspOid);
 
    thisobj.classId = RelationRelationId;
    thisobj.objectId = relOid;
    thisobj.objectSubId = 0;
 
    /*
     * If the object has already been moved, don't move it again.  If it's
     * already in the right place, don't move it, but still fire the object
     * access hook.
     */
    already_done = object_address_present(&thisobj, objsMoved);
    if (!already_done && oldNspOid != newNspOid)
    {
        ItemPointerData otid = classTup->t_self;
 
        /* check for duplicate name (more friendly than unique-index failure) */
        if (get_relname_relid(NameStr(classForm->relname),
                              newNspOid) != InvalidOid)
            ereport(ERROR,
                    (errcode(ERRCODE_DUPLICATE_TABLE),
                     errmsg("relation \"%s\" already exists in schema \"%s\"",
                            NameStr(classForm->relname),
                            get_namespace_name(newNspOid))));
 
        /* classTup is a copy, so OK to scribble on */
        classForm->relnamespace = newNspOid;
 
        CatalogTupleUpdate(classRel, &otid, classTup);
        UnlockTuple(classRel, &otid, InplaceUpdateTupleLock);
 
 
        /* Update dependency on schema if caller said so */
        if (hasDependEntry &&
            changeDependencyFor(RelationRelationId,
                                relOid,
                                NamespaceRelationId,
                                oldNspOid,
                                newNspOid) != 1)
            elog(ERROR, "could not change schema dependency for relation \"%s\"",
                 NameStr(classForm->relname));
    }
    else
        UnlockTuple(classRel, &classTup->t_self, InplaceUpdateTupleLock);
    if (!already_done)
    {
        add_exact_object_address(&thisobj, objsMoved);
 
        InvokeObjectPostAlterHook(RelationRelationId, relOid, 0);
    }
 
    heap_freetuple(classTup);
}

References add_exact_object_address(), Assert(), CatalogTupleUpdate(), changeDependencyFor(), ObjectAddress::classId, elog, ereport, errcode(), errmsg(), ERROR, get_namespace_name(), get_relname_relid(), GETSTRUCT(), heap_freetuple(), HeapTupleIsValid, InplaceUpdateTupleLock, InvalidOid, InvokeObjectPostAlterHook, NameStr, object_address_present(), ObjectAddress::objectId, ObjectIdGetDatum(), ObjectAddress::objectSubId, SearchSysCacheLockedCopy1(), HeapTupleData::t_self, and UnlockTuple().

Referenced by AlterIndexNamespaces(), AlterSeqNamespaces(), AlterTableNamespaceInternal(), and AlterTypeNamespaceInternal().

AlterTable()

void AlterTable	(	AlterTableStmt *	stmt,
		LOCKMODE	lockmode,
		AlterTableUtilityContext *	context
	)

Definition at line 4531 of file tablecmds.c.

{
    Relation    rel;
 
    /* Caller is required to provide an adequate lock. */
    rel = relation_open(context->relid, NoLock);
 
    CheckAlterTableIsSafe(rel);
 
    ATController(stmt, rel, stmt->cmds, stmt->relation->inh, lockmode, context);
}

References ATController(), CheckAlterTableIsSafe(), NoLock, relation_open(), AlterTableUtilityContext::relid, and stmt.

Referenced by ProcessUtilitySlow().

AlterTableGetLockLevel()

LOCKMODE AlterTableGetLockLevel

(

List *

cmds

)

Definition at line 4605 of file tablecmds.c.

{
    /*
     * This only works if we read catalog tables using MVCC snapshots.
     */
    ListCell   *lcmd;
    LOCKMODE    lockmode = ShareUpdateExclusiveLock;
 
    foreach(lcmd, cmds)
    {
        AlterTableCmd *cmd = (AlterTableCmd *) lfirst(lcmd);
        LOCKMODE    cmd_lockmode = AccessExclusiveLock; /* default for compiler */
 
        switch (cmd->subtype)
        {
                /*
                 * These subcommands rewrite the heap, so require full locks.
                 */
            case AT_AddColumn:  /* may rewrite heap, in some cases and visible
                                 * to SELECT */
            case AT_SetAccessMethod:    /* must rewrite heap */
            case AT_SetTableSpace:  /* must rewrite heap */
            case AT_AlterColumnType:    /* must rewrite heap */
                cmd_lockmode = AccessExclusiveLock;
                break;
 
                /*
                 * These subcommands may require addition of toast tables. If
                 * we add a toast table to a table currently being scanned, we
                 * might miss data added to the new toast table by concurrent
                 * insert transactions.
                 */
            case AT_SetStorage: /* may add toast tables, see
                                 * ATRewriteCatalogs() */
                cmd_lockmode = AccessExclusiveLock;
                break;
 
                /*
                 * Removing constraints can affect SELECTs that have been
                 * optimized assuming the constraint holds true. See also
                 * CloneFkReferenced.
                 */
            case AT_DropConstraint: /* as DROP INDEX */
            case AT_DropNotNull:    /* may change some SQL plans */
                cmd_lockmode = AccessExclusiveLock;
                break;
 
                /*
                 * Subcommands that may be visible to concurrent SELECTs
                 */
            case AT_DropColumn: /* change visible to SELECT */
            case AT_AddColumnToView:    /* CREATE VIEW */
            case AT_DropOids:   /* used to equiv to DropColumn */
            case AT_EnableAlwaysRule:   /* may change SELECT rules */
            case AT_EnableReplicaRule:  /* may change SELECT rules */
            case AT_EnableRule: /* may change SELECT rules */
            case AT_DisableRule:    /* may change SELECT rules */
                cmd_lockmode = AccessExclusiveLock;
                break;
 
                /*
                 * Changing owner may remove implicit SELECT privileges
                 */
            case AT_ChangeOwner:    /* change visible to SELECT */
                cmd_lockmode = AccessExclusiveLock;
                break;
 
                /*
                 * Changing foreign table options may affect optimization.
                 */
            case AT_GenericOptions:
            case AT_AlterColumnGenericOptions:
                cmd_lockmode = AccessExclusiveLock;
                break;
 
                /*
                 * These subcommands affect write operations only.
                 */
            case AT_EnableTrig:
            case AT_EnableAlwaysTrig:
            case AT_EnableReplicaTrig:
            case AT_EnableTrigAll:
            case AT_EnableTrigUser:
            case AT_DisableTrig:
            case AT_DisableTrigAll:
            case AT_DisableTrigUser:
                cmd_lockmode = ShareRowExclusiveLock;
                break;
 
                /*
                 * These subcommands affect write operations only. XXX
                 * Theoretically, these could be ShareRowExclusiveLock.
                 */
            case AT_ColumnDefault:
            case AT_CookedColumnDefault:
            case AT_AlterConstraint:
            case AT_AddIndex:   /* from ADD CONSTRAINT */
            case AT_AddIndexConstraint:
            case AT_ReplicaIdentity:
            case AT_SetNotNull:
            case AT_EnableRowSecurity:
            case AT_DisableRowSecurity:
            case AT_ForceRowSecurity:
            case AT_NoForceRowSecurity:
            case AT_AddIdentity:
            case AT_DropIdentity:
            case AT_SetIdentity:
            case AT_SetExpression:
            case AT_DropExpression:
            case AT_SetCompression:
                cmd_lockmode = AccessExclusiveLock;
                break;
 
            case AT_AddConstraint:
            case AT_ReAddConstraint:    /* becomes AT_AddConstraint */
            case AT_ReAddDomainConstraint:  /* becomes AT_AddConstraint */
                if (IsA(cmd->def, Constraint))
                {
                    Constraint *con = (Constraint *) cmd->def;
 
                    switch (con->contype)
                    {
                        case CONSTR_EXCLUSION:
                        case CONSTR_PRIMARY:
                        case CONSTR_UNIQUE:
 
                            /*
                             * Cases essentially the same as CREATE INDEX. We
                             * could reduce the lock strength to ShareLock if
                             * we can work out how to allow concurrent catalog
                             * updates. XXX Might be set down to
                             * ShareRowExclusiveLock but requires further
                             * analysis.
                             */
                            cmd_lockmode = AccessExclusiveLock;
                            break;
                        case CONSTR_FOREIGN:
 
                            /*
                             * We add triggers to both tables when we add a
                             * Foreign Key, so the lock level must be at least
                             * as strong as CREATE TRIGGER.
                             */
                            cmd_lockmode = ShareRowExclusiveLock;
                            break;
 
                        default:
                            cmd_lockmode = AccessExclusiveLock;
                    }
                }
                break;
 
                /*
                 * These subcommands affect inheritance behaviour. Queries
                 * started before us will continue to see the old inheritance
                 * behaviour, while queries started after we commit will see
                 * new behaviour. No need to prevent reads or writes to the
                 * subtable while we hook it up though. Changing the TupDesc
                 * may be a problem, so keep highest lock.
                 */
            case AT_AddInherit:
            case AT_DropInherit:
                cmd_lockmode = AccessExclusiveLock;
                break;
 
                /*
                 * These subcommands affect implicit row type conversion. They
                 * have affects similar to CREATE/DROP CAST on queries. don't
                 * provide for invalidating parse trees as a result of such
                 * changes, so we keep these at AccessExclusiveLock.
                 */
            case AT_AddOf:
            case AT_DropOf:
                cmd_lockmode = AccessExclusiveLock;
                break;
 
                /*
                 * Only used by CREATE OR REPLACE VIEW which must conflict
                 * with an SELECTs currently using the view.
                 */
            case AT_ReplaceRelOptions:
                cmd_lockmode = AccessExclusiveLock;
                break;
 
                /*
                 * These subcommands affect general strategies for performance
                 * and maintenance, though don't change the semantic results
                 * from normal data reads and writes. Delaying an ALTER TABLE
                 * behind currently active writes only delays the point where
                 * the new strategy begins to take effect, so there is no
                 * benefit in waiting. In this case the minimum restriction
                 * applies: we don't currently allow concurrent catalog
                 * updates.
                 */
            case AT_SetStatistics:  /* Uses MVCC in getTableAttrs() */
            case AT_ClusterOn:  /* Uses MVCC in getIndexes() */
            case AT_DropCluster:    /* Uses MVCC in getIndexes() */
            case AT_SetOptions: /* Uses MVCC in getTableAttrs() */
            case AT_ResetOptions:   /* Uses MVCC in getTableAttrs() */
                cmd_lockmode = ShareUpdateExclusiveLock;
                break;
 
            case AT_SetLogged:
            case AT_SetUnLogged:
                cmd_lockmode = AccessExclusiveLock;
                break;
 
            case AT_ValidateConstraint: /* Uses MVCC in getConstraints() */
                cmd_lockmode = ShareUpdateExclusiveLock;
                break;
 
                /*
                 * Rel options are more complex than first appears. Options
                 * are set here for tables, views and indexes; for historical
                 * reasons these can all be used with ALTER TABLE, so we can't
                 * decide between them using the basic grammar.
                 */
            case AT_SetRelOptions:  /* Uses MVCC in getIndexes() and
                                     * getTables() */
            case AT_ResetRelOptions:    /* Uses MVCC in getIndexes() and
                                         * getTables() */
                cmd_lockmode = AlterTableGetRelOptionsLockLevel((List *) cmd->def);
                break;
 
            case AT_AttachPartition:
                cmd_lockmode = ShareUpdateExclusiveLock;
                break;
 
            case AT_DetachPartition:
                if (((PartitionCmd *) cmd->def)->concurrent)
                    cmd_lockmode = ShareUpdateExclusiveLock;
                else
                    cmd_lockmode = AccessExclusiveLock;
                break;
 
            case AT_DetachPartitionFinalize:
                cmd_lockmode = ShareUpdateExclusiveLock;
                break;
 
            case AT_MergePartitions:
            case AT_SplitPartition:
                cmd_lockmode = AccessExclusiveLock;
                break;
 
            default:            /* oops */
                elog(ERROR, "unrecognized alter table type: %d",
                     (int) cmd->subtype);
                break;
        }
 
        /*
         * Take the greatest lockmode from any subcommand
         */
        if (cmd_lockmode > lockmode)
            lockmode = cmd_lockmode;
    }
 
    return lockmode;
}

References AccessExclusiveLock, AlterTableGetRelOptionsLockLevel(), AT_AddColumn, AT_AddColumnToView, AT_AddConstraint, AT_AddIdentity, AT_AddIndex, AT_AddIndexConstraint, AT_AddInherit, AT_AddOf, AT_AlterColumnGenericOptions, AT_AlterColumnType, AT_AlterConstraint, AT_AttachPartition, AT_ChangeOwner, AT_ClusterOn, AT_ColumnDefault, AT_CookedColumnDefault, AT_DetachPartition, AT_DetachPartitionFinalize, AT_DisableRowSecurity, AT_DisableRule, AT_DisableTrig, AT_DisableTrigAll, AT_DisableTrigUser, AT_DropCluster, AT_DropColumn, AT_DropConstraint, AT_DropExpression, AT_DropIdentity, AT_DropInherit, AT_DropNotNull, AT_DropOf, AT_DropOids, AT_EnableAlwaysRule, AT_EnableAlwaysTrig, AT_EnableReplicaRule, AT_EnableReplicaTrig, AT_EnableRowSecurity, AT_EnableRule, AT_EnableTrig, AT_EnableTrigAll, AT_EnableTrigUser, AT_ForceRowSecurity, AT_GenericOptions, AT_MergePartitions, AT_NoForceRowSecurity, AT_ReAddConstraint, AT_ReAddDomainConstraint, AT_ReplaceRelOptions, AT_ReplicaIdentity, AT_ResetOptions, AT_ResetRelOptions, AT_SetAccessMethod, AT_SetCompression, AT_SetExpression, AT_SetIdentity, AT_SetLogged, AT_SetNotNull, AT_SetOptions, AT_SetRelOptions, AT_SetStatistics, AT_SetStorage, AT_SetTableSpace, AT_SetUnLogged, AT_SplitPartition, AT_ValidateConstraint, CONSTR_EXCLUSION, CONSTR_FOREIGN, CONSTR_PRIMARY, CONSTR_UNIQUE, Constraint::contype, AlterTableCmd::def, elog, ERROR, IsA, lfirst, ShareRowExclusiveLock, ShareUpdateExclusiveLock, and AlterTableCmd::subtype.

Referenced by AlterTableInternal(), and ProcessUtilitySlow().

AlterTableInternal()

void AlterTableInternal	(	Oid	relid,
		List *	cmds,
		bool	recurse
	)

Definition at line 4560 of file tablecmds.c.

{
    Relation    rel;
    LOCKMODE    lockmode = AlterTableGetLockLevel(cmds);
 
    rel = relation_open(relid, lockmode);
 
    EventTriggerAlterTableRelid(relid);
 
    ATController(NULL, rel, cmds, recurse, lockmode, NULL);
}

References AlterTableGetLockLevel(), ATController(), EventTriggerAlterTableRelid(), and relation_open().

Referenced by AlterTableMoveAll(), and DefineVirtualRelation().

AlterTableLookupRelation()

Oid AlterTableLookupRelation	(	AlterTableStmt *	stmt,
		LOCKMODE	lockmode
	)

Definition at line 4472 of file tablecmds.c.

{
    return RangeVarGetRelidExtended(stmt->relation, lockmode,
                                    stmt->missing_ok ? RVR_MISSING_OK : 0,
                                    RangeVarCallbackForAlterRelation,
                                    stmt);
}

References RangeVarCallbackForAlterRelation(), RangeVarGetRelidExtended(), RVR_MISSING_OK, and stmt.

Referenced by ProcessUtilitySlow().

AlterTableMoveAll()

Oid AlterTableMoveAll

(

AlterTableMoveAllStmt *

stmt

)

Definition at line 17013 of file tablecmds.c.

{
    List       *relations = NIL;
    ListCell   *l;
    ScanKeyData key[1];
    Relation    rel;
    TableScanDesc scan;
    HeapTuple   tuple;
    Oid         orig_tablespaceoid;
    Oid         new_tablespaceoid;
    List       *role_oids = roleSpecsToIds(stmt->roles);
 
    /* Ensure we were not asked to move something we can't */
    if (stmt->objtype != OBJECT_TABLE && stmt->objtype != OBJECT_INDEX &&
        stmt->objtype != OBJECT_MATVIEW)
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                 errmsg("only tables, indexes, and materialized views exist in tablespaces")));
 
    /* Get the orig and new tablespace OIDs */
    orig_tablespaceoid = get_tablespace_oid(stmt->orig_tablespacename, false);
    new_tablespaceoid = get_tablespace_oid(stmt->new_tablespacename, false);
 
    /* Can't move shared relations in to or out of pg_global */
    /* This is also checked by ATExecSetTableSpace, but nice to stop earlier */
    if (orig_tablespaceoid == GLOBALTABLESPACE_OID ||
        new_tablespaceoid == GLOBALTABLESPACE_OID)
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                 errmsg("cannot move relations in to or out of pg_global tablespace")));
 
    /*
     * Must have CREATE rights on the new tablespace, unless it is the
     * database default tablespace (which all users implicitly have CREATE
     * rights on).
     */
    if (OidIsValid(new_tablespaceoid) && new_tablespaceoid != MyDatabaseTableSpace)
    {
        AclResult   aclresult;
 
        aclresult = object_aclcheck(TableSpaceRelationId, new_tablespaceoid, GetUserId(),
                                    ACL_CREATE);
        if (aclresult != ACLCHECK_OK)
            aclcheck_error(aclresult, OBJECT_TABLESPACE,
                           get_tablespace_name(new_tablespaceoid));
    }
 
    /*
     * Now that the checks are done, check if we should set either to
     * InvalidOid because it is our database's default tablespace.
     */
    if (orig_tablespaceoid == MyDatabaseTableSpace)
        orig_tablespaceoid = InvalidOid;
 
    if (new_tablespaceoid == MyDatabaseTableSpace)
        new_tablespaceoid = InvalidOid;
 
    /* no-op */
    if (orig_tablespaceoid == new_tablespaceoid)
        return new_tablespaceoid;
 
    /*
     * Walk the list of objects in the tablespace and move them. This will
     * only find objects in our database, of course.
     */
    ScanKeyInit(&key[0],
                Anum_pg_class_reltablespace,
                BTEqualStrategyNumber, F_OIDEQ,
                ObjectIdGetDatum(orig_tablespaceoid));
 
    rel = table_open(RelationRelationId, AccessShareLock);
    scan = table_beginscan_catalog(rel, 1, key);
    while ((tuple = heap_getnext(scan, ForwardScanDirection)) != NULL)
    {
        Form_pg_class relForm = (Form_pg_class) GETSTRUCT(tuple);
        Oid         relOid = relForm->oid;
 
        /*
         * Do not move objects in pg_catalog as part of this, if an admin
         * really wishes to do so, they can issue the individual ALTER
         * commands directly.
         *
         * Also, explicitly avoid any shared tables, temp tables, or TOAST
         * (TOAST will be moved with the main table).
         */
        if (IsCatalogNamespace(relForm->relnamespace) ||
            relForm->relisshared ||
            isAnyTempNamespace(relForm->relnamespace) ||
            IsToastNamespace(relForm->relnamespace))
            continue;
 
        /* Only move the object type requested */
        if ((stmt->objtype == OBJECT_TABLE &&
             relForm->relkind != RELKIND_RELATION &&
             relForm->relkind != RELKIND_PARTITIONED_TABLE) ||
            (stmt->objtype == OBJECT_INDEX &&
             relForm->relkind != RELKIND_INDEX &&
             relForm->relkind != RELKIND_PARTITIONED_INDEX) ||
            (stmt->objtype == OBJECT_MATVIEW &&
             relForm->relkind != RELKIND_MATVIEW))
            continue;
 
        /* Check if we are only moving objects owned by certain roles */
        if (role_oids != NIL && !list_member_oid(role_oids, relForm->relowner))
            continue;
 
        /*
         * Handle permissions-checking here since we are locking the tables
         * and also to avoid doing a bunch of work only to fail part-way. Note
         * that permissions will also be checked by AlterTableInternal().
         *
         * Caller must be considered an owner on the table to move it.
         */
        if (!object_ownercheck(RelationRelationId, relOid, GetUserId()))
            aclcheck_error(ACLCHECK_NOT_OWNER, get_relkind_objtype(get_rel_relkind(relOid)),
                           NameStr(relForm->relname));
 
        if (stmt->nowait &&
            !ConditionalLockRelationOid(relOid, AccessExclusiveLock))
            ereport(ERROR,
                    (errcode(ERRCODE_OBJECT_IN_USE),
                     errmsg("aborting because lock on relation \"%s.%s\" is not available",
                            get_namespace_name(relForm->relnamespace),
                            NameStr(relForm->relname))));
        else
            LockRelationOid(relOid, AccessExclusiveLock);
 
        /* Add to our list of objects to move */
        relations = lappend_oid(relations, relOid);
    }
 
    table_endscan(scan);
    table_close(rel, AccessShareLock);
 
    if (relations == NIL)
        ereport(NOTICE,
                (errcode(ERRCODE_NO_DATA_FOUND),
                 errmsg("no matching relations in tablespace \"%s\" found",
                        orig_tablespaceoid == InvalidOid ? "(database default)" :
                        get_tablespace_name(orig_tablespaceoid))));
 
    /* Everything is locked, loop through and move all of the relations. */
    foreach(l, relations)
    {
        List       *cmds = NIL;
        AlterTableCmd *cmd = makeNode(AlterTableCmd);
 
        cmd->subtype = AT_SetTableSpace;
        cmd->name = stmt->new_tablespacename;
 
        cmds = lappend(cmds, cmd);
 
        EventTriggerAlterTableStart((Node *) stmt);
        /* OID is set by AlterTableInternal */
        AlterTableInternal(lfirst_oid(l), cmds, false);
        EventTriggerAlterTableEnd();
    }
 
    return new_tablespaceoid;
}

References AccessExclusiveLock, AccessShareLock, ACL_CREATE, aclcheck_error(), ACLCHECK_NOT_OWNER, ACLCHECK_OK, AlterTableInternal(), AT_SetTableSpace, BTEqualStrategyNumber, ConditionalLockRelationOid(), ereport, errcode(), errmsg(), ERROR, EventTriggerAlterTableEnd(), EventTriggerAlterTableStart(), ForwardScanDirection, get_namespace_name(), get_rel_relkind(), get_relkind_objtype(), get_tablespace_name(), get_tablespace_oid(), GETSTRUCT(), GetUserId(), heap_getnext(), InvalidOid, isAnyTempNamespace(), IsCatalogNamespace(), IsToastNamespace(), sort-test::key, lappend(), lappend_oid(), lfirst_oid, list_member_oid(), LockRelationOid(), makeNode, MyDatabaseTableSpace, AlterTableCmd::name, NameStr, NIL, NOTICE, object_aclcheck(), OBJECT_INDEX, OBJECT_MATVIEW, object_ownercheck(), OBJECT_TABLE, OBJECT_TABLESPACE, ObjectIdGetDatum(), OidIsValid, roleSpecsToIds(), ScanKeyInit(), stmt, AlterTableCmd::subtype, table_beginscan_catalog(), table_close(), table_endscan(), and table_open().

Referenced by ProcessUtilitySlow().

AlterTableNamespace()

ObjectAddress AlterTableNamespace	(	AlterObjectSchemaStmt *	stmt,
		Oid *	oldschema
	)

Definition at line 18972 of file tablecmds.c.

{
    Relation    rel;
    Oid         relid;
    Oid         oldNspOid;
    Oid         nspOid;
    RangeVar   *newrv;
    ObjectAddresses *objsMoved;
    ObjectAddress myself;
 
    relid = RangeVarGetRelidExtended(stmt->relation, AccessExclusiveLock,
                                     stmt->missing_ok ? RVR_MISSING_OK : 0,
                                     RangeVarCallbackForAlterRelation,
                                     stmt);
 
    if (!OidIsValid(relid))
    {
        ereport(NOTICE,
                (errmsg("relation \"%s\" does not exist, skipping",
                        stmt->relation->relname)));
        return InvalidObjectAddress;
    }
 
    rel = relation_open(relid, NoLock);
 
    oldNspOid = RelationGetNamespace(rel);
 
    /* If it's an owned sequence, disallow moving it by itself. */
    if (rel->rd_rel->relkind == RELKIND_SEQUENCE)
    {
        Oid         tableId;
        int32       colId;
 
        if (sequenceIsOwned(relid, DEPENDENCY_AUTO, &tableId, &colId) ||
            sequenceIsOwned(relid, DEPENDENCY_INTERNAL, &tableId, &colId))
            ereport(ERROR,
                    (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                     errmsg("cannot move an owned sequence into another schema"),
                     errdetail("Sequence \"%s\" is linked to table \"%s\".",
                               RelationGetRelationName(rel),
                               get_rel_name(tableId))));
    }
 
    /* Get and lock schema OID and check its permissions. */
    newrv = makeRangeVar(stmt->newschema, RelationGetRelationName(rel), -1);
    nspOid = RangeVarGetAndCheckCreationNamespace(newrv, NoLock, NULL);
 
    /* common checks on switching namespaces */
    CheckSetNamespace(oldNspOid, nspOid);
 
    objsMoved = new_object_addresses();
    AlterTableNamespaceInternal(rel, oldNspOid, nspOid, objsMoved);
    free_object_addresses(objsMoved);
 
    ObjectAddressSet(myself, RelationRelationId, relid);
 
    if (oldschema)
        *oldschema = oldNspOid;
 
    /* close rel, but keep lock until commit */
    relation_close(rel, NoLock);
 
    return myself;
}

References AccessExclusiveLock, AlterTableNamespaceInternal(), CheckSetNamespace(), DEPENDENCY_AUTO, DEPENDENCY_INTERNAL, ereport, errcode(), errdetail(), errmsg(), ERROR, free_object_addresses(), get_rel_name(), InvalidObjectAddress, makeRangeVar(), new_object_addresses(), NoLock, NOTICE, ObjectAddressSet, OidIsValid, RangeVarCallbackForAlterRelation(), RangeVarGetAndCheckCreationNamespace(), RangeVarGetRelidExtended(), RelationData::rd_rel, relation_close(), relation_open(), RelationGetNamespace, RelationGetRelationName, RVR_MISSING_OK, sequenceIsOwned(), and stmt.

Referenced by ExecAlterObjectSchemaStmt().

AlterTableNamespaceInternal()

void AlterTableNamespaceInternal	(	Relation	rel,
		Oid	oldNspOid,
		Oid	nspOid,
		ObjectAddresses *	objsMoved
	)

Definition at line 19043 of file tablecmds.c.

{
    Relation    classRel;
 
    Assert(objsMoved != NULL);
 
    /* OK, modify the pg_class row and pg_depend entry */
    classRel = table_open(RelationRelationId, RowExclusiveLock);
 
    AlterRelationNamespaceInternal(classRel, RelationGetRelid(rel), oldNspOid,
                                   nspOid, true, objsMoved);
 
    /* Fix the table's row type too, if it has one */
    if (OidIsValid(rel->rd_rel->reltype))
        AlterTypeNamespaceInternal(rel->rd_rel->reltype, nspOid,
                                   false,   /* isImplicitArray */
                                   false,   /* ignoreDependent */
                                   false,   /* errorOnTableType */
                                   objsMoved);
 
    /* Fix other dependent stuff */
    AlterIndexNamespaces(classRel, rel, oldNspOid, nspOid, objsMoved);
    AlterSeqNamespaces(classRel, rel, oldNspOid, nspOid,
                       objsMoved, AccessExclusiveLock);
    AlterConstraintNamespaces(RelationGetRelid(rel), oldNspOid, nspOid,
                              false, objsMoved);
 
    table_close(classRel, RowExclusiveLock);
}

References AccessExclusiveLock, AlterConstraintNamespaces(), AlterIndexNamespaces(), AlterRelationNamespaceInternal(), AlterSeqNamespaces(), AlterTypeNamespaceInternal(), Assert(), OidIsValid, RelationData::rd_rel, RelationGetRelid, RowExclusiveLock, table_close(), and table_open().

Referenced by AlterObjectNamespace_oid(), and AlterTableNamespace().

AtEOSubXact_on_commit_actions()

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

Definition at line 19485 of file tablecmds.c.

{
    ListCell   *cur_item;
 
    foreach(cur_item, on_commits)
    {
        OnCommitItem *oc = (OnCommitItem *) lfirst(cur_item);
 
        if (!isCommit && oc->creating_subid == mySubid)
        {
            /* cur_item must be removed */
            on_commits = foreach_delete_current(on_commits, cur_item);
            pfree(oc);
        }
        else
        {
            /* cur_item must be preserved */
            if (oc->creating_subid == mySubid)
                oc->creating_subid = parentSubid;
            if (oc->deleting_subid == mySubid)
                oc->deleting_subid = isCommit ? parentSubid : InvalidSubTransactionId;
        }
    }
}

References OnCommitItem::creating_subid, OnCommitItem::deleting_subid, foreach_delete_current, InvalidSubTransactionId, lfirst, on_commits, and pfree().

Referenced by AbortSubTransaction(), and CommitSubTransaction().

AtEOXact_on_commit_actions()

void AtEOXact_on_commit_actions

(

bool

isCommit

)

Definition at line 19453 of file tablecmds.c.

{
    ListCell   *cur_item;
 
    foreach(cur_item, on_commits)
    {
        OnCommitItem *oc = (OnCommitItem *) lfirst(cur_item);
 
        if (isCommit ? oc->deleting_subid != InvalidSubTransactionId :
            oc->creating_subid != InvalidSubTransactionId)
        {
            /* cur_item must be removed */
            on_commits = foreach_delete_current(on_commits, cur_item);
            pfree(oc);
        }
        else
        {
            /* cur_item must be preserved */
            oc->creating_subid = InvalidSubTransactionId;
            oc->deleting_subid = InvalidSubTransactionId;
        }
    }
}

References OnCommitItem::creating_subid, OnCommitItem::deleting_subid, foreach_delete_current, InvalidSubTransactionId, lfirst, on_commits, and pfree().

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

ATExecChangeOwner()

void ATExecChangeOwner	(	Oid	relationOid,
		Oid	newOwnerId,
		bool	recursing,
		LOCKMODE	lockmode
	)

Definition at line 16100 of file tablecmds.c.

{
    Relation    target_rel;
    Relation    class_rel;
    HeapTuple   tuple;
    Form_pg_class tuple_class;
 
    /*
     * Get exclusive lock till end of transaction on the target table. Use
     * relation_open so that we can work on indexes and sequences.
     */
    target_rel = relation_open(relationOid, lockmode);
 
    /* Get its pg_class tuple, too */
    class_rel = table_open(RelationRelationId, RowExclusiveLock);
 
    tuple = SearchSysCache1(RELOID, ObjectIdGetDatum(relationOid));
    if (!HeapTupleIsValid(tuple))
        elog(ERROR, "cache lookup failed for relation %u", relationOid);
    tuple_class = (Form_pg_class) GETSTRUCT(tuple);
 
    /* Can we change the ownership of this tuple? */
    switch (tuple_class->relkind)
    {
        case RELKIND_RELATION:
        case RELKIND_VIEW:
        case RELKIND_MATVIEW:
        case RELKIND_FOREIGN_TABLE:
        case RELKIND_PARTITIONED_TABLE:
            /* ok to change owner */
            break;
        case RELKIND_INDEX:
            if (!recursing)
            {
                /*
                 * Because ALTER INDEX OWNER used to be allowed, and in fact
                 * is generated by old versions of pg_dump, we give a warning
                 * and do nothing rather than erroring out.  Also, to avoid
                 * unnecessary chatter while restoring those old dumps, say
                 * nothing at all if the command would be a no-op anyway.
                 */
                if (tuple_class->relowner != newOwnerId)
                    ereport(WARNING,
                            (errcode(ERRCODE_WRONG_OBJECT_TYPE),
                             errmsg("cannot change owner of index \"%s\"",
                                    NameStr(tuple_class->relname)),
                             errhint("Change the ownership of the index's table instead.")));
                /* quick hack to exit via the no-op path */
                newOwnerId = tuple_class->relowner;
            }
            break;
        case RELKIND_PARTITIONED_INDEX:
            if (recursing)
                break;
            ereport(ERROR,
                    (errcode(ERRCODE_WRONG_OBJECT_TYPE),
                     errmsg("cannot change owner of index \"%s\"",
                            NameStr(tuple_class->relname)),
                     errhint("Change the ownership of the index's table instead.")));
            break;
        case RELKIND_SEQUENCE:
            if (!recursing &&
                tuple_class->relowner != newOwnerId)
            {
                /* if it's an owned sequence, disallow changing it by itself */
                Oid         tableId;
                int32       colId;
 
                if (sequenceIsOwned(relationOid, DEPENDENCY_AUTO, &tableId, &colId) ||
                    sequenceIsOwned(relationOid, DEPENDENCY_INTERNAL, &tableId, &colId))
                    ereport(ERROR,
                            (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                             errmsg("cannot change owner of sequence \"%s\"",
                                    NameStr(tuple_class->relname)),
                             errdetail("Sequence \"%s\" is linked to table \"%s\".",
                                       NameStr(tuple_class->relname),
                                       get_rel_name(tableId))));
            }
            break;
        case RELKIND_COMPOSITE_TYPE:
            if (recursing)
                break;
            ereport(ERROR,
                    (errcode(ERRCODE_WRONG_OBJECT_TYPE),
                     errmsg("\"%s\" is a composite type",
                            NameStr(tuple_class->relname)),
            /* translator: %s is an SQL ALTER command */
                     errhint("Use %s instead.",
                             "ALTER TYPE")));
            break;
        case RELKIND_TOASTVALUE:
            if (recursing)
                break;
            /* FALL THRU */
        default:
            ereport(ERROR,
                    (errcode(ERRCODE_WRONG_OBJECT_TYPE),
                     errmsg("cannot change owner of relation \"%s\"",
                            NameStr(tuple_class->relname)),
                     errdetail_relkind_not_supported(tuple_class->relkind)));
    }
 
    /*
     * If the new owner is the same as the existing owner, consider the
     * command to have succeeded.  This is for dump restoration purposes.
     */
    if (tuple_class->relowner != newOwnerId)
    {
        Datum       repl_val[Natts_pg_class];
        bool        repl_null[Natts_pg_class];
        bool        repl_repl[Natts_pg_class];
        Acl        *newAcl;
        Datum       aclDatum;
        bool        isNull;
        HeapTuple   newtuple;
 
        /* skip permission checks when recursing to index or toast table */
        if (!recursing)
        {
            /* Superusers can always do it */
            if (!superuser())
            {
                Oid         namespaceOid = tuple_class->relnamespace;
                AclResult   aclresult;
 
                /* Otherwise, must be owner of the existing object */
                if (!object_ownercheck(RelationRelationId, relationOid, GetUserId()))
                    aclcheck_error(ACLCHECK_NOT_OWNER, get_relkind_objtype(get_rel_relkind(relationOid)),
                                   RelationGetRelationName(target_rel));
 
                /* Must be able to become new owner */
                check_can_set_role(GetUserId(), newOwnerId);
 
                /* New owner must have CREATE privilege on namespace */
                aclresult = object_aclcheck(NamespaceRelationId, namespaceOid, newOwnerId,
                                            ACL_CREATE);
                if (aclresult != ACLCHECK_OK)
                    aclcheck_error(aclresult, OBJECT_SCHEMA,
                                   get_namespace_name(namespaceOid));
            }
        }
 
        memset(repl_null, false, sizeof(repl_null));
        memset(repl_repl, false, sizeof(repl_repl));
 
        repl_repl[Anum_pg_class_relowner - 1] = true;
        repl_val[Anum_pg_class_relowner - 1] = ObjectIdGetDatum(newOwnerId);
 
        /*
         * Determine the modified ACL for the new owner.  This is only
         * necessary when the ACL is non-null.
         */
        aclDatum = SysCacheGetAttr(RELOID, tuple,
                                   Anum_pg_class_relacl,
                                   &isNull);
        if (!isNull)
        {
            newAcl = aclnewowner(DatumGetAclP(aclDatum),
                                 tuple_class->relowner, newOwnerId);
            repl_repl[Anum_pg_class_relacl - 1] = true;
            repl_val[Anum_pg_class_relacl - 1] = PointerGetDatum(newAcl);
        }
 
        newtuple = heap_modify_tuple(tuple, RelationGetDescr(class_rel), repl_val, repl_null, repl_repl);
 
        CatalogTupleUpdate(class_rel, &newtuple->t_self, newtuple);
 
        heap_freetuple(newtuple);
 
        /*
         * We must similarly update any per-column ACLs to reflect the new
         * owner; for neatness reasons that's split out as a subroutine.
         */
        change_owner_fix_column_acls(relationOid,
                                     tuple_class->relowner,
                                     newOwnerId);
 
        /*
         * Update owner dependency reference, if any.  A composite type has
         * none, because it's tracked for the pg_type entry instead of here;
         * indexes and TOAST tables don't have their own entries either.
         */
        if (tuple_class->relkind != RELKIND_COMPOSITE_TYPE &&
            tuple_class->relkind != RELKIND_INDEX &&
            tuple_class->relkind != RELKIND_PARTITIONED_INDEX &&
            tuple_class->relkind != RELKIND_TOASTVALUE)
            changeDependencyOnOwner(RelationRelationId, relationOid,
                                    newOwnerId);
 
        /*
         * Also change the ownership of the table's row type, if it has one
         */
        if (OidIsValid(tuple_class->reltype))
            AlterTypeOwnerInternal(tuple_class->reltype, newOwnerId);
 
        /*
         * If we are operating on a table or materialized view, also change
         * the ownership of any indexes and sequences that belong to the
         * relation, as well as its toast table (if it has one).
         */
        if (tuple_class->relkind == RELKIND_RELATION ||
            tuple_class->relkind == RELKIND_PARTITIONED_TABLE ||
            tuple_class->relkind == RELKIND_MATVIEW ||
            tuple_class->relkind == RELKIND_TOASTVALUE)
        {
            List       *index_oid_list;
            ListCell   *i;
 
            /* Find all the indexes belonging to this relation */
            index_oid_list = RelationGetIndexList(target_rel);
 
            /* For each index, recursively change its ownership */
            foreach(i, index_oid_list)
                ATExecChangeOwner(lfirst_oid(i), newOwnerId, true, lockmode);
 
            list_free(index_oid_list);
        }
 
        /* If it has a toast table, recurse to change its ownership */
        if (tuple_class->reltoastrelid != InvalidOid)
            ATExecChangeOwner(tuple_class->reltoastrelid, newOwnerId,
                              true, lockmode);
 
        /* If it has dependent sequences, recurse to change them too */
        change_owner_recurse_to_sequences(relationOid, newOwnerId, lockmode);
    }
 
    InvokeObjectPostAlterHook(RelationRelationId, relationOid, 0);
 
    ReleaseSysCache(tuple);
    table_close(class_rel, RowExclusiveLock);
    relation_close(target_rel, NoLock);
}

References ACL_CREATE, aclcheck_error(), ACLCHECK_NOT_OWNER, ACLCHECK_OK, aclnewowner(), AlterTypeOwnerInternal(), ATExecChangeOwner(), CatalogTupleUpdate(), change_owner_fix_column_acls(), change_owner_recurse_to_sequences(), changeDependencyOnOwner(), check_can_set_role(), DatumGetAclP, DEPENDENCY_AUTO, DEPENDENCY_INTERNAL, elog, ereport, errcode(), errdetail(), errdetail_relkind_not_supported(), errhint(), errmsg(), ERROR, get_namespace_name(), get_rel_name(), get_rel_relkind(), get_relkind_objtype(), GETSTRUCT(), GetUserId(), heap_freetuple(), heap_modify_tuple(), HeapTupleIsValid, i, InvalidOid, InvokeObjectPostAlterHook, lfirst_oid, list_free(), NameStr, NoLock, object_aclcheck(), object_ownercheck(), OBJECT_SCHEMA, ObjectIdGetDatum(), OidIsValid, PointerGetDatum(), relation_close(), relation_open(), RelationGetDescr, RelationGetIndexList(), RelationGetRelationName, ReleaseSysCache(), RowExclusiveLock, SearchSysCache1(), sequenceIsOwned(), superuser(), SysCacheGetAttr(), HeapTupleData::t_self, table_close(), table_open(), and WARNING.

Referenced by AlterTypeOwner_oid(), ATExecChangeOwner(), ATExecCmd(), change_owner_recurse_to_sequences(), and shdepReassignOwned_Owner().

BuildDescForRelation()

TupleDesc BuildDescForRelation

(

const List *

columns

)

Definition at line 1375 of file tablecmds.c.

{
    int         natts;
    AttrNumber  attnum;
    ListCell   *l;
    TupleDesc   desc;
    char       *attname;
    Oid         atttypid;
    int32       atttypmod;
    Oid         attcollation;
    int         attdim;
 
    /*
     * allocate a new tuple descriptor
     */
    natts = list_length(columns);
    desc = CreateTemplateTupleDesc(natts);
 
    attnum = 0;
 
    foreach(l, columns)
    {
        ColumnDef  *entry = lfirst(l);
        AclResult   aclresult;
        Form_pg_attribute att;
 
        /*
         * for each entry in the list, get the name and type information from
         * the list and have TupleDescInitEntry fill in the attribute
         * information we need.
         */
        attnum++;
 
        attname = entry->colname;
        typenameTypeIdAndMod(NULL, entry->typeName, &atttypid, &atttypmod);
 
        aclresult = object_aclcheck(TypeRelationId, atttypid, GetUserId(), ACL_USAGE);
        if (aclresult != ACLCHECK_OK)
            aclcheck_error_type(aclresult, atttypid);
 
        attcollation = GetColumnDefCollation(NULL, entry, atttypid);
        attdim = list_length(entry->typeName->arrayBounds);
        if (attdim > PG_INT16_MAX)
            ereport(ERROR,
                    errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
                    errmsg("too many array dimensions"));
 
        if (entry->typeName->setof)
            ereport(ERROR,
                    (errcode(ERRCODE_INVALID_TABLE_DEFINITION),
                     errmsg("column \"%s\" cannot be declared SETOF",
                            attname)));
 
        TupleDescInitEntry(desc, attnum, attname,
                           atttypid, atttypmod, attdim);
        att = TupleDescAttr(desc, attnum - 1);
 
        /* Override TupleDescInitEntry's settings as requested */
        TupleDescInitEntryCollation(desc, attnum, attcollation);
 
        /* Fill in additional stuff not handled by TupleDescInitEntry */
        att->attnotnull = entry->is_not_null;
        att->attislocal = entry->is_local;
        att->attinhcount = entry->inhcount;
        att->attidentity = entry->identity;
        att->attgenerated = entry->generated;
        att->attcompression = GetAttributeCompression(att->atttypid, entry->compression);
        if (entry->storage)
            att->attstorage = entry->storage;
        else if (entry->storage_name)
            att->attstorage = GetAttributeStorage(att->atttypid, entry->storage_name);
 
        populate_compact_attribute(desc, attnum - 1);
    }
 
    return desc;
}

References ACL_USAGE, aclcheck_error_type(), ACLCHECK_OK, TypeName::arrayBounds, attname, attnum, ColumnDef::colname, ColumnDef::compression, CreateTemplateTupleDesc(), ereport, errcode(), errmsg(), ERROR, ColumnDef::generated, GetAttributeCompression(), GetAttributeStorage(), GetColumnDefCollation(), GetUserId(), ColumnDef::identity, ColumnDef::inhcount, ColumnDef::is_local, ColumnDef::is_not_null, lfirst, list_length(), object_aclcheck(), PG_INT16_MAX, populate_compact_attribute(), TypeName::setof, ColumnDef::storage, ColumnDef::storage_name, TupleDescAttr(), TupleDescInitEntry(), TupleDescInitEntryCollation(), ColumnDef::typeName, and typenameTypeIdAndMod().

Referenced by ATExecAddColumn(), createPartitionTable(), DefineRelation(), and DefineVirtualRelation().

check_of_type()

void check_of_type

(

HeapTuple

typetuple

)

Definition at line 7171 of file tablecmds.c.

{
    Form_pg_type typ = (Form_pg_type) GETSTRUCT(typetuple);
    bool        typeOk = false;
 
    if (typ->typtype == TYPTYPE_COMPOSITE)
    {
        Relation    typeRelation;
 
        Assert(OidIsValid(typ->typrelid));
        typeRelation = relation_open(typ->typrelid, AccessShareLock);
        typeOk = (typeRelation->rd_rel->relkind == RELKIND_COMPOSITE_TYPE);
 
        /*
         * Close the parent rel, but keep our AccessShareLock on it until xact
         * commit.  That will prevent someone else from deleting or ALTERing
         * the type before the typed table creation/conversion commits.
         */
        relation_close(typeRelation, NoLock);
 
        if (!typeOk)
            ereport(ERROR,
                    (errcode(ERRCODE_WRONG_OBJECT_TYPE),
                     errmsg("type %s is the row type of another table",
                            format_type_be(typ->oid)),
                     errdetail("A typed table must use a stand-alone composite type created with CREATE TYPE.")));
    }
    else
        ereport(ERROR,
                (errcode(ERRCODE_WRONG_OBJECT_TYPE),
                 errmsg("type %s is not a composite type",
                        format_type_be(typ->oid))));
}

References AccessShareLock, Assert(), ereport, errcode(), errdetail(), errmsg(), ERROR, format_type_be(), GETSTRUCT(), NoLock, OidIsValid, RelationData::rd_rel, relation_close(), and relation_open().

Referenced by ATExecAddOf(), and transformOfType().

CheckRelationTableSpaceMove()

bool CheckRelationTableSpaceMove	(	Relation	rel,
		Oid	newTableSpaceId
	)

Definition at line 3690 of file tablecmds.c.

{
    Oid         oldTableSpaceId;
 
    /*
     * No work if no change in tablespace.  Note that MyDatabaseTableSpace is
     * stored as 0.
     */
    oldTableSpaceId = rel->rd_rel->reltablespace;
    if (newTableSpaceId == oldTableSpaceId ||
        (newTableSpaceId == MyDatabaseTableSpace && oldTableSpaceId == 0))
        return false;
 
    /*
     * We cannot support moving mapped relations into different tablespaces.
     * (In particular this eliminates all shared catalogs.)
     */
    if (RelationIsMapped(rel))
        ereport(ERROR,
                (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                 errmsg("cannot move system relation \"%s\"",
                        RelationGetRelationName(rel))));
 
    /* Cannot move a non-shared relation into pg_global */
    if (newTableSpaceId == GLOBALTABLESPACE_OID)
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                 errmsg("only shared relations can be placed in pg_global tablespace")));
 
    /*
     * Do not allow moving temp tables of other backends ... their local
     * buffer manager is not going to cope.
     */
    if (RELATION_IS_OTHER_TEMP(rel))
        ereport(ERROR,
                (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                 errmsg("cannot move temporary tables of other sessions")));
 
    return true;
}

References ereport, errcode(), errmsg(), ERROR, MyDatabaseTableSpace, RelationData::rd_rel, RELATION_IS_OTHER_TEMP, RelationGetRelationName, and RelationIsMapped.

Referenced by ATExecSetTableSpace(), ATExecSetTableSpaceNoStorage(), reindex_index(), and SetRelationTableSpace().

CheckTableNotInUse()

void CheckTableNotInUse	(	Relation	rel,
		const char *	stmt
	)

Definition at line 4413 of file tablecmds.c.

{
    int         expected_refcnt;
 
    expected_refcnt = rel->rd_isnailed ? 2 : 1;
    if (rel->rd_refcnt != expected_refcnt)
        ereport(ERROR,
                (errcode(ERRCODE_OBJECT_IN_USE),
        /* translator: first %s is a SQL command, eg ALTER TABLE */
                 errmsg("cannot %s \"%s\" because it is being used by active queries in this session",
                        stmt, RelationGetRelationName(rel))));
 
    if (rel->rd_rel->relkind != RELKIND_INDEX &&
        rel->rd_rel->relkind != RELKIND_PARTITIONED_INDEX &&
        AfterTriggerPendingOnRel(RelationGetRelid(rel)))
        ereport(ERROR,
                (errcode(ERRCODE_OBJECT_IN_USE),
        /* translator: first %s is a SQL command, eg ALTER TABLE */
                 errmsg("cannot %s \"%s\" because it has pending trigger events",
                        stmt, RelationGetRelationName(rel))));
}

References AfterTriggerPendingOnRel(), ereport, errcode(), errmsg(), ERROR, RelationData::rd_isnailed, RelationData::rd_refcnt, RelationData::rd_rel, RelationGetRelationName, RelationGetRelid, and stmt.

Referenced by CheckAlterTableIsSafe(), cluster_rel(), DefineIndex(), DefineVirtualRelation(), heap_drop_with_catalog(), index_drop(), MergeAttributes(), RefreshMatViewByOid(), reindex_index(), and truncate_check_activity().

DefineRelation()

ObjectAddress DefineRelation	(	CreateStmt *	stmt,
		char	relkind,
		Oid	ownerId,
		ObjectAddress *	typaddress,
		const char *	queryString
	)

Definition at line 769 of file tablecmds.c.

{
    char        relname[NAMEDATALEN];
    Oid         namespaceId;
    Oid         relationId;
    Oid         tablespaceId;
    Relation    rel;
    TupleDesc   descriptor;
    List       *inheritOids;
    List       *old_constraints;
    List       *old_notnulls;
    List       *rawDefaults;
    List       *cookedDefaults;
    List       *nncols;
    Datum       reloptions;
    ListCell   *listptr;
    AttrNumber  attnum;
    bool        partitioned;
    const char *const validnsps[] = HEAP_RELOPT_NAMESPACES;
    Oid         ofTypeId;
    ObjectAddress address;
    LOCKMODE    parentLockmode;
    Oid         accessMethodId = InvalidOid;
 
    /*
     * Truncate relname to appropriate length (probably a waste of time, as
     * parser should have done this already).
     */
    strlcpy(relname, stmt->relation->relname, NAMEDATALEN);
 
    /*
     * Check consistency of arguments
     */
    if (stmt->oncommit != ONCOMMIT_NOOP
        && stmt->relation->relpersistence != RELPERSISTENCE_TEMP)
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_TABLE_DEFINITION),
                 errmsg("ON COMMIT can only be used on temporary tables")));
 
    if (stmt->partspec != NULL)
    {
        if (relkind != RELKIND_RELATION)
            elog(ERROR, "unexpected relkind: %d", (int) relkind);
 
        relkind = RELKIND_PARTITIONED_TABLE;
        partitioned = true;
    }
    else
        partitioned = false;
 
    if (relkind == RELKIND_PARTITIONED_TABLE &&
        stmt->relation->relpersistence == RELPERSISTENCE_UNLOGGED)
        ereport(ERROR,
                (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                 errmsg("partitioned tables cannot be unlogged")));
 
    /*
     * Look up the namespace in which we are supposed to create the relation,
     * check we have permission to create there, lock it against concurrent
     * drop, and mark stmt->relation as RELPERSISTENCE_TEMP if a temporary
     * namespace is selected.
     */
    namespaceId =
        RangeVarGetAndCheckCreationNamespace(stmt->relation, NoLock, NULL);
 
    /*
     * Security check: disallow creating temp tables from security-restricted
     * code.  This is needed because calling code might not expect untrusted
     * tables to appear in pg_temp at the front of its search path.
     */
    if (stmt->relation->relpersistence == RELPERSISTENCE_TEMP
        && InSecurityRestrictedOperation())
        ereport(ERROR,
                (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
                 errmsg("cannot create temporary table within security-restricted operation")));
 
    /*
     * Determine the lockmode to use when scanning parents.  A self-exclusive
     * lock is needed here.
     *
     * For regular inheritance, if two backends attempt to add children to the
     * same parent simultaneously, and that parent has no pre-existing
     * children, then both will attempt to update the parent's relhassubclass
     * field, leading to a "tuple concurrently updated" error.  Also, this
     * interlocks against a concurrent ANALYZE on the parent table, which
     * might otherwise be attempting to clear the parent's relhassubclass
     * field, if its previous children were recently dropped.
     *
     * If the child table is a partition, then we instead grab an exclusive
     * lock on the parent because its partition descriptor will be changed by
     * addition of the new partition.
     */
    parentLockmode = (stmt->partbound != NULL ? AccessExclusiveLock :
                      ShareUpdateExclusiveLock);
 
    /* Determine the list of OIDs of the parents. */
    inheritOids = NIL;
    foreach(listptr, stmt->inhRelations)
    {
        RangeVar   *rv = (RangeVar *) lfirst(listptr);
        Oid         parentOid;
 
        parentOid = RangeVarGetRelid(rv, parentLockmode, false);
 
        /*
         * Reject duplications in the list of parents.
         */
        if (list_member_oid(inheritOids, parentOid))
            ereport(ERROR,
                    (errcode(ERRCODE_DUPLICATE_TABLE),
                     errmsg("relation \"%s\" would be inherited from more than once",
                            get_rel_name(parentOid))));
 
        inheritOids = lappend_oid(inheritOids, parentOid);
    }
 
    /*
     * Select tablespace to use: an explicitly indicated one, or (in the case
     * of a partitioned table) the parent's, if it has one.
     */
    if (stmt->tablespacename)
    {
        tablespaceId = get_tablespace_oid(stmt->tablespacename, false);
 
        if (partitioned && tablespaceId == MyDatabaseTableSpace)
            ereport(ERROR,
                    (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                     errmsg("cannot specify default tablespace for partitioned relations")));
    }
    else if (stmt->partbound)
    {
        Assert(list_length(inheritOids) == 1);
        tablespaceId = get_rel_tablespace(linitial_oid(inheritOids));
    }
    else
        tablespaceId = InvalidOid;
 
    /* still nothing? use the default */
    if (!OidIsValid(tablespaceId))
        tablespaceId = GetDefaultTablespace(stmt->relation->relpersistence,
                                            partitioned);
 
    /* Check permissions except when using database's default */
    if (OidIsValid(tablespaceId) && tablespaceId != MyDatabaseTableSpace)
    {
        AclResult   aclresult;
 
        aclresult = object_aclcheck(TableSpaceRelationId, tablespaceId, GetUserId(),
                                    ACL_CREATE);
        if (aclresult != ACLCHECK_OK)
            aclcheck_error(aclresult, OBJECT_TABLESPACE,
                           get_tablespace_name(tablespaceId));
    }
 
    /* In all cases disallow placing user relations in pg_global */
    if (tablespaceId == GLOBALTABLESPACE_OID)
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                 errmsg("only shared relations can be placed in pg_global tablespace")));
 
    /* Identify user ID that will own the table */
    if (!OidIsValid(ownerId))
        ownerId = GetUserId();
 
    /*
     * Parse and validate reloptions, if any.
     */
    reloptions = transformRelOptions((Datum) 0, stmt->options, NULL, validnsps,
                                     true, false);
 
    switch (relkind)
    {
        case RELKIND_VIEW:
            (void) view_reloptions(reloptions, true);
            break;
        case RELKIND_PARTITIONED_TABLE:
            (void) partitioned_table_reloptions(reloptions, true);
            break;
        default:
            (void) heap_reloptions(relkind, reloptions, true);
    }
 
    if (stmt->ofTypename)
    {
        AclResult   aclresult;
 
        ofTypeId = typenameTypeId(NULL, stmt->ofTypename);
 
        aclresult = object_aclcheck(TypeRelationId, ofTypeId, GetUserId(), ACL_USAGE);
        if (aclresult != ACLCHECK_OK)
            aclcheck_error_type(aclresult, ofTypeId);
    }
    else
        ofTypeId = InvalidOid;
 
    /*
     * Look up inheritance ancestors and generate relation schema, including
     * inherited attributes.  (Note that stmt->tableElts is destructively
     * modified by MergeAttributes.)
     */
    stmt->tableElts =
        MergeAttributes(stmt->tableElts, inheritOids,
                        stmt->relation->relpersistence,
                        stmt->partbound != NULL,
                        &old_constraints, &old_notnulls);
 
    /*
     * Create a tuple descriptor from the relation schema.  Note that this
     * deals with column names, types, and in-descriptor NOT NULL flags, but
     * not default values, NOT NULL or CHECK constraints; we handle those
     * below.
     */
    descriptor = BuildDescForRelation(stmt->tableElts);
 
    /*
     * Find columns with default values and prepare for insertion of the
     * defaults.  Pre-cooked (that is, inherited) defaults go into a list of
     * CookedConstraint structs that we'll pass to heap_create_with_catalog,
     * while raw defaults go into a list of RawColumnDefault structs that will
     * be processed by AddRelationNewConstraints.  (We can't deal with raw
     * expressions until we can do transformExpr.)
     */
    rawDefaults = NIL;
    cookedDefaults = NIL;
    attnum = 0;
 
    foreach(listptr, stmt->tableElts)
    {
        ColumnDef  *colDef = lfirst(listptr);
 
        attnum++;
        if (colDef->raw_default != NULL)
        {
            RawColumnDefault *rawEnt;
 
            Assert(colDef->cooked_default == NULL);
 
            rawEnt = palloc_object(RawColumnDefault);
            rawEnt->attnum = attnum;
            rawEnt->raw_default = colDef->raw_default;
            rawEnt->generated = colDef->generated;
            rawDefaults = lappend(rawDefaults, rawEnt);
        }
        else if (colDef->cooked_default != NULL)
        {
            CookedConstraint *cooked;
 
            cooked = palloc_object(CookedConstraint);
            cooked->contype = CONSTR_DEFAULT;
            cooked->conoid = InvalidOid;    /* until created */
            cooked->name = NULL;
            cooked->attnum = attnum;
            cooked->expr = colDef->cooked_default;
            cooked->is_enforced = true;
            cooked->skip_validation = false;
            cooked->is_local = true;    /* not used for defaults */
            cooked->inhcount = 0;   /* ditto */
            cooked->is_no_inherit = false;
            cookedDefaults = lappend(cookedDefaults, cooked);
        }
    }
 
    /*
     * For relations with table AM and partitioned tables, select access
     * method to use: an explicitly indicated one, or (in the case of a
     * partitioned table) the parent's, if it has one.
     */
    if (stmt->accessMethod != NULL)
    {
        Assert(RELKIND_HAS_TABLE_AM(relkind) || relkind == RELKIND_PARTITIONED_TABLE);
        accessMethodId = get_table_am_oid(stmt->accessMethod, false);
    }
    else if (RELKIND_HAS_TABLE_AM(relkind) || relkind == RELKIND_PARTITIONED_TABLE)
    {
        if (stmt->partbound)
        {
            Assert(list_length(inheritOids) == 1);
            accessMethodId = get_rel_relam(linitial_oid(inheritOids));
        }
 
        if (RELKIND_HAS_TABLE_AM(relkind) && !OidIsValid(accessMethodId))
            accessMethodId = get_table_am_oid(default_table_access_method, false);
    }
 
    /*
     * Create the relation.  Inherited defaults and CHECK constraints are
     * passed in for immediate handling --- since they don't need parsing,
     * they can be stored immediately.
     */
    relationId = heap_create_with_catalog(relname,
                                          namespaceId,
                                          tablespaceId,
                                          InvalidOid,
                                          InvalidOid,
                                          ofTypeId,
                                          ownerId,
                                          accessMethodId,
                                          descriptor,
                                          list_concat(cookedDefaults,
                                                      old_constraints),
                                          relkind,
                                          stmt->relation->relpersistence,
                                          false,
                                          false,
                                          stmt->oncommit,
                                          reloptions,
                                          true,
                                          allowSystemTableMods,
                                          false,
                                          InvalidOid,
                                          typaddress);
 
    /*
     * We must bump the command counter to make the newly-created relation
     * tuple visible for opening.
     */
    CommandCounterIncrement();
 
    /*
     * Open the new relation and acquire exclusive lock on it.  This isn't
     * really necessary for locking out other backends (since they can't see
     * the new rel anyway until we commit), but it keeps the lock manager from
     * complaining about deadlock risks.
     */
    rel = relation_open(relationId, AccessExclusiveLock);
 
    /*
     * Now add any newly specified column default and generation expressions
     * to the new relation.  These are passed to us in the form of raw
     * parsetrees; we need to transform them to executable expression trees
     * before they can be added. The most convenient way to do that is to
     * apply the parser's transformExpr routine, but transformExpr doesn't
     * work unless we have a pre-existing relation. So, the transformation has
     * to be postponed to this final step of CREATE TABLE.
     *
     * This needs to be before processing the partitioning clauses because
     * those could refer to generated columns.
     */
    if (rawDefaults)
        AddRelationNewConstraints(rel, rawDefaults, NIL,
                                  true, true, false, queryString);
 
    /*
     * Make column generation expressions visible for use by partitioning.
     */
    CommandCounterIncrement();
 
    /* Process and store partition bound, if any. */
    if (stmt->partbound)
    {
        PartitionBoundSpec *bound;
        ParseState *pstate;
        Oid         parentId = linitial_oid(inheritOids),
                    defaultPartOid;
        Relation    parent,
                    defaultRel = NULL;
        ParseNamespaceItem *nsitem;
 
        /* Already have strong enough lock on the parent */
        parent = table_open(parentId, NoLock);
 
        /*
         * We are going to try to validate the partition bound specification
         * against the partition key of parentRel, so it better have one.
         */
        if (parent->rd_rel->relkind != RELKIND_PARTITIONED_TABLE)
            ereport(ERROR,
                    (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
                     errmsg("\"%s\" is not partitioned",
                            RelationGetRelationName(parent))));
 
        /*
         * The partition constraint of the default partition depends on the
         * partition bounds of every other partition. It is possible that
         * another backend might be about to execute a query on the default
         * partition table, and that the query relies on previously cached
         * default partition constraints. We must therefore take a table lock
         * strong enough to prevent all queries on the default partition from
         * proceeding until we commit and send out a shared-cache-inval notice
         * that will make them update their index lists.
         *
         * Order of locking: The relation being added won't be visible to
         * other backends until it is committed, hence here in
         * DefineRelation() the order of locking the default partition and the
         * relation being added does not matter. But at all other places we
         * need to lock the default relation before we lock the relation being
         * added or removed i.e. we should take the lock in same order at all
         * the places such that lock parent, lock default partition and then
         * lock the partition so as to avoid a deadlock.
         */
        defaultPartOid =
            get_default_oid_from_partdesc(RelationGetPartitionDesc(parent,
                                                                   true));
        if (OidIsValid(defaultPartOid))
            defaultRel = table_open(defaultPartOid, AccessExclusiveLock);
 
        /* Transform the bound values */
        pstate = make_parsestate(NULL);
        pstate->p_sourcetext = queryString;
 
        /*
         * Add an nsitem containing this relation, so that transformExpr
         * called on partition bound expressions is able to report errors
         * using a proper context.
         */
        nsitem = addRangeTableEntryForRelation(pstate, rel, AccessShareLock,
                                               NULL, false, false);
        addNSItemToQuery(pstate, nsitem, false, true, true);
 
        bound = transformPartitionBound(pstate, parent, stmt->partbound);
 
        /*
         * Check first that the new partition's bound is valid and does not
         * overlap with any of existing partitions of the parent.
         */
        check_new_partition_bound(relname, parent, bound, pstate);
 
        /*
         * If the default partition exists, its partition constraints will
         * change after the addition of this new partition such that it won't
         * allow any row that qualifies for this new partition. So, check that
         * the existing data in the default partition satisfies the constraint
         * as it will exist after adding this partition.
         */
        if (OidIsValid(defaultPartOid))
        {
            check_default_partition_contents(parent, defaultRel, bound);
            /* Keep the lock until commit. */
            table_close(defaultRel, NoLock);
        }
 
        /* Update the pg_class entry. */
        StorePartitionBound(rel, parent, bound);
 
        table_close(parent, NoLock);
    }
 
    /* Store inheritance information for new rel. */
    StoreCatalogInheritance(relationId, inheritOids, stmt->partbound != NULL);
 
    /*
     * Process the partitioning specification (if any) and store the partition
     * key information into the catalog.
     */
    if (partitioned)
    {
        ParseState *pstate;
        int         partnatts;
        AttrNumber  partattrs[PARTITION_MAX_KEYS];
        Oid         partopclass[PARTITION_MAX_KEYS];
        Oid         partcollation[PARTITION_MAX_KEYS];
        List       *partexprs = NIL;
 
        pstate = make_parsestate(NULL);
        pstate->p_sourcetext = queryString;
 
        partnatts = list_length(stmt->partspec->partParams);
 
        /* Protect fixed-size arrays here and in executor */
        if (partnatts > PARTITION_MAX_KEYS)
            ereport(ERROR,
                    (errcode(ERRCODE_TOO_MANY_COLUMNS),
                     errmsg("cannot partition using more than %d columns",
                            PARTITION_MAX_KEYS)));
 
        /*
         * We need to transform the raw parsetrees corresponding to partition
         * expressions into executable expression trees.  Like column defaults
         * and CHECK constraints, we could not have done the transformation
         * earlier.
         */
        stmt->partspec = transformPartitionSpec(rel, stmt->partspec);
 
        ComputePartitionAttrs(pstate, rel, stmt->partspec->partParams,
                              partattrs, &partexprs, partopclass,
                              partcollation, stmt->partspec->strategy);
 
        StorePartitionKey(rel, stmt->partspec->strategy, partnatts, partattrs,
                          partexprs,
                          partopclass, partcollation);
 
        /* make it all visible */
        CommandCounterIncrement();
    }
 
    /*
     * If we're creating a partition, create now all the indexes, triggers,
     * FKs defined in the parent.
     *
     * We can't do it earlier, because DefineIndex wants to know the partition
     * key which we just stored.
     */
    if (stmt->partbound)
    {
        Oid         parentId = linitial_oid(inheritOids);
        Relation    parent;
        List       *idxlist;
        ListCell   *cell;
 
        /* Already have strong enough lock on the parent */
        parent = table_open(parentId, NoLock);
        idxlist = RelationGetIndexList(parent);
 
        /*
         * For each index in the parent table, create one in the partition
         */
        foreach(cell, idxlist)
        {
            Relation    idxRel = index_open(lfirst_oid(cell), AccessShareLock);
            AttrMap    *attmap;
            IndexStmt  *idxstmt;
            Oid         constraintOid;
 
            if (rel->rd_rel->relkind == RELKIND_FOREIGN_TABLE)
            {
                if (idxRel->rd_index->indisunique)
                    ereport(ERROR,
                            (errcode(ERRCODE_WRONG_OBJECT_TYPE),
                             errmsg("cannot create foreign partition of partitioned table \"%s\"",
                                    RelationGetRelationName(parent)),
                             errdetail("Table \"%s\" contains indexes that are unique.",
                                       RelationGetRelationName(parent))));
                else
                {
                    index_close(idxRel, AccessShareLock);
                    continue;
                }
            }
 
            attmap = build_attrmap_by_name(RelationGetDescr(rel),
                                           RelationGetDescr(parent),
                                           false);
            idxstmt =
                generateClonedIndexStmt(NULL, idxRel,
                                        attmap, &constraintOid);
            DefineIndex(RelationGetRelid(rel),
                        idxstmt,
                        InvalidOid,
                        RelationGetRelid(idxRel),
                        constraintOid,
                        -1,
                        false, false, false, false, false);
 
            index_close(idxRel, AccessShareLock);
        }
 
        list_free(idxlist);
 
        /*
         * If there are any row-level triggers, clone them to the new
         * partition.
         */
        if (parent->trigdesc != NULL)
            CloneRowTriggersToPartition(parent, rel);
 
        /*
         * And foreign keys too.  Note that because we're freshly creating the
         * table, there is no need to verify these new constraints.
         */
        CloneForeignKeyConstraints(NULL, parent, rel);
 
        table_close(parent, NoLock);
    }
 
    /*
     * Now add any newly specified CHECK constraints to the new relation. Same
     * as for defaults above, but these need to come after partitioning is set
     * up.
     */
    if (stmt->constraints)
        AddRelationNewConstraints(rel, NIL, stmt->constraints,
                                  true, true, false, queryString);
 
    /*
     * Finally, merge the not-null constraints that are declared directly with
     * those that come from parent relations (making sure to count inheritance
     * appropriately for each), create them, and set the attnotnull flag on
     * columns that don't yet have it.
     */
    nncols = AddRelationNotNullConstraints(rel, stmt->nnconstraints,
                                           old_notnulls);
    foreach_int(attrnum, nncols)
        set_attnotnull(NULL, rel, attrnum, true, false);
 
    ObjectAddressSet(address, RelationRelationId, relationId);
 
    /*
     * Clean up.  We keep lock on new relation (although it shouldn't be
     * visible to anyone else anyway, until commit).
     */
    relation_close(rel, NoLock);
 
    return address;
}

References AccessExclusiveLock, AccessShareLock, ACL_CREATE, ACL_USAGE, aclcheck_error(), aclcheck_error_type(), ACLCHECK_OK, addNSItemToQuery(), addRangeTableEntryForRelation(), AddRelationNewConstraints(), AddRelationNotNullConstraints(), allowSystemTableMods, Assert(), RawColumnDefault::attnum, CookedConstraint::attnum, attnum, build_attrmap_by_name(), BuildDescForRelation(), check_default_partition_contents(), check_new_partition_bound(), CloneForeignKeyConstraints(), CloneRowTriggersToPartition(), CommandCounterIncrement(), ComputePartitionAttrs(), CookedConstraint::conoid, CONSTR_DEFAULT, CookedConstraint::contype, ColumnDef::cooked_default, default_table_access_method, DefineIndex(), elog, ereport, errcode(), errdetail(), errmsg(), ERROR, CookedConstraint::expr, foreach_int, generateClonedIndexStmt(), RawColumnDefault::generated, ColumnDef::generated, get_default_oid_from_partdesc(), get_rel_name(), get_rel_relam(), get_rel_tablespace(), get_table_am_oid(), get_tablespace_name(), get_tablespace_oid(), GetDefaultTablespace(), GetUserId(), heap_create_with_catalog(), HEAP_RELOPT_NAMESPACES, heap_reloptions(), index_close(), index_open(), CookedConstraint::inhcount, InSecurityRestrictedOperation(), InvalidOid, CookedConstraint::is_enforced, CookedConstraint::is_local, CookedConstraint::is_no_inherit, lappend(), lappend_oid(), lfirst, lfirst_oid, linitial_oid, list_concat(), list_free(), list_length(), list_member_oid(), make_parsestate(), MergeAttributes(), MyDatabaseTableSpace, CookedConstraint::name, NAMEDATALEN, NIL, NoLock, object_aclcheck(), OBJECT_TABLESPACE, ObjectAddressSet, OidIsValid, ONCOMMIT_NOOP, ParseState::p_sourcetext, palloc_object, PARTITION_MAX_KEYS, partitioned_table_reloptions(), RangeVarGetAndCheckCreationNamespace(), RangeVarGetRelid, RawColumnDefault::raw_default, ColumnDef::raw_default, RelationData::rd_index, RelationData::rd_rel, relation_close(), relation_open(), RelationGetDescr, RelationGetIndexList(), RelationGetPartitionDesc(), RelationGetRelationName, RelationGetRelid, relname, set_attnotnull(), ShareUpdateExclusiveLock, CookedConstraint::skip_validation, stmt, StoreCatalogInheritance(), StorePartitionBound(), StorePartitionKey(), strlcpy(), table_close(), table_open(), transformPartitionBound(), transformPartitionSpec(), transformRelOptions(), RelationData::trigdesc, typenameTypeId(), and view_reloptions().

Referenced by create_ctas_internal(), DefineCompositeType(), DefineSequence(), DefineVirtualRelation(), and ProcessUtilitySlow().

ExecuteTruncate()

void ExecuteTruncate

(

TruncateStmt *

stmt

)

Definition at line 1856 of file tablecmds.c.

{
    List       *rels = NIL;
    List       *relids = NIL;
    List       *relids_logged = NIL;
    ListCell   *cell;
 
    /*
     * Open, exclusive-lock, and check all the explicitly-specified relations
     */
    foreach(cell, stmt->relations)
    {
        RangeVar   *rv = lfirst(cell);
        Relation    rel;
        bool        recurse = rv->inh;
        Oid         myrelid;
        LOCKMODE    lockmode = AccessExclusiveLock;
 
        myrelid = RangeVarGetRelidExtended(rv, lockmode,
                                           0, RangeVarCallbackForTruncate,
                                           NULL);
 
        /* don't throw error for "TRUNCATE foo, foo" */
        if (list_member_oid(relids, myrelid))
            continue;
 
        /* open the relation, we already hold a lock on it */
        rel = table_open(myrelid, NoLock);
 
        /*
         * RangeVarGetRelidExtended() has done most checks with its callback,
         * but other checks with the now-opened Relation remain.
         */
        truncate_check_activity(rel);
 
        rels = lappend(rels, rel);
        relids = lappend_oid(relids, myrelid);
 
        /* Log this relation only if needed for logical decoding */
        if (RelationIsLogicallyLogged(rel))
            relids_logged = lappend_oid(relids_logged, myrelid);
 
        if (recurse)
        {
            ListCell   *child;
            List       *children;
 
            children = find_all_inheritors(myrelid, lockmode, NULL);
 
            foreach(child, children)
            {
                Oid         childrelid = lfirst_oid(child);
 
                if (list_member_oid(relids, childrelid))
                    continue;
 
                /* find_all_inheritors already got lock */
                rel = table_open(childrelid, NoLock);
 
                /*
                 * It is possible that the parent table has children that are
                 * temp tables of other backends.  We cannot safely access
                 * such tables (because of buffering issues), and the best
                 * thing to do is to silently ignore them.  Note that this
                 * check is the same as one of the checks done in
                 * truncate_check_activity() called below, still it is kept
                 * here for simplicity.
                 */
                if (RELATION_IS_OTHER_TEMP(rel))
                {
                    table_close(rel, lockmode);
                    continue;
                }
 
                /*
                 * Inherited TRUNCATE commands perform access permission
                 * checks on the parent table only. So we skip checking the
                 * children's permissions and don't call
                 * truncate_check_perms() here.
                 */
                truncate_check_rel(RelationGetRelid(rel), rel->rd_rel);
                truncate_check_activity(rel);
 
                rels = lappend(rels, rel);
                relids = lappend_oid(relids, childrelid);
 
                /* Log this relation only if needed for logical decoding */
                if (RelationIsLogicallyLogged(rel))
                    relids_logged = lappend_oid(relids_logged, childrelid);
            }
        }
        else if (rel->rd_rel->relkind == RELKIND_PARTITIONED_TABLE)
            ereport(ERROR,
                    (errcode(ERRCODE_WRONG_OBJECT_TYPE),
                     errmsg("cannot truncate only a partitioned table"),
                     errhint("Do not specify the ONLY keyword, or use TRUNCATE ONLY on the partitions directly.")));
    }
 
    ExecuteTruncateGuts(rels, relids, relids_logged,
                        stmt->behavior, stmt->restart_seqs, false);
 
    /* And close the rels */
    foreach(cell, rels)
    {
        Relation    rel = (Relation) lfirst(cell);
 
        table_close(rel, NoLock);
    }
}

References AccessExclusiveLock, ereport, errcode(), errhint(), errmsg(), ERROR, ExecuteTruncateGuts(), find_all_inheritors(), RangeVar::inh, lappend(), lappend_oid(), lfirst, lfirst_oid, list_member_oid(), NIL, NoLock, RangeVarCallbackForTruncate(), RangeVarGetRelidExtended(), RelationData::rd_rel, RELATION_IS_OTHER_TEMP, RelationGetRelid, RelationIsLogicallyLogged, stmt, table_close(), table_open(), truncate_check_activity(), and truncate_check_rel().

Referenced by standard_ProcessUtility().

ExecuteTruncateGuts()

void ExecuteTruncateGuts	(	List *	explicit_rels,
		List *	relids,
		List *	relids_logged,
		DropBehavior	behavior,
		bool	restart_seqs,
		bool	run_as_table_owner
	)

Definition at line 1980 of file tablecmds.c.

{
    List       *rels;
    List       *seq_relids = NIL;
    HTAB       *ft_htab = NULL;
    EState     *estate;
    ResultRelInfo *resultRelInfos;
    ResultRelInfo *resultRelInfo;
    SubTransactionId mySubid;
    ListCell   *cell;
    Oid        *logrelids;
 
    /*
     * Check the explicitly-specified relations.
     *
     * In CASCADE mode, suck in all referencing relations as well.  This
     * requires multiple iterations to find indirectly-dependent relations. At
     * each phase, we need to exclusive-lock new rels before looking for their
     * dependencies, else we might miss something.  Also, we check each rel as
     * soon as we open it, to avoid a faux pas such as holding lock for a long
     * time on a rel we have no permissions for.
     */
    rels = list_copy(explicit_rels);
    if (behavior == DROP_CASCADE)
    {
        for (;;)
        {
            List       *newrelids;
 
            newrelids = heap_truncate_find_FKs(relids);
            if (newrelids == NIL)
                break;          /* nothing else to add */
 
            foreach(cell, newrelids)
            {
                Oid         relid = lfirst_oid(cell);
                Relation    rel;
 
                rel = table_open(relid, AccessExclusiveLock);
                ereport(NOTICE,
                        (errmsg("truncate cascades to table \"%s\"",
                                RelationGetRelationName(rel))));
                truncate_check_rel(relid, rel->rd_rel);
                truncate_check_perms(relid, rel->rd_rel);
                truncate_check_activity(rel);
                rels = lappend(rels, rel);
                relids = lappend_oid(relids, relid);
 
                /* Log this relation only if needed for logical decoding */
                if (RelationIsLogicallyLogged(rel))
                    relids_logged = lappend_oid(relids_logged, relid);
            }
        }
    }
 
    /*
     * Check foreign key references.  In CASCADE mode, this should be
     * unnecessary since we just pulled in all the references; but as a
     * cross-check, do it anyway if in an Assert-enabled build.
     */
#ifdef USE_ASSERT_CHECKING
    heap_truncate_check_FKs(rels, false);
#else
    if (behavior == DROP_RESTRICT)
        heap_truncate_check_FKs(rels, false);
#endif
 
    /*
     * If we are asked to restart sequences, find all the sequences, lock them
     * (we need AccessExclusiveLock for ResetSequence), and check permissions.
     * We want to do this early since it's pointless to do all the truncation
     * work only to fail on sequence permissions.
     */
    if (restart_seqs)
    {
        foreach(cell, rels)
        {
            Relation    rel = (Relation) lfirst(cell);
            List       *seqlist = getOwnedSequences(RelationGetRelid(rel));
            ListCell   *seqcell;
 
            foreach(seqcell, seqlist)
            {
                Oid         seq_relid = lfirst_oid(seqcell);
                Relation    seq_rel;
 
                seq_rel = relation_open(seq_relid, AccessExclusiveLock);
 
                /* This check must match AlterSequence! */
                if (!object_ownercheck(RelationRelationId, seq_relid, GetUserId()))
                    aclcheck_error(ACLCHECK_NOT_OWNER, OBJECT_SEQUENCE,
                                   RelationGetRelationName(seq_rel));
 
                seq_relids = lappend_oid(seq_relids, seq_relid);
 
                relation_close(seq_rel, NoLock);
            }
        }
    }
 
    /* Prepare to catch AFTER triggers. */
    AfterTriggerBeginQuery();
 
    /*
     * To fire triggers, we'll need an EState as well as a ResultRelInfo for
     * each relation.  We don't need to call ExecOpenIndices, though.
     *
     * We put the ResultRelInfos in the es_opened_result_relations list, even
     * though we don't have a range table and don't populate the
     * es_result_relations array.  That's a bit bogus, but it's enough to make
     * ExecGetTriggerResultRel() find them.
     */
    estate = CreateExecutorState();
    resultRelInfos = (ResultRelInfo *)
        palloc(list_length(rels) * sizeof(ResultRelInfo));
    resultRelInfo = resultRelInfos;
    foreach(cell, rels)
    {
        Relation    rel = (Relation) lfirst(cell);
 
        InitResultRelInfo(resultRelInfo,
                          rel,
                          0,    /* dummy rangetable index */
                          NULL,
                          0);
        estate->es_opened_result_relations =
            lappend(estate->es_opened_result_relations, resultRelInfo);
        resultRelInfo++;
    }
 
    /*
     * Process all BEFORE STATEMENT TRUNCATE triggers before we begin
     * truncating (this is because one of them might throw an error). Also, if
     * we were to allow them to prevent statement execution, that would need
     * to be handled here.
     */
    resultRelInfo = resultRelInfos;
    foreach(cell, rels)
    {
        UserContext ucxt;
 
        if (run_as_table_owner)
            SwitchToUntrustedUser(resultRelInfo->ri_RelationDesc->rd_rel->relowner,
                                  &ucxt);
        ExecBSTruncateTriggers(estate, resultRelInfo);
        if (run_as_table_owner)
            RestoreUserContext(&ucxt);
        resultRelInfo++;
    }
 
    /*
     * OK, truncate each table.
     */
    mySubid = GetCurrentSubTransactionId();
 
    foreach(cell, rels)
    {
        Relation    rel = (Relation) lfirst(cell);
 
        /* Skip partitioned tables as there is nothing to do */
        if (rel->rd_rel->relkind == RELKIND_PARTITIONED_TABLE)
            continue;
 
        /*
         * Build the lists of foreign tables belonging to each foreign server
         * and pass each list to the foreign data wrapper's callback function,
         * so that each server can truncate its all foreign tables in bulk.
         * Each list is saved as a single entry in a hash table that uses the
         * server OID as lookup key.
         */
        if (rel->rd_rel->relkind == RELKIND_FOREIGN_TABLE)
        {
            Oid         serverid = GetForeignServerIdByRelId(RelationGetRelid(rel));
            bool        found;
            ForeignTruncateInfo *ft_info;
 
            /* First time through, initialize hashtable for foreign tables */
            if (!ft_htab)
            {
                HASHCTL     hctl;
 
                memset(&hctl, 0, sizeof(HASHCTL));
                hctl.keysize = sizeof(Oid);
                hctl.entrysize = sizeof(ForeignTruncateInfo);
                hctl.hcxt = CurrentMemoryContext;
 
                ft_htab = hash_create("TRUNCATE for Foreign Tables",
                                      32,   /* start small and extend */
                                      &hctl,
                                      HASH_ELEM | HASH_BLOBS | HASH_CONTEXT);
            }
 
            /* Find or create cached entry for the foreign table */
            ft_info = hash_search(ft_htab, &serverid, HASH_ENTER, &found);
            if (!found)
                ft_info->rels = NIL;
 
            /*
             * Save the foreign table in the entry of the server that the
             * foreign table belongs to.
             */
            ft_info->rels = lappend(ft_info->rels, rel);
            continue;
        }
 
        /*
         * Normally, we need a transaction-safe truncation here.  However, if
         * the table was either created in the current (sub)transaction or has
         * a new relfilenumber in the current (sub)transaction, then we can
         * just truncate it in-place, because a rollback would cause the whole
         * table or the current physical file to be thrown away anyway.
         */
        if (rel->rd_createSubid == mySubid ||
            rel->rd_newRelfilelocatorSubid == mySubid)
        {
            /* Immediate, non-rollbackable truncation is OK */
            heap_truncate_one_rel(rel);
        }
        else
        {
            Oid         heap_relid;
            Oid         toast_relid;
            ReindexParams reindex_params = {0};
 
            /*
             * This effectively deletes all rows in the table, and may be done
             * in a serializable transaction.  In that case we must record a
             * rw-conflict in to this transaction from each transaction
             * holding a predicate lock on the table.
             */
            CheckTableForSerializableConflictIn(rel);
 
            /*
             * Need the full transaction-safe pushups.
             *
             * Create a new empty storage file for the relation, and assign it
             * as the relfilenumber value. The old storage file is scheduled
             * for deletion at commit.
             */
            RelationSetNewRelfilenumber(rel, rel->rd_rel->relpersistence);
 
            heap_relid = RelationGetRelid(rel);
 
            /*
             * The same for the toast table, if any.
             */
            toast_relid = rel->rd_rel->reltoastrelid;
            if (OidIsValid(toast_relid))
            {
                Relation    toastrel = relation_open(toast_relid,
                                                     AccessExclusiveLock);
 
                RelationSetNewRelfilenumber(toastrel,
                                            toastrel->rd_rel->relpersistence);
                table_close(toastrel, NoLock);
            }
 
            /*
             * Reconstruct the indexes to match, and we're done.
             */
            reindex_relation(NULL, heap_relid, REINDEX_REL_PROCESS_TOAST,
                             &reindex_params);
        }
 
        pgstat_count_truncate(rel);
    }
 
    /* Now go through the hash table, and truncate foreign tables */
    if (ft_htab)
    {
        ForeignTruncateInfo *ft_info;
        HASH_SEQ_STATUS seq;
 
        hash_seq_init(&seq, ft_htab);
 
        PG_TRY();
        {
            while ((ft_info = hash_seq_search(&seq)) != NULL)
            {
                FdwRoutine *routine = GetFdwRoutineByServerId(ft_info->serverid);
 
                /* truncate_check_rel() has checked that already */
                Assert(routine->ExecForeignTruncate != NULL);
 
                routine->ExecForeignTruncate(ft_info->rels,
                                             behavior,
                                             restart_seqs);
            }
        }
        PG_FINALLY();
        {
            hash_destroy(ft_htab);
        }
        PG_END_TRY();
    }
 
    /*
     * Restart owned sequences if we were asked to.
     */
    foreach(cell, seq_relids)
    {
        Oid         seq_relid = lfirst_oid(cell);
 
        ResetSequence(seq_relid);
    }
 
    /*
     * Write a WAL record to allow this set of actions to be logically
     * decoded.
     *
     * Assemble an array of relids so we can write a single WAL record for the
     * whole action.
     */
    if (relids_logged != NIL)
    {
        xl_heap_truncate xlrec;
        int         i = 0;
 
        /* should only get here if wal_level >= logical */
        Assert(XLogLogicalInfoActive());
 
        logrelids = palloc(list_length(relids_logged) * sizeof(Oid));
        foreach(cell, relids_logged)
            logrelids[i++] = lfirst_oid(cell);
 
        xlrec.dbId = MyDatabaseId;
        xlrec.nrelids = list_length(relids_logged);
        xlrec.flags = 0;
        if (behavior == DROP_CASCADE)
            xlrec.flags |= XLH_TRUNCATE_CASCADE;
        if (restart_seqs)
            xlrec.flags |= XLH_TRUNCATE_RESTART_SEQS;
 
        XLogBeginInsert();
        XLogRegisterData(&xlrec, SizeOfHeapTruncate);
        XLogRegisterData(logrelids, list_length(relids_logged) * sizeof(Oid));
 
        XLogSetRecordFlags(XLOG_INCLUDE_ORIGIN);
 
        (void) XLogInsert(RM_HEAP_ID, XLOG_HEAP_TRUNCATE);
    }
 
    /*
     * Process all AFTER STATEMENT TRUNCATE triggers.
     */
    resultRelInfo = resultRelInfos;
    foreach(cell, rels)
    {
        UserContext ucxt;
 
        if (run_as_table_owner)
            SwitchToUntrustedUser(resultRelInfo->ri_RelationDesc->rd_rel->relowner,
                                  &ucxt);
        ExecASTruncateTriggers(estate, resultRelInfo);
        if (run_as_table_owner)
            RestoreUserContext(&ucxt);
        resultRelInfo++;
    }
 
    /* Handle queued AFTER triggers */
    AfterTriggerEndQuery(estate);
 
    /* We can clean up the EState now */
    FreeExecutorState(estate);
 
    /*
     * Close any rels opened by CASCADE (can't do this while EState still
     * holds refs)
     */
    rels = list_difference_ptr(rels, explicit_rels);
    foreach(cell, rels)
    {
        Relation    rel = (Relation) lfirst(cell);
 
        table_close(rel, NoLock);
    }
}

References AccessExclusiveLock, aclcheck_error(), ACLCHECK_NOT_OWNER, AfterTriggerBeginQuery(), AfterTriggerEndQuery(), Assert(), CheckTableForSerializableConflictIn(), CreateExecutorState(), CurrentMemoryContext, xl_heap_truncate::dbId, DROP_CASCADE, DROP_RESTRICT, HASHCTL::entrysize, ereport, errmsg(), EState::es_opened_result_relations, ExecASTruncateTriggers(), ExecBSTruncateTriggers(), FdwRoutine::ExecForeignTruncate, xl_heap_truncate::flags, FreeExecutorState(), GetCurrentSubTransactionId(), GetFdwRoutineByServerId(), GetForeignServerIdByRelId(), getOwnedSequences(), GetUserId(), HASH_BLOBS, HASH_CONTEXT, hash_create(), hash_destroy(), HASH_ELEM, HASH_ENTER, hash_search(), hash_seq_init(), hash_seq_search(), HASHCTL::hcxt, heap_truncate_check_FKs(), heap_truncate_find_FKs(), heap_truncate_one_rel(), i, InitResultRelInfo(), HASHCTL::keysize, lappend(), lappend_oid(), lfirst, lfirst_oid, list_copy(), list_difference_ptr(), list_length(), MyDatabaseId, NIL, NoLock, NOTICE, xl_heap_truncate::nrelids, object_ownercheck(), OBJECT_SEQUENCE, OidIsValid, palloc(), PG_END_TRY, PG_FINALLY, PG_TRY, pgstat_count_truncate(), RelationData::rd_createSubid, RelationData::rd_newRelfilelocatorSubid, RelationData::rd_rel, REINDEX_REL_PROCESS_TOAST, reindex_relation(), relation_close(), relation_open(), RelationGetRelationName, RelationGetRelid, RelationIsLogicallyLogged, RelationSetNewRelfilenumber(), ForeignTruncateInfo::rels, ResetSequence(), RestoreUserContext(), ResultRelInfo::ri_RelationDesc, ForeignTruncateInfo::serverid, SizeOfHeapTruncate, SwitchToUntrustedUser(), table_close(), table_open(), truncate_check_activity(), truncate_check_perms(), truncate_check_rel(), XLH_TRUNCATE_CASCADE, XLH_TRUNCATE_RESTART_SEQS, XLOG_HEAP_TRUNCATE, XLOG_INCLUDE_ORIGIN, XLogBeginInsert(), XLogInsert(), XLogLogicalInfoActive, XLogRegisterData(), and XLogSetRecordFlags().

Referenced by apply_handle_truncate(), and ExecuteTruncate().

find_composite_type_dependencies()

void find_composite_type_dependencies	(	Oid	typeOid,
		Relation	origRelation,
		const char *	origTypeName
	)

Definition at line 6964 of file tablecmds.c.

{
    Relation    depRel;
    ScanKeyData key[2];
    SysScanDesc depScan;
    HeapTuple   depTup;
 
    /* since this function recurses, it could be driven to stack overflow */
    check_stack_depth();
 
    /*
     * We scan pg_depend to find those things that depend on the given type.
     * (We assume we can ignore refobjsubid for a type.)
     */
    depRel = table_open(DependRelationId, AccessShareLock);
 
    ScanKeyInit(&key[0],
                Anum_pg_depend_refclassid,
                BTEqualStrategyNumber, F_OIDEQ,
                ObjectIdGetDatum(TypeRelationId));
    ScanKeyInit(&key[1],
                Anum_pg_depend_refobjid,
                BTEqualStrategyNumber, F_OIDEQ,
                ObjectIdGetDatum(typeOid));
 
    depScan = systable_beginscan(depRel, DependReferenceIndexId, true,
                                 NULL, 2, key);
 
    while (HeapTupleIsValid(depTup = systable_getnext(depScan)))
    {
        Form_pg_depend pg_depend = (Form_pg_depend) GETSTRUCT(depTup);
        Relation    rel;
        TupleDesc   tupleDesc;
        Form_pg_attribute att;
 
        /* Check for directly dependent types */
        if (pg_depend->classid == TypeRelationId)
        {
            /*
             * This must be an array, domain, or range containing the given
             * type, so recursively check for uses of this type.  Note that
             * any error message will mention the original type not the
             * container; this is intentional.
             */
            find_composite_type_dependencies(pg_depend->objid,
                                             origRelation, origTypeName);
            continue;
        }
 
        /* Else, ignore dependees that aren't relations */
        if (pg_depend->classid != RelationRelationId)
            continue;
 
        rel = relation_open(pg_depend->objid, AccessShareLock);
        tupleDesc = RelationGetDescr(rel);
 
        /*
         * If objsubid identifies a specific column, refer to that in error
         * messages.  Otherwise, search to see if there's a user column of the
         * type.  (We assume system columns are never of interesting types.)
         * The search is needed because an index containing an expression
         * column of the target type will just be recorded as a whole-relation
         * dependency.  If we do not find a column of the type, the dependency
         * must indicate that the type is transiently referenced in an index
         * expression but not stored on disk, which we assume is OK, just as
         * we do for references in views.  (It could also be that the target
         * type is embedded in some container type that is stored in an index
         * column, but the previous recursion should catch such cases.)
         */
        if (pg_depend->objsubid > 0 && pg_depend->objsubid <= tupleDesc->natts)
            att = TupleDescAttr(tupleDesc, pg_depend->objsubid - 1);
        else
        {
            att = NULL;
            for (int attno = 1; attno <= tupleDesc->natts; attno++)
            {
                att = TupleDescAttr(tupleDesc, attno - 1);
                if (att->atttypid == typeOid && !att->attisdropped)
                    break;
                att = NULL;
            }
            if (att == NULL)
            {
                /* No such column, so assume OK */
                relation_close(rel, AccessShareLock);
                continue;
            }
        }
 
        /*
         * We definitely should reject if the relation has storage.  If it's
         * partitioned, then perhaps we don't have to reject: if there are
         * partitions then we'll fail when we find one, else there is no
         * stored data to worry about.  However, it's possible that the type
         * change would affect conclusions about whether the type is sortable
         * or hashable and thus (if it's a partitioning column) break the
         * partitioning rule.  For now, reject for partitioned rels too.
         */
        if (RELKIND_HAS_STORAGE(rel->rd_rel->relkind) ||
            RELKIND_HAS_PARTITIONS(rel->rd_rel->relkind))
        {
            if (origTypeName)
                ereport(ERROR,
                        (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                         errmsg("cannot alter type \"%s\" because column \"%s.%s\" uses it",
                                origTypeName,
                                RelationGetRelationName(rel),
                                NameStr(att->attname))));
            else if (origRelation->rd_rel->relkind == RELKIND_COMPOSITE_TYPE)
                ereport(ERROR,
                        (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                         errmsg("cannot alter type \"%s\" because column \"%s.%s\" uses it",
                                RelationGetRelationName(origRelation),
                                RelationGetRelationName(rel),
                                NameStr(att->attname))));
            else if (origRelation->rd_rel->relkind == RELKIND_FOREIGN_TABLE)
                ereport(ERROR,
                        (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                         errmsg("cannot alter foreign table \"%s\" because column \"%s.%s\" uses its row type",
                                RelationGetRelationName(origRelation),
                                RelationGetRelationName(rel),
                                NameStr(att->attname))));
            else
                ereport(ERROR,
                        (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                         errmsg("cannot alter table \"%s\" because column \"%s.%s\" uses its row type",
                                RelationGetRelationName(origRelation),
                                RelationGetRelationName(rel),
                                NameStr(att->attname))));
        }
        else if (OidIsValid(rel->rd_rel->reltype))
        {
            /*
             * A view or composite type itself isn't a problem, but we must
             * recursively check for indirect dependencies via its rowtype.
             */
            find_composite_type_dependencies(rel->rd_rel->reltype,
                                             origRelation, origTypeName);
        }
 
        relation_close(rel, AccessShareLock);
    }
 
    systable_endscan(depScan);
 
    relation_close(depRel, AccessShareLock);
}

References AccessShareLock, BTEqualStrategyNumber, check_stack_depth(), ereport, errcode(), errmsg(), ERROR, find_composite_type_dependencies(), GETSTRUCT(), HeapTupleIsValid, sort-test::key, NameStr, TupleDescData::natts, ObjectIdGetDatum(), OidIsValid, RelationData::rd_rel, relation_close(), relation_open(), RelationGetDescr, RelationGetRelationName, ScanKeyInit(), systable_beginscan(), systable_endscan(), systable_getnext(), table_open(), and TupleDescAttr().

Referenced by ATPrepAlterColumnType(), ATRewriteTables(), find_composite_type_dependencies(), and get_rels_with_domain().

PartConstraintImpliedByRelConstraint()

bool PartConstraintImpliedByRelConstraint	(	Relation	scanrel,
		List *	partConstraint
	)

Definition at line 20085 of file tablecmds.c.

{
    List       *existConstraint = NIL;
    TupleConstr *constr = RelationGetDescr(scanrel)->constr;
    int         i;
 
    if (constr && constr->has_not_null)
    {
        int         natts = scanrel->rd_att->natts;
 
        for (i = 1; i <= natts; i++)
        {
            CompactAttribute *att = TupleDescCompactAttr(scanrel->rd_att, i - 1);
 
            /* invalid not-null constraint must be ignored here */
            if (att->attnullability == ATTNULLABLE_VALID && !att->attisdropped)
            {
                Form_pg_attribute wholeatt = TupleDescAttr(scanrel->rd_att, i - 1);
                NullTest   *ntest = makeNode(NullTest);
 
                ntest->arg = (Expr *) makeVar(1,
                                              i,
                                              wholeatt->atttypid,
                                              wholeatt->atttypmod,
                                              wholeatt->attcollation,
                                              0);
                ntest->nulltesttype = IS_NOT_NULL;
 
                /*
                 * argisrow=false is correct even for a composite column,
                 * because attnotnull does not represent a SQL-spec IS NOT
                 * NULL test in such a case, just IS DISTINCT FROM NULL.
                 */
                ntest->argisrow = false;
                ntest->location = -1;
                existConstraint = lappend(existConstraint, ntest);
            }
        }
    }
 
    return ConstraintImpliedByRelConstraint(scanrel, partConstraint, existConstraint);
}

References NullTest::arg, CompactAttribute::attisdropped, CompactAttribute::attnullability, ATTNULLABLE_VALID, ConstraintImpliedByRelConstraint(), TupleConstr::has_not_null, i, IS_NOT_NULL, lappend(), NullTest::location, makeNode, makeVar(), TupleDescData::natts, NIL, NullTest::nulltesttype, RelationData::rd_att, RelationGetDescr, TupleDescAttr(), and TupleDescCompactAttr().

Referenced by check_default_partition_contents(), and QueuePartitionConstraintValidation().

PreCommit_on_commit_actions()

void PreCommit_on_commit_actions

(

void

)

Definition at line 19346 of file tablecmds.c.

{
    ListCell   *l;
    List       *oids_to_truncate = NIL;
    List       *oids_to_drop = NIL;
 
    foreach(l, on_commits)
    {
        OnCommitItem *oc = (OnCommitItem *) lfirst(l);
 
        /* Ignore entry if already dropped in this xact */
        if (oc->deleting_subid != InvalidSubTransactionId)
            continue;
 
        switch (oc->oncommit)
        {
            case ONCOMMIT_NOOP:
            case ONCOMMIT_PRESERVE_ROWS:
                /* Do nothing (there shouldn't be such entries, actually) */
                break;
            case ONCOMMIT_DELETE_ROWS:
 
                /*
                 * If this transaction hasn't accessed any temporary
                 * relations, we can skip truncating ON COMMIT DELETE ROWS
                 * tables, as they must still be empty.
                 */
                if ((MyXactFlags & XACT_FLAGS_ACCESSEDTEMPNAMESPACE))
                    oids_to_truncate = lappend_oid(oids_to_truncate, oc->relid);
                break;
            case ONCOMMIT_DROP:
                oids_to_drop = lappend_oid(oids_to_drop, oc->relid);
                break;
        }
    }
 
    /*
     * Truncate relations before dropping so that all dependencies between
     * relations are removed after they are worked on.  Doing it like this
     * might be a waste as it is possible that a relation being truncated will
     * be dropped anyway due to its parent being dropped, but this makes the
     * code more robust because of not having to re-check that the relation
     * exists at truncation time.
     */
    if (oids_to_truncate != NIL)
        heap_truncate(oids_to_truncate);
 
    if (oids_to_drop != NIL)
    {
        ObjectAddresses *targetObjects = new_object_addresses();
 
        foreach(l, oids_to_drop)
        {
            ObjectAddress object;
 
            object.classId = RelationRelationId;
            object.objectId = lfirst_oid(l);
            object.objectSubId = 0;
 
            Assert(!object_address_present(&object, targetObjects));
 
            add_exact_object_address(&object, targetObjects);
        }
 
        /*
         * Object deletion might involve toast table access (to clean up
         * toasted catalog entries), so ensure we have a valid snapshot.
         */
        PushActiveSnapshot(GetTransactionSnapshot());
 
        /*
         * Since this is an automatic drop, rather than one directly initiated
         * by the user, we pass the PERFORM_DELETION_INTERNAL flag.
         */
        performMultipleDeletions(targetObjects, DROP_CASCADE,
                                 PERFORM_DELETION_INTERNAL | PERFORM_DELETION_QUIETLY);
 
        PopActiveSnapshot();
 
#ifdef USE_ASSERT_CHECKING
 
        /*
         * Note that table deletion will call remove_on_commit_action, so the
         * entry should get marked as deleted.
         */
        foreach(l, on_commits)
        {
            OnCommitItem *oc = (OnCommitItem *) lfirst(l);
 
            if (oc->oncommit != ONCOMMIT_DROP)
                continue;
 
            Assert(oc->deleting_subid != InvalidSubTransactionId);
        }
#endif
    }
}

References add_exact_object_address(), Assert(), ObjectAddress::classId, OnCommitItem::deleting_subid, DROP_CASCADE, GetTransactionSnapshot(), heap_truncate(), InvalidSubTransactionId, lappend_oid(), lfirst, lfirst_oid, MyXactFlags, new_object_addresses(), NIL, object_address_present(), on_commits, OnCommitItem::oncommit, ONCOMMIT_DELETE_ROWS, ONCOMMIT_DROP, ONCOMMIT_NOOP, ONCOMMIT_PRESERVE_ROWS, PERFORM_DELETION_INTERNAL, PERFORM_DELETION_QUIETLY, performMultipleDeletions(), PopActiveSnapshot(), PushActiveSnapshot(), OnCommitItem::relid, and XACT_FLAGS_ACCESSEDTEMPNAMESPACE.

Referenced by CommitTransaction(), and PrepareTransaction().

RangeVarCallbackMaintainsTable()

void RangeVarCallbackMaintainsTable	(	const RangeVar *	relation,
		Oid	relId,
		Oid	oldRelId,
		void *	arg
	)

Definition at line 19520 of file tablecmds.c.

{
    char        relkind;
    AclResult   aclresult;
 
    /* Nothing to do if the relation was not found. */
    if (!OidIsValid(relId))
        return;
 
    /*
     * If the relation does exist, check whether it's an index.  But note that
     * the relation might have been dropped between the time we did the name
     * lookup and now.  In that case, there's nothing to do.
     */
    relkind = get_rel_relkind(relId);
    if (!relkind)
        return;
    if (relkind != RELKIND_RELATION && relkind != RELKIND_TOASTVALUE &&
        relkind != RELKIND_MATVIEW && relkind != RELKIND_PARTITIONED_TABLE)
        ereport(ERROR,
                (errcode(ERRCODE_WRONG_OBJECT_TYPE),
                 errmsg("\"%s\" is not a table or materialized view", relation->relname)));
 
    /* Check permissions */
    aclresult = pg_class_aclcheck(relId, GetUserId(), ACL_MAINTAIN);
    if (aclresult != ACLCHECK_OK)
        aclcheck_error(aclresult,
                       get_relkind_objtype(get_rel_relkind(relId)),
                       relation->relname);
}

References ACL_MAINTAIN, aclcheck_error(), ACLCHECK_OK, ereport, errcode(), errmsg(), ERROR, get_rel_relkind(), get_relkind_objtype(), GetUserId(), OidIsValid, pg_class_aclcheck(), and RangeVar::relname.

Referenced by cluster(), ExecRefreshMatView(), and ReindexTable().

RangeVarCallbackOwnsRelation()

void RangeVarCallbackOwnsRelation	(	const RangeVar *	relation,
		Oid	relId,
		Oid	oldRelId,
		void *	arg
	)

Definition at line 19580 of file tablecmds.c.

{
    HeapTuple   tuple;
 
    /* Nothing to do if the relation was not found. */
    if (!OidIsValid(relId))
        return;
 
    tuple = SearchSysCache1(RELOID, ObjectIdGetDatum(relId));
    if (!HeapTupleIsValid(tuple))   /* should not happen */
        elog(ERROR, "cache lookup failed for relation %u", relId);
 
    if (!object_ownercheck(RelationRelationId, relId, GetUserId()))
        aclcheck_error(ACLCHECK_NOT_OWNER, get_relkind_objtype(get_rel_relkind(relId)),
                       relation->relname);
 
    if (!allowSystemTableMods &&
        IsSystemClass(relId, (Form_pg_class) GETSTRUCT(tuple)))
        ereport(ERROR,
                (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
                 errmsg("permission denied: \"%s\" is a system catalog",
                        relation->relname)));
 
    ReleaseSysCache(tuple);
}

References aclcheck_error(), ACLCHECK_NOT_OWNER, allowSystemTableMods, elog, ereport, errcode(), errmsg(), ERROR, get_rel_relkind(), get_relkind_objtype(), GETSTRUCT(), GetUserId(), HeapTupleIsValid, IsSystemClass(), object_ownercheck(), ObjectIdGetDatum(), OidIsValid, ReleaseSysCache(), RangeVar::relname, and SearchSysCache1().

Referenced by AlterSequence(), ProcessUtilitySlow(), transformPartitionCmdForMerge(), and transformPartitionCmdForSplit().

register_on_commit_action()

void register_on_commit_action	(	Oid	relid,
		OnCommitAction	action
	)

Definition at line 19287 of file tablecmds.c.

{
    OnCommitItem *oc;
    MemoryContext oldcxt;
 
    /*
     * We needn't bother registering the relation unless there is an ON COMMIT
     * action we need to take.
     */
    if (action == ONCOMMIT_NOOP || action == ONCOMMIT_PRESERVE_ROWS)
        return;
 
    oldcxt = MemoryContextSwitchTo(CacheMemoryContext);
 
    oc = palloc_object(OnCommitItem);
    oc->relid = relid;
    oc->oncommit = action;
    oc->creating_subid = GetCurrentSubTransactionId();
    oc->deleting_subid = InvalidSubTransactionId;
 
    /*
     * We use lcons() here so that ON COMMIT actions are processed in reverse
     * order of registration.  That might not be essential but it seems
     * reasonable.
     */
    on_commits = lcons(oc, on_commits);
 
    MemoryContextSwitchTo(oldcxt);
}

References generate_unaccent_rules::action, CacheMemoryContext, OnCommitItem::creating_subid, OnCommitItem::deleting_subid, GetCurrentSubTransactionId(), InvalidSubTransactionId, lcons(), MemoryContextSwitchTo(), on_commits, OnCommitItem::oncommit, ONCOMMIT_NOOP, ONCOMMIT_PRESERVE_ROWS, palloc_object, and OnCommitItem::relid.

Referenced by heap_create_with_catalog().

remove_on_commit_action()

void remove_on_commit_action

(

Oid

relid

)

Definition at line 19323 of file tablecmds.c.

{
    ListCell   *l;
 
    foreach(l, on_commits)
    {
        OnCommitItem *oc = (OnCommitItem *) lfirst(l);
 
        if (oc->relid == relid)
        {
            oc->deleting_subid = GetCurrentSubTransactionId();
            break;
        }
    }
}

References OnCommitItem::deleting_subid, GetCurrentSubTransactionId(), lfirst, on_commits, and OnCommitItem::relid.

Referenced by heap_drop_with_catalog().

RemoveRelations()

void RemoveRelations

(

DropStmt *

drop

)

Definition at line 1533 of file tablecmds.c.

{
    ObjectAddresses *objects;
    char        relkind;
    ListCell   *cell;
    int         flags = 0;
    LOCKMODE    lockmode = AccessExclusiveLock;
 
    /* DROP CONCURRENTLY uses a weaker lock, and has some restrictions */
    if (drop->concurrent)
    {
        /*
         * Note that for temporary relations this lock may get upgraded later
         * on, but as no other session can access a temporary relation, this
         * is actually fine.
         */
        lockmode = ShareUpdateExclusiveLock;
        Assert(drop->removeType == OBJECT_INDEX);
        if (list_length(drop->objects) != 1)
            ereport(ERROR,
                    (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                     errmsg("DROP INDEX CONCURRENTLY does not support dropping multiple objects")));
        if (drop->behavior == DROP_CASCADE)
            ereport(ERROR,
                    (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                     errmsg("DROP INDEX CONCURRENTLY does not support CASCADE")));
    }
 
    /*
     * First we identify all the relations, then we delete them in a single
     * performMultipleDeletions() call.  This is to avoid unwanted DROP
     * RESTRICT errors if one of the relations depends on another.
     */
 
    /* Determine required relkind */
    switch (drop->removeType)
    {
        case OBJECT_TABLE:
            relkind = RELKIND_RELATION;
            break;
 
        case OBJECT_INDEX:
            relkind = RELKIND_INDEX;
            break;
 
        case OBJECT_SEQUENCE:
            relkind = RELKIND_SEQUENCE;
            break;
 
        case OBJECT_VIEW:
            relkind = RELKIND_VIEW;
            break;
 
        case OBJECT_MATVIEW:
            relkind = RELKIND_MATVIEW;
            break;
 
        case OBJECT_FOREIGN_TABLE:
            relkind = RELKIND_FOREIGN_TABLE;
            break;
 
        default:
            elog(ERROR, "unrecognized drop object type: %d",
                 (int) drop->removeType);
            relkind = 0;        /* keep compiler quiet */
            break;
    }
 
    /* Lock and validate each relation; build a list of object addresses */
    objects = new_object_addresses();
 
    foreach(cell, drop->objects)
    {
        RangeVar   *rel = makeRangeVarFromNameList((List *) lfirst(cell));
        Oid         relOid;
        ObjectAddress obj;
        struct DropRelationCallbackState state;
 
        /*
         * These next few steps are a great deal like relation_openrv, but we
         * don't bother building a relcache entry since we don't need it.
         *
         * Check for shared-cache-inval messages before trying to access the
         * relation.  This is needed to cover the case where the name
         * identifies a rel that has been dropped and recreated since the
         * start of our transaction: if we don't flush the old syscache entry,
         * then we'll latch onto that entry and suffer an error later.
         */
        AcceptInvalidationMessages();
 
        /* Look up the appropriate relation using namespace search. */
        state.expected_relkind = relkind;
        state.heap_lockmode = drop->concurrent ?
            ShareUpdateExclusiveLock : AccessExclusiveLock;
        /* We must initialize these fields to show that no locks are held: */
        state.heapOid = InvalidOid;
        state.partParentOid = InvalidOid;
 
        relOid = RangeVarGetRelidExtended(rel, lockmode, RVR_MISSING_OK,
                                          RangeVarCallbackForDropRelation,
                                          &state);
 
        /* Not there? */
        if (!OidIsValid(relOid))
        {
            DropErrorMsgNonExistent(rel, relkind, drop->missing_ok);
            continue;
        }
 
        /*
         * Decide if concurrent mode needs to be used here or not.  The
         * callback retrieved the rel's persistence for us.
         */
        if (drop->concurrent &&
            state.actual_relpersistence != RELPERSISTENCE_TEMP)
        {
            Assert(list_length(drop->objects) == 1 &&
                   drop->removeType == OBJECT_INDEX);
            flags |= PERFORM_DELETION_CONCURRENTLY;
        }
 
        /*
         * Concurrent index drop cannot be used with partitioned indexes,
         * either.
         */
        if ((flags & PERFORM_DELETION_CONCURRENTLY) != 0 &&
            state.actual_relkind == RELKIND_PARTITIONED_INDEX)
            ereport(ERROR,
                    (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                     errmsg("cannot drop partitioned index \"%s\" concurrently",
                            rel->relname)));
 
        /*
         * If we're told to drop a partitioned index, we must acquire lock on
         * all the children of its parent partitioned table before proceeding.
         * Otherwise we'd try to lock the child index partitions before their
         * tables, leading to potential deadlock against other sessions that
         * will lock those objects in the other order.
         */
        if (state.actual_relkind == RELKIND_PARTITIONED_INDEX)
            (void) find_all_inheritors(state.heapOid,
                                       state.heap_lockmode,
                                       NULL);
 
        /* OK, we're ready to delete this one */
        obj.classId = RelationRelationId;
        obj.objectId = relOid;
        obj.objectSubId = 0;
 
        add_exact_object_address(&obj, objects);
    }
 
    performMultipleDeletions(objects, drop->behavior, flags);
 
    free_object_addresses(objects);
}

References AcceptInvalidationMessages(), AccessExclusiveLock, add_exact_object_address(), Assert(), DropStmt::behavior, ObjectAddress::classId, DropStmt::concurrent, DROP_CASCADE, DropErrorMsgNonExistent(), elog, ereport, errcode(), errmsg(), ERROR, find_all_inheritors(), free_object_addresses(), InvalidOid, lfirst, list_length(), makeRangeVarFromNameList(), DropStmt::missing_ok, new_object_addresses(), OBJECT_FOREIGN_TABLE, OBJECT_INDEX, OBJECT_MATVIEW, OBJECT_SEQUENCE, OBJECT_TABLE, OBJECT_VIEW, ObjectAddress::objectId, DropStmt::objects, ObjectAddress::objectSubId, OidIsValid, PERFORM_DELETION_CONCURRENTLY, performMultipleDeletions(), RangeVarCallbackForDropRelation(), RangeVarGetRelidExtended(), RangeVar::relname, DropStmt::removeType, RVR_MISSING_OK, and ShareUpdateExclusiveLock.

Referenced by ExecDropStmt().

renameatt()

ObjectAddress renameatt

(

RenameStmt *

stmt

)

Definition at line 4006 of file tablecmds.c.

{
    Oid         relid;
    AttrNumber  attnum;
    ObjectAddress address;
 
    /* lock level taken here should match renameatt_internal */
    relid = RangeVarGetRelidExtended(stmt->relation, AccessExclusiveLock,
                                     stmt->missing_ok ? RVR_MISSING_OK : 0,
                                     RangeVarCallbackForRenameAttribute,
                                     NULL);
 
    if (!OidIsValid(relid))
    {
        ereport(NOTICE,
                (errmsg("relation \"%s\" does not exist, skipping",
                        stmt->relation->relname)));
        return InvalidObjectAddress;
    }
 
    attnum =
        renameatt_internal(relid,
                           stmt->subname,   /* old att name */
                           stmt->newname,   /* new att name */
                           stmt->relation->inh, /* recursive? */
                           false,   /* recursing? */
                           0,   /* expected inhcount */
                           stmt->behavior);
 
    ObjectAddressSubSet(address, RelationRelationId, relid, attnum);
 
    return address;
}

References AccessExclusiveLock, attnum, ereport, errmsg(), InvalidObjectAddress, NOTICE, ObjectAddressSubSet, OidIsValid, RangeVarCallbackForRenameAttribute(), RangeVarGetRelidExtended(), renameatt_internal(), RVR_MISSING_OK, and stmt.

Referenced by ExecRenameStmt().

RenameConstraint()

ObjectAddress RenameConstraint

(

RenameStmt *

stmt

)

Definition at line 4153 of file tablecmds.c.

{
    Oid         relid = InvalidOid;
    Oid         typid = InvalidOid;
 
    if (stmt->renameType == OBJECT_DOMCONSTRAINT)
    {
        Relation    rel;
        HeapTuple   tup;
 
        typid = typenameTypeId(NULL, makeTypeNameFromNameList(castNode(List, stmt->object)));
        rel = table_open(TypeRelationId, RowExclusiveLock);
        tup = SearchSysCache1(TYPEOID, ObjectIdGetDatum(typid));
        if (!HeapTupleIsValid(tup))
            elog(ERROR, "cache lookup failed for type %u", typid);
        checkDomainOwner(tup);
        ReleaseSysCache(tup);
        table_close(rel, NoLock);
    }
    else
    {
        /* lock level taken here should match rename_constraint_internal */
        relid = RangeVarGetRelidExtended(stmt->relation, AccessExclusiveLock,
                                         stmt->missing_ok ? RVR_MISSING_OK : 0,
                                         RangeVarCallbackForRenameAttribute,
                                         NULL);
        if (!OidIsValid(relid))
        {
            ereport(NOTICE,
                    (errmsg("relation \"%s\" does not exist, skipping",
                            stmt->relation->relname)));
            return InvalidObjectAddress;
        }
    }
 
    return
        rename_constraint_internal(relid, typid,
                                   stmt->subname,
                                   stmt->newname,
                                   (stmt->relation &&
                                    stmt->relation->inh),   /* recursive? */
                                   false,   /* recursing? */
                                   0 /* expected inhcount */ );
}

References AccessExclusiveLock, castNode, checkDomainOwner(), elog, ereport, errmsg(), ERROR, HeapTupleIsValid, InvalidObjectAddress, InvalidOid, makeTypeNameFromNameList(), NoLock, NOTICE, OBJECT_DOMCONSTRAINT, ObjectIdGetDatum(), OidIsValid, RangeVarCallbackForRenameAttribute(), RangeVarGetRelidExtended(), ReleaseSysCache(), rename_constraint_internal(), RowExclusiveLock, RVR_MISSING_OK, SearchSysCache1(), stmt, table_close(), table_open(), and typenameTypeId().

Referenced by ExecRenameStmt().

RenameRelation()

ObjectAddress RenameRelation

(

RenameStmt *

stmt

)

Definition at line 4203 of file tablecmds.c.

{
    bool        is_index_stmt = stmt->renameType == OBJECT_INDEX;
    Oid         relid;
    ObjectAddress address;
 
    /*
     * Grab an exclusive lock on the target table, index, sequence, view,
     * materialized view, or foreign table, which we will NOT release until
     * end of transaction.
     *
     * Lock level used here should match RenameRelationInternal, to avoid lock
     * escalation.  However, because ALTER INDEX can be used with any relation
     * type, we mustn't believe without verification.
     */
    for (;;)
    {
        LOCKMODE    lockmode;
        char        relkind;
        bool        obj_is_index;
 
        lockmode = is_index_stmt ? ShareUpdateExclusiveLock : AccessExclusiveLock;
 
        relid = RangeVarGetRelidExtended(stmt->relation, lockmode,
                                         stmt->missing_ok ? RVR_MISSING_OK : 0,
                                         RangeVarCallbackForAlterRelation,
                                         stmt);
 
        if (!OidIsValid(relid))
        {
            ereport(NOTICE,
                    (errmsg("relation \"%s\" does not exist, skipping",
                            stmt->relation->relname)));
            return InvalidObjectAddress;
        }
 
        /*
         * We allow mismatched statement and object types (e.g., ALTER INDEX
         * to rename a table), but we might've used the wrong lock level.  If
         * that happens, retry with the correct lock level.  We don't bother
         * if we already acquired AccessExclusiveLock with an index, however.
         */
        relkind = get_rel_relkind(relid);
        obj_is_index = (relkind == RELKIND_INDEX ||
                        relkind == RELKIND_PARTITIONED_INDEX);
        if (obj_is_index || is_index_stmt == obj_is_index)
            break;
 
        UnlockRelationOid(relid, lockmode);
        is_index_stmt = obj_is_index;
    }
 
    /* Do the work */
    RenameRelationInternal(relid, stmt->newname, false, is_index_stmt);
 
    ObjectAddressSet(address, RelationRelationId, relid);
 
    return address;
}

References AccessExclusiveLock, ereport, errmsg(), get_rel_relkind(), InvalidObjectAddress, NOTICE, OBJECT_INDEX, ObjectAddressSet, OidIsValid, RangeVarCallbackForAlterRelation(), RangeVarGetRelidExtended(), RenameRelationInternal(), RVR_MISSING_OK, ShareUpdateExclusiveLock, stmt, and UnlockRelationOid().

Referenced by ExecRenameStmt().

RenameRelationInternal()

void RenameRelationInternal	(	Oid	myrelid,
		const char *	newrelname,
		bool	is_internal,
		bool	is_index
	)

Definition at line 4267 of file tablecmds.c.

{
    Relation    targetrelation;
    Relation    relrelation;    /* for RELATION relation */
    ItemPointerData otid;
    HeapTuple   reltup;
    Form_pg_class relform;
    Oid         namespaceId;
 
    /*
     * Grab a lock on the target relation, which we will NOT release until end
     * of transaction.  We need at least a self-exclusive lock so that
     * concurrent DDL doesn't overwrite the rename if they start updating
     * while still seeing the old version.  The lock also guards against
     * triggering relcache reloads in concurrent sessions, which might not
     * handle this information changing under them.  For indexes, we can use a
     * reduced lock level because RelationReloadIndexInfo() handles indexes
     * specially.
     */
    targetrelation = relation_open(myrelid, is_index ? ShareUpdateExclusiveLock : AccessExclusiveLock);
    namespaceId = RelationGetNamespace(targetrelation);
 
    /*
     * Find relation's pg_class tuple, and make sure newrelname isn't in use.
     */
    relrelation = table_open(RelationRelationId, RowExclusiveLock);
 
    reltup = SearchSysCacheLockedCopy1(RELOID, ObjectIdGetDatum(myrelid));
    if (!HeapTupleIsValid(reltup))  /* shouldn't happen */
        elog(ERROR, "cache lookup failed for relation %u", myrelid);
    otid = reltup->t_self;
    relform = (Form_pg_class) GETSTRUCT(reltup);
 
    if (get_relname_relid(newrelname, namespaceId) != InvalidOid)
        ereport(ERROR,
                (errcode(ERRCODE_DUPLICATE_TABLE),
                 errmsg("relation \"%s\" already exists",
                        newrelname)));
 
    /*
     * RenameRelation is careful not to believe the caller's idea of the
     * relation kind being handled.  We don't have to worry about this, but
     * let's not be totally oblivious to it.  We can process an index as
     * not-an-index, but not the other way around.
     */
    Assert(!is_index ||
           is_index == (targetrelation->rd_rel->relkind == RELKIND_INDEX ||
                        targetrelation->rd_rel->relkind == RELKIND_PARTITIONED_INDEX));
 
    /*
     * Update pg_class tuple with new relname.  (Scribbling on reltup is OK
     * because it's a copy...)
     */
    namestrcpy(&(relform->relname), newrelname);
 
    CatalogTupleUpdate(relrelation, &otid, reltup);
    UnlockTuple(relrelation, &otid, InplaceUpdateTupleLock);
 
    InvokeObjectPostAlterHookArg(RelationRelationId, myrelid, 0,
                                 InvalidOid, is_internal);
 
    heap_freetuple(reltup);
    table_close(relrelation, RowExclusiveLock);
 
    /*
     * Also rename the associated type, if any.
     */
    if (OidIsValid(targetrelation->rd_rel->reltype))
        RenameTypeInternal(targetrelation->rd_rel->reltype,
                           newrelname, namespaceId);
 
    /*
     * Also rename the associated constraint, if any.
     */
    if (targetrelation->rd_rel->relkind == RELKIND_INDEX ||
        targetrelation->rd_rel->relkind == RELKIND_PARTITIONED_INDEX)
    {
        Oid         constraintId = get_index_constraint(myrelid);
 
        if (OidIsValid(constraintId))
            RenameConstraintById(constraintId, newrelname);
    }
 
    /*
     * Close rel, but keep lock!
     */
    relation_close(targetrelation, NoLock);
}

References AccessExclusiveLock, Assert(), CatalogTupleUpdate(), elog, ereport, errcode(), errmsg(), ERROR, get_index_constraint(), get_relname_relid(), GETSTRUCT(), heap_freetuple(), HeapTupleIsValid, InplaceUpdateTupleLock, InvalidOid, InvokeObjectPostAlterHookArg, namestrcpy(), NoLock, ObjectIdGetDatum(), OidIsValid, RelationData::rd_rel, relation_close(), relation_open(), RelationGetNamespace, RenameConstraintById(), RenameTypeInternal(), RowExclusiveLock, SearchSysCacheLockedCopy1(), ShareUpdateExclusiveLock, HeapTupleData::t_self, table_close(), table_open(), and UnlockTuple().

Referenced by ATExecAddIndexConstraint(), ATExecMergePartitions(), ATExecSplitPartition(), finish_heap_swap(), rename_constraint_internal(), RenameRelation(), and RenameType().

ResetRelRewrite()

void ResetRelRewrite

(

Oid

myrelid

)

Definition at line 4360 of file tablecmds.c.

{
    Relation    relrelation;    /* for RELATION relation */
    HeapTuple   reltup;
    Form_pg_class relform;
 
    /*
     * Find relation's pg_class tuple.
     */
    relrelation = table_open(RelationRelationId, RowExclusiveLock);
 
    reltup = SearchSysCacheCopy1(RELOID, ObjectIdGetDatum(myrelid));
    if (!HeapTupleIsValid(reltup))  /* shouldn't happen */
        elog(ERROR, "cache lookup failed for relation %u", myrelid);
    relform = (Form_pg_class) GETSTRUCT(reltup);
 
    /*
     * Update pg_class tuple.
     */
    relform->relrewrite = InvalidOid;
 
    CatalogTupleUpdate(relrelation, &reltup->t_self, reltup);
 
    heap_freetuple(reltup);
    table_close(relrelation, RowExclusiveLock);
}

References CatalogTupleUpdate(), elog, ERROR, GETSTRUCT(), heap_freetuple(), HeapTupleIsValid, InvalidOid, ObjectIdGetDatum(), RowExclusiveLock, SearchSysCacheCopy1, HeapTupleData::t_self, table_close(), and table_open().

Referenced by finish_heap_swap().

SetRelationHasSubclass()

void SetRelationHasSubclass	(	Oid	relationId,
		bool	relhassubclass
	)

Definition at line 3644 of file tablecmds.c.

{
    Relation    relationRelation;
    HeapTuple   tuple;
    Form_pg_class classtuple;
 
    Assert(CheckRelationOidLockedByMe(relationId,
                                      ShareUpdateExclusiveLock, false) ||
           CheckRelationOidLockedByMe(relationId,
                                      ShareRowExclusiveLock, true));
 
    /*
     * Fetch a modifiable copy of the tuple, modify it, update pg_class.
     */
    relationRelation = table_open(RelationRelationId, RowExclusiveLock);
    tuple = SearchSysCacheCopy1(RELOID, ObjectIdGetDatum(relationId));
    if (!HeapTupleIsValid(tuple))
        elog(ERROR, "cache lookup failed for relation %u", relationId);
    classtuple = (Form_pg_class) GETSTRUCT(tuple);
 
    if (classtuple->relhassubclass != relhassubclass)
    {
        classtuple->relhassubclass = relhassubclass;
        CatalogTupleUpdate(relationRelation, &tuple->t_self, tuple);
    }
    else
    {
        /* no need to change tuple, but force relcache rebuild anyway */
        CacheInvalidateRelcacheByTuple(tuple);
    }
 
    heap_freetuple(tuple);
    table_close(relationRelation, RowExclusiveLock);
}

References Assert(), CacheInvalidateRelcacheByTuple(), CatalogTupleUpdate(), CheckRelationOidLockedByMe(), elog, ERROR, GETSTRUCT(), heap_freetuple(), HeapTupleIsValid, ObjectIdGetDatum(), RowExclusiveLock, SearchSysCacheCopy1, ShareRowExclusiveLock, ShareUpdateExclusiveLock, HeapTupleData::t_self, table_close(), and table_open().

Referenced by acquire_inherited_sample_rows(), index_create(), IndexSetParentIndex(), and StoreCatalogInheritance1().

SetRelationTableSpace()

void SetRelationTableSpace	(	Relation	rel,
		Oid	newTableSpaceId,
		RelFileNumber	newRelFilenumber
	)

Definition at line 3747 of file tablecmds.c.

{
    Relation    pg_class;
    HeapTuple   tuple;
    ItemPointerData otid;
    Form_pg_class rd_rel;
    Oid         reloid = RelationGetRelid(rel);
 
    Assert(CheckRelationTableSpaceMove(rel, newTableSpaceId));
 
    /* Get a modifiable copy of the relation's pg_class row. */
    pg_class = table_open(RelationRelationId, RowExclusiveLock);
 
    tuple = SearchSysCacheLockedCopy1(RELOID, ObjectIdGetDatum(reloid));
    if (!HeapTupleIsValid(tuple))
        elog(ERROR, "cache lookup failed for relation %u", reloid);
    otid = tuple->t_self;
    rd_rel = (Form_pg_class) GETSTRUCT(tuple);
 
    /* Update the pg_class row. */
    rd_rel->reltablespace = (newTableSpaceId == MyDatabaseTableSpace) ?
        InvalidOid : newTableSpaceId;
    if (RelFileNumberIsValid(newRelFilenumber))
        rd_rel->relfilenode = newRelFilenumber;
    CatalogTupleUpdate(pg_class, &otid, tuple);
    UnlockTuple(pg_class, &otid, InplaceUpdateTupleLock);
 
    /*
     * Record dependency on tablespace.  This is only required for relations
     * that have no physical storage.
     */
    if (!RELKIND_HAS_STORAGE(rel->rd_rel->relkind))
        changeDependencyOnTablespace(RelationRelationId, reloid,
                                     rd_rel->reltablespace);
 
    heap_freetuple(tuple);
    table_close(pg_class, RowExclusiveLock);
}

References Assert(), CatalogTupleUpdate(), changeDependencyOnTablespace(), CheckRelationTableSpaceMove(), elog, ERROR, GETSTRUCT(), heap_freetuple(), HeapTupleIsValid, InplaceUpdateTupleLock, InvalidOid, MyDatabaseTableSpace, ObjectIdGetDatum(), RelationData::rd_rel, RelationGetRelid, RelFileNumberIsValid, RowExclusiveLock, SearchSysCacheLockedCopy1(), HeapTupleData::t_self, table_close(), table_open(), and UnlockTuple().

Referenced by ATExecSetTableSpace(), ATExecSetTableSpaceNoStorage(), and reindex_index().