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.

Functions
ObjectAddress	DefineRelation (CreateStmt *stmt, char relkind, Oid ownerId, ObjectAddress *typaddress)
void	RemoveRelations (DropStmt *drop)
Oid	AlterTableLookupRelation (AlterTableStmt *stmt, LOCKMODE lockmode)
void	AlterTable (Oid relid, LOCKMODE lockmode, AlterTableStmt *stmt)
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	SetRelationHasSubclass (Oid relationId, bool relhassubclass)
ObjectAddress	renameatt (RenameStmt *stmt)
ObjectAddress	renameatt_type (RenameStmt *stmt)
ObjectAddress	RenameConstraint (RenameStmt *stmt)
ObjectAddress	RenameRelation (RenameStmt *stmt)
void	RenameRelationInternal (Oid myrelid, const char *newrelname, bool is_internal)
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	RangeVarCallbackOwnsTable (const RangeVar *relation, Oid relId, Oid oldRelId, void *arg)
void	RangeVarCallbackOwnsRelation (const RangeVar *relation, Oid relId, Oid oldRelId, void *noCatalogs)

Function Documentation

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

Definition at line 11466 of file tablecmds.c.

References add_exact_object_address(), Assert, CatalogUpdateIndexes(), changeDependencyFor(), ObjectAddress::classId, elog, ereport, errcode(), errmsg(), ERROR, get_namespace_name(), get_relname_relid(), GETSTRUCT, heap_freetuple(), HeapTupleIsValid, InvalidOid, InvokeObjectPostAlterHook, NamespaceRelationId, NameStr, object_address_present(), ObjectAddress::objectId, ObjectIdGetDatum, ObjectAddress::objectSubId, RelationRelationId, RELOID, SearchSysCacheCopy1, simple_heap_update(), and HeapTupleData::t_self.

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

{
    HeapTuple   classTup;
    Form_pg_class classForm;
    ObjectAddress thisobj;
    bool        already_done = false;

    classTup = SearchSysCacheCopy1(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)
    {
        /* 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;

        simple_heap_update(classRel, &classTup->t_self, classTup);
        CatalogUpdateIndexes(classRel, classTup);

        /* Update dependency on schema if caller said so */
        if (hasDependEntry &&
            changeDependencyFor(RelationRelationId,
                                relOid,
                                NamespaceRelationId,
                                oldNspOid,
                                newNspOid) != 1)
            elog(ERROR, "failed to change schema dependency for relation \"%s\"",
                 NameStr(classForm->relname));
    }
    if (!already_done)
    {
        add_exact_object_address(&thisobj, objsMoved);

        InvokeObjectPostAlterHook(RelationRelationId, relOid, 0);
    }

    heap_freetuple(classTup);
}

void AlterTable	(	Oid	relid,
		LOCKMODE	lockmode,
		AlterTableStmt *	stmt
	)

Definition at line 2771 of file tablecmds.c.

References ATController(), CheckTableNotInUse(), AlterTableStmt::cmds, RangeVar::inhOpt, interpretInhOption(), NoLock, AlterTableStmt::relation, and relation_open().

Referenced by ProcessUtilitySlow().

{
    Relation    rel;

    /* Caller is required to provide an adequate lock. */
    rel = relation_open(relid, NoLock);

    CheckTableNotInUse(rel, "ALTER TABLE");

    ATController(stmt,
                 rel, stmt->cmds, interpretInhOption(stmt->relation->inhOpt),
                 lockmode);
}

LOCKMODE AlterTableGetLockLevel

(

List *

cmds

)

Definition at line 2842 of file tablecmds.c.

References AccessExclusiveLock, AlterTableGetRelOptionsLockLevel(), AT_AddColumn, AT_AddColumnToView, AT_AddConstraint, AT_AddConstraintRecurse, AT_AddIndex, AT_AddIndexConstraint, AT_AddInherit, AT_AddOf, AT_AddOids, AT_AlterColumnGenericOptions, AT_AlterColumnType, AT_AlterConstraint, AT_ChangeOwner, AT_ClusterOn, AT_ColumnDefault, AT_DisableRowSecurity, AT_DisableRule, AT_DisableTrig, AT_DisableTrigAll, AT_DisableTrigUser, AT_DropCluster, AT_DropColumn, AT_DropConstraint, 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_NoForceRowSecurity, AT_ProcessedConstraint, AT_ReAddConstraint, AT_ReplaceRelOptions, AT_ReplicaIdentity, AT_ResetOptions, AT_ResetRelOptions, AT_SetLogged, AT_SetNotNull, AT_SetOptions, AT_SetRelOptions, AT_SetStatistics, AT_SetStorage, AT_SetTableSpace, AT_SetUnLogged, 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().

{
    /*
     * 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_SetTableSpace:      /* must rewrite heap */
            case AT_AlterColumnType:    /* must rewrite heap */
            case AT_AddOids:    /* 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
                 * optimised assuming the constraint holds true.
                 */
            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:   /* calls AT_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 optimisation.
                 */
            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_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:
                cmd_lockmode = AccessExclusiveLock;
                break;

            case AT_AddConstraint:
            case AT_ProcessedConstraint:        /* becomes AT_AddConstraint */
            case AT_AddConstraintRecurse:       /* becomes AT_AddConstraint */
            case AT_ReAddConstraint:    /* 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;

            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;
}

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

Definition at line 2797 of file tablecmds.c.

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

Referenced by AlterTableMoveAll(), DefineVirtualRelation(), and index_check_primary_key().

{
    Relation    rel;
    LOCKMODE    lockmode = AlterTableGetLockLevel(cmds);

    rel = relation_open(relid, lockmode);

    EventTriggerAlterTableRelid(relid);

    ATController(NULL, rel, cmds, recurse, lockmode);
}

Oid AlterTableLookupRelation	(	AlterTableStmt *	stmt,
		LOCKMODE	lockmode
	)

Definition at line 2721 of file tablecmds.c.

References AlterTableStmt::missing_ok, RangeVarCallbackForAlterRelation(), RangeVarGetRelidExtended(), and AlterTableStmt::relation.

Referenced by ProcessUtilitySlow().

{
    return RangeVarGetRelidExtended(stmt->relation, lockmode, stmt->missing_ok, false,
                                    RangeVarCallbackForAlterRelation,
                                    (void *) stmt);
}

Oid AlterTableMoveAll

(

AlterTableMoveAllStmt *

stmt

)

Definition at line 9726 of file tablecmds.c.

References AccessExclusiveLock, AccessShareLock, ACL_CREATE, ACL_KIND_CLASS, ACL_KIND_TABLESPACE, aclcheck_error(), ACLCHECK_NOT_OWNER, ACLCHECK_OK, AlterTableInternal(), Anum_pg_class_reltablespace, AT_SetTableSpace, BTEqualStrategyNumber, ConditionalLockRelationOid(), ereport, errcode(), errmsg(), ERROR, EventTriggerAlterTableEnd(), EventTriggerAlterTableStart(), ForwardScanDirection, get_namespace_name(), get_tablespace_name(), get_tablespace_oid(), GETSTRUCT, GetUserId(), GLOBALTABLESPACE_OID, heap_beginscan_catalog(), heap_close, heap_endscan(), heap_getnext(), heap_open(), HeapTupleGetOid, InvalidOid, isAnyTempNamespace(), IsSystemNamespace(), lappend(), lappend_oid(), lfirst_oid, list_member_oid(), LockRelationOid(), makeNode, MyDatabaseTableSpace, AlterTableCmd::name, NameStr, AlterTableMoveAllStmt::new_tablespacename, NIL, NOTICE, AlterTableMoveAllStmt::nowait, NULL, OBJECT_INDEX, OBJECT_MATVIEW, OBJECT_TABLE, ObjectIdGetDatum, AlterTableMoveAllStmt::objtype, OidIsValid, AlterTableMoveAllStmt::orig_tablespacename, pg_class_ownercheck(), pg_tablespace_aclcheck(), PG_TOAST_NAMESPACE, RelationRelationId, RELKIND_INDEX, RELKIND_MATVIEW, RELKIND_RELATION, AlterTableMoveAllStmt::roles, roleSpecsToIds(), ScanKeyInit(), and AlterTableCmd::subtype.

Referenced by ProcessUtilitySlow().

{
    List       *relations = NIL;
    ListCell   *l;
    ScanKeyData key[1];
    Relation    rel;
    HeapScanDesc 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 = pg_tablespace_aclcheck(new_tablespaceoid, GetUserId(),
                                           ACL_CREATE);
        if (aclresult != ACLCHECK_OK)
            aclcheck_error(aclresult, ACL_KIND_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 = heap_open(RelationRelationId, AccessShareLock);
    scan = heap_beginscan_catalog(rel, 1, key);
    while ((tuple = heap_getnext(scan, ForwardScanDirection)) != NULL)
    {
        Oid         relOid = HeapTupleGetOid(tuple);
        Form_pg_class relForm;

        relForm = (Form_pg_class) GETSTRUCT(tuple);

        /*
         * 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 (IsSystemNamespace(relForm->relnamespace) || relForm->relisshared ||
            isAnyTempNamespace(relForm->relnamespace) ||
            relForm->relnamespace == PG_TOAST_NAMESPACE)
            continue;

        /* Only move the object type requested */
        if ((stmt->objtype == OBJECT_TABLE &&
             relForm->relkind != RELKIND_RELATION) ||
            (stmt->objtype == OBJECT_INDEX &&
             relForm->relkind != RELKIND_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 (!pg_class_ownercheck(relOid, GetUserId()))
            aclcheck_error(ACLCHECK_NOT_OWNER, ACL_KIND_CLASS,
                           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);
    }

    heap_endscan(scan);
    heap_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;
}

ObjectAddress AlterTableNamespace	(	AlterObjectSchemaStmt *	stmt,
		Oid *	oldschema
	)

Definition at line 11359 of file tablecmds.c.

References AccessExclusiveLock, AlterTableNamespaceInternal(), CheckSetNamespace(), ereport, errcode(), errdetail(), errmsg(), ERROR, free_object_addresses(), get_rel_name(), InvalidObjectAddress, makeRangeVar(), AlterObjectSchemaStmt::missing_ok, new_object_addresses(), AlterObjectSchemaStmt::newschema, NoLock, NOTICE, NULL, ObjectAddressSet, OidIsValid, RangeVarCallbackForAlterRelation(), RangeVarGetAndCheckCreationNamespace(), RangeVarGetRelidExtended(), RelationData::rd_rel, AlterObjectSchemaStmt::relation, relation_close(), relation_open(), RelationGetNamespace, RelationGetRelationName, RelationRelationId, RELKIND_SEQUENCE, RangeVar::relname, and sequenceIsOwned().

Referenced by ExecAlterObjectSchemaStmt().

{
    Relation    rel;
    Oid         relid;
    Oid         oldNspOid;
    Oid         nspOid;
    RangeVar   *newrv;
    ObjectAddresses *objsMoved;
    ObjectAddress myself;

    relid = RangeVarGetRelidExtended(stmt->relation, AccessExclusiveLock,
                                     stmt->missing_ok, false,
                                     RangeVarCallbackForAlterRelation,
                                     (void *) 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, &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;
}

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

Definition at line 11429 of file tablecmds.c.

References AccessExclusiveLock, AlterConstraintNamespaces(), AlterIndexNamespaces(), AlterRelationNamespaceInternal(), AlterSeqNamespaces(), AlterTypeNamespaceInternal(), Assert, heap_close, heap_open(), NULL, RelationData::rd_rel, RelationGetRelid, RelationRelationId, RELKIND_MATVIEW, RELKIND_RELATION, and RowExclusiveLock.

Referenced by AlterObjectNamespace_oid(), and AlterTableNamespace().

{
    Relation    classRel;

    Assert(objsMoved != NULL);

    /* OK, modify the pg_class row and pg_depend entry */
    classRel = heap_open(RelationRelationId, RowExclusiveLock);

    AlterRelationNamespaceInternal(classRel, RelationGetRelid(rel), oldNspOid,
                                   nspOid, true, objsMoved);

    /* Fix the table's row type too */
    AlterTypeNamespaceInternal(rel->rd_rel->reltype,
                               nspOid, false, false, objsMoved);

    /* Fix other dependent stuff */
    if (rel->rd_rel->relkind == RELKIND_RELATION ||
        rel->rd_rel->relkind == RELKIND_MATVIEW)
    {
        AlterIndexNamespaces(classRel, rel, oldNspOid, nspOid, objsMoved);
        AlterSeqNamespaces(classRel, rel, oldNspOid, nspOid,
                           objsMoved, AccessExclusiveLock);
        AlterConstraintNamespaces(RelationGetRelid(rel), oldNspOid, nspOid,
                                  false, objsMoved);
    }

    heap_close(classRel, RowExclusiveLock);
}

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

Definition at line 11834 of file tablecmds.c.

References OnCommitItem::creating_subid, OnCommitItem::deleting_subid, InvalidSubTransactionId, lfirst, list_delete_cell(), list_head(), lnext, NULL, and pfree().

Referenced by AbortSubTransaction(), and CommitSubTransaction().

{
    ListCell   *cur_item;
    ListCell   *prev_item;

    prev_item = NULL;
    cur_item = list_head(on_commits);

    while (cur_item != NULL)
    {
        OnCommitItem *oc = (OnCommitItem *) lfirst(cur_item);

        if (!isCommit && oc->creating_subid == mySubid)
        {
            /* cur_item must be removed */
            on_commits = list_delete_cell(on_commits, cur_item, prev_item);
            pfree(oc);
            if (prev_item)
                cur_item = lnext(prev_item);
            else
                cur_item = list_head(on_commits);
        }
        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;
            prev_item = cur_item;
            cur_item = lnext(prev_item);
        }
    }
}

void AtEOXact_on_commit_actions

(

bool

isCommit

)

Definition at line 11792 of file tablecmds.c.

References OnCommitItem::creating_subid, OnCommitItem::deleting_subid, InvalidSubTransactionId, lfirst, list_delete_cell(), list_head(), lnext, NULL, and pfree().

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

{
    ListCell   *cur_item;
    ListCell   *prev_item;

    prev_item = NULL;
    cur_item = list_head(on_commits);

    while (cur_item != NULL)
    {
        OnCommitItem *oc = (OnCommitItem *) lfirst(cur_item);

        if (isCommit ? oc->deleting_subid != InvalidSubTransactionId :
            oc->creating_subid != InvalidSubTransactionId)
        {
            /* cur_item must be removed */
            on_commits = list_delete_cell(on_commits, cur_item, prev_item);
            pfree(oc);
            if (prev_item)
                cur_item = lnext(prev_item);
            else
                cur_item = list_head(on_commits);
        }
        else
        {
            /* cur_item must be preserved */
            oc->creating_subid = InvalidSubTransactionId;
            oc->deleting_subid = InvalidSubTransactionId;
            prev_item = cur_item;
            cur_item = lnext(prev_item);
        }
    }
}

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

Definition at line 8911 of file tablecmds.c.

References ACL_CREATE, ACL_KIND_CLASS, ACL_KIND_NAMESPACE, aclcheck_error(), ACLCHECK_NOT_OWNER, ACLCHECK_OK, aclnewowner(), AlterTypeOwnerInternal(), Anum_pg_class_relacl, Anum_pg_class_relowner, ATExecChangeOwner(), CatalogUpdateIndexes(), change_owner_fix_column_acls(), change_owner_recurse_to_sequences(), changeDependencyOnOwner(), check_is_member_of_role(), DatumGetAclP, elog, ereport, errcode(), errdetail(), errhint(), errmsg(), ERROR, get_namespace_name(), get_rel_name(), GETSTRUCT, GetUserId(), heap_close, heap_freetuple(), heap_modify_tuple(), heap_open(), HeapTupleIsValid, i, InvalidOid, InvokeObjectPostAlterHook, lfirst_oid, list_free(), NameStr, Natts_pg_class, NoLock, ObjectIdGetDatum, pg_class_ownercheck(), pg_namespace_aclcheck(), PointerGetDatum, relation_close(), relation_open(), RelationGetDescr, RelationGetIndexList(), RelationGetRelationName, RelationRelationId, ReleaseSysCache(), RELKIND_COMPOSITE_TYPE, RELKIND_FOREIGN_TABLE, RELKIND_INDEX, RELKIND_MATVIEW, RELKIND_RELATION, RELKIND_SEQUENCE, RELKIND_TOASTVALUE, RELKIND_VIEW, RELOID, RowExclusiveLock, SearchSysCache1, sequenceIsOwned(), simple_heap_update(), superuser(), SysCacheGetAttr(), HeapTupleData::t_self, and WARNING.

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

{
    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 = heap_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:
            /* 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_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, &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)),
                     errhint("Use ALTER TYPE instead.")));
            break;
        case RELKIND_TOASTVALUE:
            if (recursing)
                break;
            /* FALL THRU */
        default:
            ereport(ERROR,
                    (errcode(ERRCODE_WRONG_OBJECT_TYPE),
            errmsg("\"%s\" is not a table, view, sequence, or foreign table",
                   NameStr(tuple_class->relname))));
    }

    /*
     * 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 (!pg_class_ownercheck(relationOid, GetUserId()))
                    aclcheck_error(ACLCHECK_NOT_OWNER, ACL_KIND_CLASS,
                                   RelationGetRelationName(target_rel));

                /* Must be able to become new owner */
                check_is_member_of_role(GetUserId(), newOwnerId);

                /* New owner must have CREATE privilege on namespace */
                aclresult = pg_namespace_aclcheck(namespaceOid, newOwnerId,
                                                  ACL_CREATE);
                if (aclresult != ACLCHECK_OK)
                    aclcheck_error(aclresult, ACL_KIND_NAMESPACE,
                                   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);

        simple_heap_update(class_rel, &newtuple->t_self, newtuple);
        CatalogUpdateIndexes(class_rel, 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_TOASTVALUE)
            changeDependencyOnOwner(RelationRelationId, relationOid,
                                    newOwnerId);

        /*
         * Also change the ownership of the table's row type, if it has one
         */
        if (tuple_class->relkind != RELKIND_INDEX)
            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_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 (tuple_class->relkind == RELKIND_RELATION ||
            tuple_class->relkind == RELKIND_MATVIEW)
        {
            /* 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);
    heap_close(class_rel, RowExclusiveLock);
    relation_close(target_rel, NoLock);
}

void check_of_type

(

HeapTuple

typetuple

)

Definition at line 4641 of file tablecmds.c.

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

Referenced by ATExecAddOf(), and transformOfType().

{
    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 not a composite type",
                        format_type_be(HeapTupleGetOid(typetuple)))));
}

void CheckTableNotInUse	(	Relation	rel,
		const char *	stmt
	)

Definition at line 2692 of file tablecmds.c.

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

Referenced by AlterTable(), ATAddCheckConstraint(), ATExecAddColumn(), ATExecDropColumn(), ATExecDropConstraint(), ATSimpleRecursion(), ATTypedTableRecursion(), cluster_rel(), DefineVirtualRelation(), ExecRefreshMatView(), heap_drop_with_catalog(), index_drop(), reindex_index(), and truncate_check_rel().

{
    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 &&
        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))));
}

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

Definition at line 457 of file tablecmds.c.

References AccessExclusiveLock, ACL_CREATE, ACL_KIND_TABLESPACE, ACL_USAGE, aclcheck_error(), aclcheck_error_type(), ACLCHECK_OK, AddRelationNewConstraints(), allowSystemTableMods, Assert, RawColumnDefault::attnum, CookedConstraint::attnum, tupleDesc::attrs, BuildDescForRelation(), CommandCounterIncrement(), CookedConstraint::conoid, CONSTR_DEFAULT, CreateStmt::constraints, CookedConstraint::contype, ColumnDef::cooked_default, ereport, errcode(), errmsg(), ERROR, CookedConstraint::expr, get_tablespace_name(), get_tablespace_oid(), GetDefaultTablespace(), GetUserId(), GLOBALTABLESPACE_OID, heap_create_with_catalog(), HEAP_RELOPT_NAMESPACES, heap_reloptions(), CookedConstraint::inhcount, CreateStmt::inhRelations, InSecurityRestrictedOperation(), interpretOidsOption(), InvalidOid, CookedConstraint::is_local, CookedConstraint::is_no_inherit, lappend(), lfirst, list_concat(), MergeAttributes(), MyDatabaseTableSpace, CookedConstraint::name, NAMEDATALEN, NIL, NoLock, NULL, ObjectAddressSet, CreateStmt::ofTypename, OidIsValid, CreateStmt::oncommit, ONCOMMIT_NOOP, CreateStmt::options, palloc(), pg_tablespace_aclcheck(), pg_type_aclcheck(), RangeVarGetAndCheckCreationNamespace(), RawColumnDefault::raw_default, ColumnDef::raw_default, CreateStmt::relation, relation_close(), relation_open(), RelationRelationId, RELKIND_RELATION, RELKIND_VIEW, RangeVar::relname, relname(), RangeVar::relpersistence, RELPERSISTENCE_TEMP, CookedConstraint::skip_validation, StoreCatalogInheritance(), StrNCpy, CreateStmt::tableElts, CreateStmt::tablespacename, tupleDesc::tdhasoid, transformRelOptions(), typenameTypeId(), and view_reloptions().

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

{
    char        relname[NAMEDATALEN];
    Oid         namespaceId;
    List       *schema = stmt->tableElts;
    Oid         relationId;
    Oid         tablespaceId;
    Relation    rel;
    TupleDesc   descriptor;
    List       *inheritOids;
    List       *old_constraints;
    bool        localHasOids;
    int         parentOidCount;
    List       *rawDefaults;
    List       *cookedDefaults;
    Datum       reloptions;
    ListCell   *listptr;
    AttrNumber  attnum;
    static char *validnsps[] = HEAP_RELOPT_NAMESPACES;
    Oid         ofTypeId;
    ObjectAddress address;

    /*
     * Truncate relname to appropriate length (probably a waste of time, as
     * parser should have done this already).
     */
    StrNCpy(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")));

    /*
     * 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")));

    /*
     * Select tablespace to use.  If not specified, use default tablespace
     * (which may in turn default to database's default).
     */
    if (stmt->tablespacename)
    {
        tablespaceId = get_tablespace_oid(stmt->tablespacename, false);
    }
    else
    {
        tablespaceId = GetDefaultTablespace(stmt->relation->relpersistence);
        /* note InvalidOid is OK in this case */
    }

    /* Check permissions except when using database's default */
    if (OidIsValid(tablespaceId) && tablespaceId != MyDatabaseTableSpace)
    {
        AclResult   aclresult;

        aclresult = pg_tablespace_aclcheck(tablespaceId, GetUserId(),
                                           ACL_CREATE);
        if (aclresult != ACLCHECK_OK)
            aclcheck_error(aclresult, ACL_KIND_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);

    if (relkind == RELKIND_VIEW)
        (void) view_reloptions(reloptions, true);
    else
        (void) heap_reloptions(relkind, reloptions, true);

    if (stmt->ofTypename)
    {
        AclResult   aclresult;

        ofTypeId = typenameTypeId(NULL, stmt->ofTypename);

        aclresult = pg_type_aclcheck(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.
     */
    schema = MergeAttributes(schema, stmt->inhRelations,
                             stmt->relation->relpersistence,
                             &inheritOids, &old_constraints, &parentOidCount);

    /*
     * Create a tuple descriptor from the relation schema.  Note that this
     * deals with column names, types, and NOT NULL constraints, but not
     * default values or CHECK constraints; we handle those below.
     */
    descriptor = BuildDescForRelation(schema);

    /*
     * Notice that we allow OIDs here only for plain tables, even though some
     * other relkinds can support them.  This is necessary because the
     * default_with_oids GUC must apply only to plain tables and not any other
     * relkind; doing otherwise would break existing pg_dump files.  We could
     * allow explicit "WITH OIDS" while not allowing default_with_oids to
     * affect other relkinds, but it would complicate interpretOidsOption().
     */
    localHasOids = interpretOidsOption(stmt->options,
                                       (relkind == RELKIND_RELATION));
    descriptor->tdhasoid = (localHasOids || parentOidCount > 0);

    /*
     * 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.)
     *
     * We can set the atthasdef flags now in the tuple descriptor; this just
     * saves StoreAttrDefault from having to do an immediate update of the
     * pg_attribute rows.
     */
    rawDefaults = NIL;
    cookedDefaults = NIL;
    attnum = 0;

    foreach(listptr, schema)
    {
        ColumnDef  *colDef = lfirst(listptr);

        attnum++;

        if (colDef->raw_default != NULL)
        {
            RawColumnDefault *rawEnt;

            Assert(colDef->cooked_default == NULL);

            rawEnt = (RawColumnDefault *) palloc(sizeof(RawColumnDefault));
            rawEnt->attnum = attnum;
            rawEnt->raw_default = colDef->raw_default;
            rawDefaults = lappend(rawDefaults, rawEnt);
            descriptor->attrs[attnum - 1]->atthasdef = true;
        }
        else if (colDef->cooked_default != NULL)
        {
            CookedConstraint *cooked;

            cooked = (CookedConstraint *) palloc(sizeof(CookedConstraint));
            cooked->contype = CONSTR_DEFAULT;
            cooked->conoid = InvalidOid;        /* until created */
            cooked->name = NULL;
            cooked->attnum = attnum;
            cooked->expr = colDef->cooked_default;
            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);
            descriptor->attrs[attnum - 1]->atthasdef = true;
        }
    }

    /*
     * Create the relation.  Inherited defaults and 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,
                                          descriptor,
                                          list_concat(cookedDefaults,
                                                      old_constraints),
                                          relkind,
                                          stmt->relation->relpersistence,
                                          false,
                                          false,
                                          localHasOids,
                                          parentOidCount,
                                          stmt->oncommit,
                                          reloptions,
                                          true,
                                          allowSystemTableMods,
                                          false,
                                          typaddress);

    /* Store inheritance information for new rel. */
    StoreCatalogInheritance(relationId, inheritOids);

    /*
     * 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 values and CHECK constraints
     * 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.
     */
    if (rawDefaults || stmt->constraints)
        AddRelationNewConstraints(rel, rawDefaults, stmt->constraints,
                                  true, 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;
}

void ExecuteTruncate

(

TruncateStmt *

stmt

)

Definition at line 1003 of file tablecmds.c.

References AccessExclusiveLock, ACL_KIND_CLASS, aclcheck_error(), ACLCHECK_NOT_OWNER, AfterTriggerBeginQuery(), AfterTriggerEndQuery(), TruncateStmt::behavior, CheckTableForSerializableConflictIn(), CreateExecutorState(), DROP_CASCADE, DROP_RESTRICT, ereport, errmsg(), EState::es_num_result_relations, EState::es_result_relation_info, EState::es_result_relations, ExecASTruncateTriggers(), ExecBSTruncateTriggers(), find_all_inheritors(), FreeExecutorState(), GetCurrentSubTransactionId(), GetOldestMultiXactId(), getOwnedSequences(), GetUserId(), heap_close, heap_create_init_fork(), heap_open(), heap_openrv(), heap_truncate_check_FKs(), heap_truncate_find_FKs(), heap_truncate_one_rel(), RangeVar::inhOpt, InitResultRelInfo(), interpretInhOption(), lappend(), lappend_oid(), lfirst, lfirst_oid, list_length(), list_member_oid(), NIL, NoLock, NOTICE, NULL, OidIsValid, palloc(), pg_class_ownercheck(), pgstat_count_truncate(), RelationData::rd_createSubid, RelationData::rd_newRelfilenodeSubid, RelationData::rd_rel, RecentXmin, REINDEX_REL_PROCESS_TOAST, reindex_relation(), relation_close(), relation_open(), RelationGetRelationName, RelationGetRelid, TruncateStmt::relations, RelationSetNewRelfilenode(), RELPERSISTENCE_UNLOGGED, ResetSequence(), TruncateStmt::restart_seqs, and truncate_check_rel().

Referenced by standard_ProcessUtility().

{
    List       *rels = NIL;
    List       *relids = NIL;
    List       *seq_relids = NIL;
    EState     *estate;
    ResultRelInfo *resultRelInfos;
    ResultRelInfo *resultRelInfo;
    SubTransactionId mySubid;
    ListCell   *cell;

    /*
     * Open, exclusive-lock, and check all the explicitly-specified relations
     */
    foreach(cell, stmt->relations)
    {
        RangeVar   *rv = lfirst(cell);
        Relation    rel;
        bool        recurse = interpretInhOption(rv->inhOpt);
        Oid         myrelid;

        rel = heap_openrv(rv, AccessExclusiveLock);
        myrelid = RelationGetRelid(rel);
        /* don't throw error for "TRUNCATE foo, foo" */
        if (list_member_oid(relids, myrelid))
        {
            heap_close(rel, AccessExclusiveLock);
            continue;
        }
        truncate_check_rel(rel);
        rels = lappend(rels, rel);
        relids = lappend_oid(relids, myrelid);

        if (recurse)
        {
            ListCell   *child;
            List       *children;

            children = find_all_inheritors(myrelid, AccessExclusiveLock, NULL);

            foreach(child, children)
            {
                Oid         childrelid = lfirst_oid(child);

                if (list_member_oid(relids, childrelid))
                    continue;

                /* find_all_inheritors already got lock */
                rel = heap_open(childrelid, NoLock);
                truncate_check_rel(rel);
                rels = lappend(rels, rel);
                relids = lappend_oid(relids, childrelid);
            }
        }
    }

    /*
     * 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.
     */
    if (stmt->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 = heap_open(relid, AccessExclusiveLock);
                ereport(NOTICE,
                        (errmsg("truncate cascades to table \"%s\"",
                                RelationGetRelationName(rel))));
                truncate_check_rel(rel);
                rels = lappend(rels, rel);
                relids = lappend_oid(relids, 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 (stmt->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 (stmt->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 (!pg_class_ownercheck(seq_relid, GetUserId()))
                    aclcheck_error(ACLCHECK_NOT_OWNER, ACL_KIND_CLASS,
                                   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.
     */
    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 */
                          0);
        resultRelInfo++;
    }
    estate->es_result_relations = resultRelInfos;
    estate->es_num_result_relations = list_length(rels);

    /*
     * 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)
    {
        estate->es_result_relation_info = resultRelInfo;
        ExecBSTruncateTriggers(estate, resultRelInfo);
        resultRelInfo++;
    }

    /*
     * OK, truncate each table.
     */
    mySubid = GetCurrentSubTransactionId();

    foreach(cell, rels)
    {
        Relation    rel = (Relation) lfirst(cell);

        /*
         * Normally, we need a transaction-safe truncation here.  However, if
         * the table was either created in the current (sub)transaction or has
         * a new relfilenode 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_newRelfilenodeSubid == mySubid)
        {
            /* Immediate, non-rollbackable truncation is OK */
            heap_truncate_one_rel(rel);
        }
        else
        {
            Oid         heap_relid;
            Oid         toast_relid;
            MultiXactId minmulti;

            /*
             * 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);

            minmulti = GetOldestMultiXactId();

            /*
             * Need the full transaction-safe pushups.
             *
             * Create a new empty storage file for the relation, and assign it
             * as the relfilenode value. The old storage file is scheduled for
             * deletion at commit.
             */
            RelationSetNewRelfilenode(rel, rel->rd_rel->relpersistence,
                                      RecentXmin, minmulti);
            if (rel->rd_rel->relpersistence == RELPERSISTENCE_UNLOGGED)
                heap_create_init_fork(rel);

            heap_relid = RelationGetRelid(rel);
            toast_relid = rel->rd_rel->reltoastrelid;

            /*
             * The same for the toast table, if any.
             */
            if (OidIsValid(toast_relid))
            {
                rel = relation_open(toast_relid, AccessExclusiveLock);
                RelationSetNewRelfilenode(rel, rel->rd_rel->relpersistence,
                                          RecentXmin, minmulti);
                if (rel->rd_rel->relpersistence == RELPERSISTENCE_UNLOGGED)
                    heap_create_init_fork(rel);
                heap_close(rel, NoLock);
            }

            /*
             * Reconstruct the indexes to match, and we're done.
             */
            reindex_relation(heap_relid, REINDEX_REL_PROCESS_TOAST, 0);
        }

        pgstat_count_truncate(rel);
    }

    /*
     * Restart owned sequences if we were asked to.
     */
    foreach(cell, seq_relids)
    {
        Oid         seq_relid = lfirst_oid(cell);

        ResetSequence(seq_relid);
    }

    /*
     * Process all AFTER STATEMENT TRUNCATE triggers.
     */
    resultRelInfo = resultRelInfos;
    foreach(cell, rels)
    {
        estate->es_result_relation_info = resultRelInfo;
        ExecASTruncateTriggers(estate, resultRelInfo);
        resultRelInfo++;
    }

    /* Handle queued AFTER triggers */
    AfterTriggerEndQuery(estate);

    /* We can clean up the EState now */
    FreeExecutorState(estate);

    /* And close the rels (can't do this while EState still holds refs) */
    foreach(cell, rels)
    {
        Relation    rel = (Relation) lfirst(cell);

        heap_close(rel, NoLock);
    }
}

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

Definition at line 4487 of file tablecmds.c.

References AccessShareLock, Anum_pg_depend_refclassid, Anum_pg_depend_refobjid, tupleDesc::attrs, BTEqualStrategyNumber, DependReferenceIndexId, DependRelationId, ereport, errcode(), errmsg(), ERROR, find_composite_type_dependencies(), get_array_type(), GETSTRUCT, heap_open(), HeapTupleIsValid, NameStr, NULL, ObjectIdGetDatum, OidIsValid, RelationData::rd_att, RelationData::rd_rel, relation_close(), relation_open(), RelationGetRelationName, RelationRelationId, RELKIND_COMPOSITE_TYPE, RELKIND_FOREIGN_TABLE, RELKIND_MATVIEW, RELKIND_RELATION, ScanKeyInit(), systable_beginscan(), systable_endscan(), systable_getnext(), and TypeRelationId.

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

{
    Relation    depRel;
    ScanKeyData key[2];
    SysScanDesc depScan;
    HeapTuple   depTup;
    Oid         arrayOid;

    /*
     * We scan pg_depend to find those things that depend on the rowtype. (We
     * assume we can ignore refobjsubid for a rowtype.)
     */
    depRel = heap_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;
        Form_pg_attribute att;

        /* Ignore dependees that aren't user columns of relations */
        /* (we assume system columns are never of rowtypes) */
        if (pg_depend->classid != RelationRelationId ||
            pg_depend->objsubid <= 0)
            continue;

        rel = relation_open(pg_depend->objid, AccessShareLock);
        att = rel->rd_att->attrs[pg_depend->objsubid - 1];

        if (rel->rd_rel->relkind == RELKIND_RELATION ||
            rel->rd_rel->relkind == RELKIND_MATVIEW)
        {
            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);

    /*
     * If there's an array type for the rowtype, must check for uses of it,
     * too.
     */
    arrayOid = get_array_type(typeOid);
    if (OidIsValid(arrayOid))
        find_composite_type_dependencies(arrayOid, origRelation, origTypeName);
}

void PreCommit_on_commit_actions

(

void

)

Definition at line 11721 of file tablecmds.c.

References Assert, ObjectAddress::classId, CommandCounterIncrement(), OnCommitItem::deleting_subid, DROP_CASCADE, heap_truncate(), InvalidSubTransactionId, lappend_oid(), lfirst, MyXactAccessedTempRel, NIL, OnCommitItem::oncommit, ONCOMMIT_DELETE_ROWS, ONCOMMIT_DROP, ONCOMMIT_NOOP, ONCOMMIT_PRESERVE_ROWS, PERFORM_DELETION_INTERNAL, performDeletion(), RelationRelationId, and OnCommitItem::relid.

Referenced by CommitTransaction(), and PrepareTransaction().

{
    ListCell   *l;
    List       *oids_to_truncate = 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 (MyXactAccessedTempRel)
                    oids_to_truncate = lappend_oid(oids_to_truncate, oc->relid);
                break;
            case ONCOMMIT_DROP:
                {
                    ObjectAddress object;

                    object.classId = RelationRelationId;
                    object.objectId = oc->relid;
                    object.objectSubId = 0;

                    /*
                     * Since this is an automatic drop, rather than one
                     * directly initiated by the user, we pass the
                     * PERFORM_DELETION_INTERNAL flag.
                     */
                    performDeletion(&object,
                                    DROP_CASCADE, PERFORM_DELETION_INTERNAL);

                    /*
                     * Note that table deletion will call
                     * remove_on_commit_action, so the entry should get marked
                     * as deleted.
                     */
                    Assert(oc->deleting_subid != InvalidSubTransactionId);
                    break;
                }
        }
    }
    if (oids_to_truncate != NIL)
    {
        heap_truncate(oids_to_truncate);
        CommandCounterIncrement();      /* XXX needed? */
    }
}

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

Definition at line 11912 of file tablecmds.c.

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

Referenced by ProcessUtilitySlow().

{
    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 (!pg_class_ownercheck(relId, GetUserId()))
        aclcheck_error(ACLCHECK_NOT_OWNER, ACL_KIND_CLASS,
                       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);
}

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

Definition at line 11879 of file tablecmds.c.

References ACL_KIND_CLASS, aclcheck_error(), ACLCHECK_NOT_OWNER, ereport, errcode(), errmsg(), ERROR, get_rel_relkind(), GetUserId(), OidIsValid, pg_class_ownercheck(), DropRelationCallbackState::relkind, RELKIND_MATVIEW, RELKIND_RELATION, RELKIND_TOASTVALUE, and RangeVar::relname.

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

{
    char        relkind;

    /* 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)
        ereport(ERROR,
                (errcode(ERRCODE_WRONG_OBJECT_TYPE),
                 errmsg("\"%s\" is not a table or materialized view", relation->relname)));

    /* Check permissions */
    if (!pg_class_ownercheck(relId, GetUserId()))
        aclcheck_error(ACLCHECK_NOT_OWNER, ACL_KIND_CLASS, relation->relname);
}

void register_on_commit_action	(	Oid	relid,
		OnCommitAction	action
	)

Definition at line 11667 of file tablecmds.c.

References CacheMemoryContext, OnCommitItem::creating_subid, OnCommitItem::deleting_subid, GetCurrentSubTransactionId(), InvalidSubTransactionId, lcons(), MemoryContextSwitchTo(), OnCommitItem::oncommit, ONCOMMIT_NOOP, ONCOMMIT_PRESERVE_ROWS, palloc(), and OnCommitItem::relid.

Referenced by heap_create_with_catalog().

{
    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 = (OnCommitItem *) palloc(sizeof(OnCommitItem));
    oc->relid = relid;
    oc->oncommit = action;
    oc->creating_subid = GetCurrentSubTransactionId();
    oc->deleting_subid = InvalidSubTransactionId;

    on_commits = lcons(oc, on_commits);

    MemoryContextSwitchTo(oldcxt);
}

void remove_on_commit_action

(

Oid

relid

)

Definition at line 11698 of file tablecmds.c.

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

Referenced by heap_drop_with_catalog().

{
    ListCell   *l;

    foreach(l, on_commits)
    {
        OnCommitItem *oc = (OnCommitItem *) lfirst(l);

        if (oc->relid == relid)
        {
            oc->deleting_subid = GetCurrentSubTransactionId();
            break;
        }
    }
}

void RemoveRelations

(

DropStmt *

drop

)

Definition at line 804 of file tablecmds.c.

References AcceptInvalidationMessages(), AccessExclusiveLock, add_exact_object_address(), Assert, DropStmt::behavior, ObjectAddress::classId, DropRelationCallbackState::concurrent, DropStmt::concurrent, DROP_CASCADE, DropErrorMsgNonExistent(), elog, ereport, errcode(), errmsg(), ERROR, free_object_addresses(), DropRelationCallbackState::heapOid, 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(), RelationRelationId, DropRelationCallbackState::relkind, RELKIND_FOREIGN_TABLE, RELKIND_INDEX, RELKIND_MATVIEW, RELKIND_RELATION, RELKIND_SEQUENCE, RELKIND_VIEW, DropStmt::removeType, and ShareUpdateExclusiveLock.

Referenced by ExecDropStmt().

{
    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)
    {
        flags |= PERFORM_DELETION_CONCURRENTLY;
        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.relkind = relkind;
        state.heapOid = InvalidOid;
        state.concurrent = drop->concurrent;
        relOid = RangeVarGetRelidExtended(rel, lockmode, true,
                                          false,
                                          RangeVarCallbackForDropRelation,
                                          (void *) &state);

        /* Not there? */
        if (!OidIsValid(relOid))
        {
            DropErrorMsgNonExistent(rel, relkind, drop->missing_ok);
            continue;
        }

        /* 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);
}

ObjectAddress renameatt

(

RenameStmt *

stmt

)

Definition at line 2362 of file tablecmds.c.

References AccessExclusiveLock, RenameStmt::behavior, ereport, errmsg(), RangeVar::inhOpt, interpretInhOption(), InvalidObjectAddress, RenameStmt::missing_ok, RenameStmt::newname, NOTICE, NULL, ObjectAddressSubSet, OidIsValid, RangeVarCallbackForRenameAttribute(), RangeVarGetRelidExtended(), RenameStmt::relation, RelationRelationId, RangeVar::relname, renameatt_internal(), and RenameStmt::subname.

Referenced by ExecRenameStmt().

{
    Oid         relid;
    AttrNumber  attnum;
    ObjectAddress address;

    /* lock level taken here should match renameatt_internal */
    relid = RangeVarGetRelidExtended(stmt->relation, AccessExclusiveLock,
                                     stmt->missing_ok, false,
                                     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 */
                           interpretInhOption(stmt->relation->inhOpt),  /* recursive? */
                           false,       /* recursing? */
                           0,   /* expected inhcount */
                           stmt->behavior);

    ObjectAddressSubSet(address, RelationRelationId, relid, attnum);

    return address;
}

ObjectAddress renameatt_type

(

RenameStmt *

stmt

)

ObjectAddress RenameConstraint

(

RenameStmt *

stmt

)

Definition at line 2499 of file tablecmds.c.

References AccessExclusiveLock, checkDomainOwner(), elog, ereport, errmsg(), ERROR, heap_close, heap_open(), HeapTupleIsValid, RangeVar::inhOpt, interpretInhOption(), InvalidObjectAddress, InvalidOid, makeTypeNameFromNameList(), RenameStmt::missing_ok, RenameStmt::newname, NoLock, NOTICE, NULL, RenameStmt::object, OBJECT_DOMCONSTRAINT, ObjectIdGetDatum, OidIsValid, RangeVarCallbackForRenameAttribute(), RangeVarGetRelidExtended(), RenameStmt::relation, ReleaseSysCache(), RangeVar::relname, rename_constraint_internal(), RenameStmt::renameType, RowExclusiveLock, SearchSysCache1, RenameStmt::subname, typenameTypeId(), TYPEOID, and TypeRelationId.

Referenced by ExecRenameStmt().

{
    Oid         relid = InvalidOid;
    Oid         typid = InvalidOid;

    if (stmt->renameType == OBJECT_DOMCONSTRAINT)
    {
        Relation    rel;
        HeapTuple   tup;

        typid = typenameTypeId(NULL, makeTypeNameFromNameList(stmt->object));
        rel = heap_open(TypeRelationId, RowExclusiveLock);
        tup = SearchSysCache1(TYPEOID, ObjectIdGetDatum(typid));
        if (!HeapTupleIsValid(tup))
            elog(ERROR, "cache lookup failed for type %u", typid);
        checkDomainOwner(tup);
        ReleaseSysCache(tup);
        heap_close(rel, NoLock);
    }
    else
    {
        /* lock level taken here should match rename_constraint_internal */
        relid = RangeVarGetRelidExtended(stmt->relation, AccessExclusiveLock,
                                         stmt->missing_ok, false,
                                         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 ? interpretInhOption(stmt->relation->inhOpt) : false,   /* recursive? */
                                   false,       /* recursing? */
                                   0 /* expected inhcount */ );

}

ObjectAddress RenameRelation

(

RenameStmt *

stmt

)

Definition at line 2549 of file tablecmds.c.

References AccessExclusiveLock, ereport, errmsg(), InvalidObjectAddress, RenameStmt::missing_ok, RenameStmt::newname, NOTICE, ObjectAddressSet, OidIsValid, RangeVarCallbackForAlterRelation(), RangeVarGetRelidExtended(), RenameStmt::relation, RelationRelationId, RangeVar::relname, and RenameRelationInternal().

Referenced by ExecRenameStmt().

{
    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.
     */
    relid = RangeVarGetRelidExtended(stmt->relation, AccessExclusiveLock,
                                     stmt->missing_ok, false,
                                     RangeVarCallbackForAlterRelation,
                                     (void *) stmt);

    if (!OidIsValid(relid))
    {
        ereport(NOTICE,
                (errmsg("relation \"%s\" does not exist, skipping",
                        stmt->relation->relname)));
        return InvalidObjectAddress;
    }

    /* Do the work */
    RenameRelationInternal(relid, stmt->newname, false);

    ObjectAddressSet(address, RelationRelationId, relid);

    return address;
}

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

Definition at line 2593 of file tablecmds.c.

References AccessExclusiveLock, CatalogUpdateIndexes(), elog, ereport, errcode(), errmsg(), ERROR, get_index_constraint(), get_relname_relid(), GETSTRUCT, heap_close, heap_freetuple(), heap_open(), HeapTupleIsValid, InvalidOid, InvokeObjectPostAlterHookArg, namestrcpy(), NoLock, ObjectIdGetDatum, OidIsValid, RelationData::rd_rel, relation_close(), relation_open(), RelationGetNamespace, RelationRelationId, RELKIND_INDEX, RELOID, RenameConstraintById(), RenameTypeInternal(), RowExclusiveLock, SearchSysCacheCopy1, simple_heap_update(), and HeapTupleData::t_self.

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

{
    Relation    targetrelation;
    Relation    relrelation;    /* for RELATION relation */
    HeapTuple   reltup;
    Form_pg_class relform;
    Oid         namespaceId;

    /*
     * 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.
     */
    targetrelation = relation_open(myrelid, AccessExclusiveLock);
    namespaceId = RelationGetNamespace(targetrelation);

    /*
     * Find relation's pg_class tuple, and make sure newrelname isn't in use.
     */
    relrelation = heap_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);

    if (get_relname_relid(newrelname, namespaceId) != InvalidOid)
        ereport(ERROR,
                (errcode(ERRCODE_DUPLICATE_TABLE),
                 errmsg("relation \"%s\" already exists",
                        newrelname)));

    /*
     * Update pg_class tuple with new relname.  (Scribbling on reltup is OK
     * because it's a copy...)
     */
    namestrcpy(&(relform->relname), newrelname);

    simple_heap_update(relrelation, &reltup->t_self, reltup);

    /* keep the system catalog indexes current */
    CatalogUpdateIndexes(relrelation, reltup);

    InvokeObjectPostAlterHookArg(RelationRelationId, myrelid, 0,
                                 InvalidOid, is_internal);

    heap_freetuple(reltup);
    heap_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)
    {
        Oid         constraintId = get_index_constraint(myrelid);

        if (OidIsValid(constraintId))
            RenameConstraintById(constraintId, newrelname);
    }

    /*
     * Close rel, but keep exclusive lock!
     */
    relation_close(targetrelation, NoLock);
}

void SetRelationHasSubclass	(	Oid	relationId,
		bool	relhassubclass
	)

Definition at line 2111 of file tablecmds.c.

References CacheInvalidateRelcacheByTuple(), CatalogUpdateIndexes(), elog, ERROR, GETSTRUCT, heap_close, heap_freetuple(), heap_open(), HeapTupleIsValid, ObjectIdGetDatum, RelationRelationId, RELOID, RowExclusiveLock, SearchSysCacheCopy1, simple_heap_update(), and HeapTupleData::t_self.

Referenced by acquire_inherited_sample_rows(), and StoreCatalogInheritance1().

{
    Relation    relationRelation;
    HeapTuple   tuple;
    Form_pg_class classtuple;

    /*
     * Fetch a modifiable copy of the tuple, modify it, update pg_class.
     */
    relationRelation = heap_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;
        simple_heap_update(relationRelation, &tuple->t_self, tuple);

        /* keep the catalog indexes up to date */
        CatalogUpdateIndexes(relationRelation, tuple);
    }
    else
    {
        /* no need to change tuple, but force relcache rebuild anyway */
        CacheInvalidateRelcacheByTuple(tuple);
    }

    heap_freetuple(tuple);
    heap_close(relationRelation, RowExclusiveLock);
}