tablecmds.c File Reference

#include "postgres.h"
#include "access/attmap.h"
#include "access/genam.h"
#include "access/heapam.h"
#include "access/heapam_xlog.h"
#include "access/multixact.h"
#include "access/reloptions.h"
#include "access/relscan.h"
#include "access/sysattr.h"
#include "access/tableam.h"
#include "access/xact.h"
#include "access/xlog.h"
#include "catalog/catalog.h"
#include "catalog/dependency.h"
#include "catalog/heap.h"
#include "catalog/index.h"
#include "catalog/indexing.h"
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/partition.h"
#include "catalog/pg_am.h"
#include "catalog/pg_collation.h"
#include "catalog/pg_constraint.h"
#include "catalog/pg_depend.h"
#include "catalog/pg_foreign_table.h"
#include "catalog/pg_inherits.h"
#include "catalog/pg_namespace.h"
#include "catalog/pg_opclass.h"
#include "catalog/pg_tablespace.h"
#include "catalog/pg_trigger.h"
#include "catalog/pg_type.h"
#include "catalog/storage.h"
#include "catalog/storage_xlog.h"
#include "catalog/toasting.h"
#include "commands/cluster.h"
#include "commands/comment.h"
#include "commands/defrem.h"
#include "commands/event_trigger.h"
#include "commands/policy.h"
#include "commands/sequence.h"
#include "commands/tablecmds.h"
#include "commands/tablespace.h"
#include "commands/trigger.h"
#include "commands/typecmds.h"
#include "commands/user.h"
#include "executor/executor.h"
#include "foreign/foreign.h"
#include "miscadmin.h"
#include "nodes/makefuncs.h"
#include "nodes/nodeFuncs.h"
#include "nodes/parsenodes.h"
#include "optimizer/optimizer.h"
#include "parser/parse_clause.h"
#include "parser/parse_coerce.h"
#include "parser/parse_collate.h"
#include "parser/parse_expr.h"
#include "parser/parse_oper.h"
#include "parser/parse_relation.h"
#include "parser/parse_type.h"
#include "parser/parse_utilcmd.h"
#include "parser/parser.h"
#include "partitioning/partbounds.h"
#include "partitioning/partdesc.h"
#include "pgstat.h"
#include "rewrite/rewriteDefine.h"
#include "rewrite/rewriteHandler.h"
#include "rewrite/rewriteManip.h"
#include "storage/bufmgr.h"
#include "storage/lmgr.h"
#include "storage/lock.h"
#include "storage/predicate.h"
#include "storage/smgr.h"
#include "tcop/utility.h"
#include "utils/acl.h"
#include "utils/builtins.h"
#include "utils/fmgroids.h"
#include "utils/inval.h"
#include "utils/lsyscache.h"
#include "utils/memutils.h"
#include "utils/partcache.h"
#include "utils/relcache.h"
#include "utils/ruleutils.h"
#include "utils/snapmgr.h"
#include "utils/syscache.h"
#include "utils/timestamp.h"
#include "utils/typcache.h"

Include dependency graph for tablecmds.c:

Go to the source code of this file.

Data Structures
struct	OnCommitItem
struct	AlteredTableInfo
struct	NewConstraint
struct	NewColumnValue
struct	dropmsgstrings
struct	DropRelationCallbackState
struct	AttachIndexCallbackState

Macros
#define	AT_PASS_UNSET   -1 /* UNSET will cause ERROR */
#define	AT_PASS_DROP   0 /* DROP (all flavors) */
#define	AT_PASS_ALTER_TYPE   1 /* ALTER COLUMN TYPE */
#define	AT_PASS_OLD_INDEX   2 /* re-add existing indexes */
#define	AT_PASS_OLD_CONSTR   3 /* re-add existing constraints */
#define	AT_PASS_ADD_COL   4 /* ADD COLUMN */
#define	AT_PASS_ADD_CONSTR   5 /* ADD constraints (initial examination) */
#define	AT_PASS_COL_ATTRS   6 /* set column attributes, eg NOT NULL */
#define	AT_PASS_ADD_INDEXCONSTR   7 /* ADD index-based constraints */
#define	AT_PASS_ADD_INDEX   8 /* ADD indexes */
#define	AT_PASS_ADD_OTHERCONSTR   9 /* ADD other constraints, defaults */
#define	AT_PASS_MISC   10 /* other stuff */
#define	AT_NUM_PASSES   11
#define	ATT_TABLE   0x0001
#define	ATT_VIEW   0x0002
#define	ATT_MATVIEW   0x0004
#define	ATT_INDEX   0x0008
#define	ATT_COMPOSITE_TYPE   0x0010
#define	ATT_FOREIGN_TABLE   0x0020
#define	ATT_PARTITIONED_INDEX   0x0040
#define	child_dependency_type(child_is_partition)   ((child_is_partition) ? DEPENDENCY_AUTO : DEPENDENCY_NORMAL)

Typedefs
typedef struct OnCommitItem	OnCommitItem
typedef struct AlteredTableInfo	AlteredTableInfo
typedef struct NewConstraint	NewConstraint
typedef struct NewColumnValue	NewColumnValue

Functions
static void	truncate_check_rel (Oid relid, Form_pg_class reltuple)
static void	truncate_check_perms (Oid relid, Form_pg_class reltuple)
static void	truncate_check_activity (Relation rel)
static void	RangeVarCallbackForTruncate (const RangeVar *relation, Oid relId, Oid oldRelId, void *arg)
static List *	MergeAttributes (List *schema, List *supers, char relpersistence, bool is_partition, List **supconstr)
static bool	MergeCheckConstraint (List *constraints, char *name, Node *expr)
static void	MergeAttributesIntoExisting (Relation child_rel, Relation parent_rel)
static void	MergeConstraintsIntoExisting (Relation child_rel, Relation parent_rel)
static void	StoreCatalogInheritance (Oid relationId, List *supers, bool child_is_partition)
static void	StoreCatalogInheritance1 (Oid relationId, Oid parentOid, int32 seqNumber, Relation inhRelation, bool child_is_partition)
static int	findAttrByName (const char *attributeName, List *schema)
static void	AlterIndexNamespaces (Relation classRel, Relation rel, Oid oldNspOid, Oid newNspOid, ObjectAddresses *objsMoved)
static void	AlterSeqNamespaces (Relation classRel, Relation rel, Oid oldNspOid, Oid newNspOid, ObjectAddresses *objsMoved, LOCKMODE lockmode)
static ObjectAddress	ATExecAlterConstraint (Relation rel, AlterTableCmd *cmd, bool recurse, bool recursing, LOCKMODE lockmode)
static ObjectAddress	ATExecValidateConstraint (Relation rel, char *constrName, bool recurse, bool recursing, LOCKMODE lockmode)
static int	transformColumnNameList (Oid relId, List *colList, int16 *attnums, Oid *atttypids)
static int	transformFkeyGetPrimaryKey (Relation pkrel, Oid *indexOid, List **attnamelist, int16 *attnums, Oid *atttypids, Oid *opclasses)
static Oid	transformFkeyCheckAttrs (Relation pkrel, int numattrs, int16 *attnums, Oid *opclasses)
static void	checkFkeyPermissions (Relation rel, int16 *attnums, int natts)
static CoercionPathType	findFkeyCast (Oid targetTypeId, Oid sourceTypeId, Oid *funcid)
static void	validateCheckConstraint (Relation rel, HeapTuple constrtup)
static void	validateForeignKeyConstraint (char *conname, Relation rel, Relation pkrel, Oid pkindOid, Oid constraintOid)
static void	ATController (AlterTableStmt *parsetree, Relation rel, List *cmds, bool recurse, LOCKMODE lockmode, AlterTableUtilityContext *context)
static void	ATPrepCmd (List **wqueue, Relation rel, AlterTableCmd *cmd, bool recurse, bool recursing, LOCKMODE lockmode, AlterTableUtilityContext *context)
static void	ATRewriteCatalogs (List **wqueue, LOCKMODE lockmode, AlterTableUtilityContext *context)
static void	ATExecCmd (List **wqueue, AlteredTableInfo *tab, Relation rel, AlterTableCmd *cmd, LOCKMODE lockmode, int cur_pass, AlterTableUtilityContext *context)
static AlterTableCmd *	ATParseTransformCmd (List **wqueue, AlteredTableInfo *tab, Relation rel, AlterTableCmd *cmd, bool recurse, LOCKMODE lockmode, int cur_pass, AlterTableUtilityContext *context)
static void	ATRewriteTables (AlterTableStmt *parsetree, List **wqueue, LOCKMODE lockmode, AlterTableUtilityContext *context)
static void	ATRewriteTable (AlteredTableInfo *tab, Oid OIDNewHeap, LOCKMODE lockmode)
static AlteredTableInfo *	ATGetQueueEntry (List **wqueue, Relation rel)
static void	ATSimplePermissions (Relation rel, int allowed_targets)
static void	ATWrongRelkindError (Relation rel, int allowed_targets)
static void	ATSimpleRecursion (List **wqueue, Relation rel, AlterTableCmd *cmd, bool recurse, LOCKMODE lockmode, AlterTableUtilityContext *context)
static void	ATCheckPartitionsNotInUse (Relation rel, LOCKMODE lockmode)
static void	ATTypedTableRecursion (List **wqueue, Relation rel, AlterTableCmd *cmd, LOCKMODE lockmode, AlterTableUtilityContext *context)
static List *	find_typed_table_dependencies (Oid typeOid, const char *typeName, DropBehavior behavior)
static void	ATPrepAddColumn (List **wqueue, Relation rel, bool recurse, bool recursing, bool is_view, AlterTableCmd *cmd, LOCKMODE lockmode, AlterTableUtilityContext *context)
static ObjectAddress	ATExecAddColumn (List **wqueue, AlteredTableInfo *tab, Relation rel, AlterTableCmd **cmd, bool recurse, bool recursing, LOCKMODE lockmode, int cur_pass, AlterTableUtilityContext *context)
static bool	check_for_column_name_collision (Relation rel, const char *colname, bool if_not_exists)
static void	add_column_datatype_dependency (Oid relid, int32 attnum, Oid typid)
static void	add_column_collation_dependency (Oid relid, int32 attnum, Oid collid)
static void	ATPrepDropNotNull (Relation rel, bool recurse, bool recursing)
static ObjectAddress	ATExecDropNotNull (Relation rel, const char *colName, LOCKMODE lockmode)
static void	ATPrepSetNotNull (List **wqueue, Relation rel, AlterTableCmd *cmd, bool recurse, bool recursing, LOCKMODE lockmode, AlterTableUtilityContext *context)
static ObjectAddress	ATExecSetNotNull (AlteredTableInfo *tab, Relation rel, const char *colName, LOCKMODE lockmode)
static void	ATExecCheckNotNull (AlteredTableInfo *tab, Relation rel, const char *colName, LOCKMODE lockmode)
static bool	NotNullImpliedByRelConstraints (Relation rel, Form_pg_attribute attr)
static bool	ConstraintImpliedByRelConstraint (Relation scanrel, List *testConstraint, List *provenConstraint)
static ObjectAddress	ATExecColumnDefault (Relation rel, const char *colName, Node *newDefault, LOCKMODE lockmode)
static ObjectAddress	ATExecAddIdentity (Relation rel, const char *colName, Node *def, LOCKMODE lockmode)
static ObjectAddress	ATExecSetIdentity (Relation rel, const char *colName, Node *def, LOCKMODE lockmode)
static ObjectAddress	ATExecDropIdentity (Relation rel, const char *colName, bool missing_ok, LOCKMODE lockmode)
static void	ATPrepDropExpression (Relation rel, AlterTableCmd *cmd, bool recursing)
static ObjectAddress	ATExecDropExpression (Relation rel, const char *colName, bool missing_ok, LOCKMODE lockmode)
static ObjectAddress	ATExecSetStatistics (Relation rel, const char *colName, int16 colNum, Node *newValue, LOCKMODE lockmode)
static ObjectAddress	ATExecSetOptions (Relation rel, const char *colName, Node *options, bool isReset, LOCKMODE lockmode)
static ObjectAddress	ATExecSetStorage (Relation rel, const char *colName, Node *newValue, LOCKMODE lockmode)
static void	ATPrepDropColumn (List **wqueue, Relation rel, bool recurse, bool recursing, AlterTableCmd *cmd, LOCKMODE lockmode, AlterTableUtilityContext *context)
static ObjectAddress	ATExecDropColumn (List **wqueue, Relation rel, const char *colName, DropBehavior behavior, bool recurse, bool recursing, bool missing_ok, LOCKMODE lockmode, ObjectAddresses *addrs)
static ObjectAddress	ATExecAddIndex (AlteredTableInfo *tab, Relation rel, IndexStmt *stmt, bool is_rebuild, LOCKMODE lockmode)
static ObjectAddress	ATExecAddConstraint (List **wqueue, AlteredTableInfo *tab, Relation rel, Constraint *newConstraint, bool recurse, bool is_readd, LOCKMODE lockmode)
static char *	ChooseForeignKeyConstraintNameAddition (List *colnames)
static ObjectAddress	ATExecAddIndexConstraint (AlteredTableInfo *tab, Relation rel, IndexStmt *stmt, LOCKMODE lockmode)
static ObjectAddress	ATAddCheckConstraint (List **wqueue, AlteredTableInfo *tab, Relation rel, Constraint *constr, bool recurse, bool recursing, bool is_readd, LOCKMODE lockmode)
static ObjectAddress	ATAddForeignKeyConstraint (List **wqueue, AlteredTableInfo *tab, Relation rel, Constraint *fkconstraint, Oid parentConstr, bool recurse, bool recursing, LOCKMODE lockmode)
static ObjectAddress	addFkRecurseReferenced (List **wqueue, Constraint *fkconstraint, Relation rel, Relation pkrel, Oid indexOid, Oid parentConstr, int numfks, int16 *pkattnum, int16 *fkattnum, Oid *pfeqoperators, Oid *ppeqoperators, Oid *ffeqoperators, bool old_check_ok)
static void	addFkRecurseReferencing (List **wqueue, Constraint *fkconstraint, Relation rel, Relation pkrel, Oid indexOid, Oid parentConstr, int numfks, int16 *pkattnum, int16 *fkattnum, Oid *pfeqoperators, Oid *ppeqoperators, Oid *ffeqoperators, bool old_check_ok, LOCKMODE lockmode)
static void	CloneForeignKeyConstraints (List **wqueue, Relation parentRel, Relation partitionRel)
static void	CloneFkReferenced (Relation parentRel, Relation partitionRel)
static void	CloneFkReferencing (List **wqueue, Relation parentRel, Relation partRel)
static void	createForeignKeyCheckTriggers (Oid myRelOid, Oid refRelOid, Constraint *fkconstraint, Oid constraintOid, Oid indexOid)
static void	createForeignKeyActionTriggers (Relation rel, Oid refRelOid, Constraint *fkconstraint, Oid constraintOid, Oid indexOid)
static bool	tryAttachPartitionForeignKey (ForeignKeyCacheInfo *fk, Oid partRelid, Oid parentConstrOid, int numfks, AttrNumber *mapped_conkey, AttrNumber *confkey, Oid *conpfeqop)
static void	ATExecDropConstraint (Relation rel, const char *constrName, DropBehavior behavior, bool recurse, bool recursing, bool missing_ok, LOCKMODE lockmode)
static void	ATPrepAlterColumnType (List **wqueue, AlteredTableInfo *tab, Relation rel, bool recurse, bool recursing, AlterTableCmd *cmd, LOCKMODE lockmode, AlterTableUtilityContext *context)
static bool	ATColumnChangeRequiresRewrite (Node *expr, AttrNumber varattno)
static ObjectAddress	ATExecAlterColumnType (AlteredTableInfo *tab, Relation rel, AlterTableCmd *cmd, LOCKMODE lockmode)
static void	RememberConstraintForRebuilding (Oid conoid, AlteredTableInfo *tab)
static void	RememberIndexForRebuilding (Oid indoid, AlteredTableInfo *tab)
static void	ATPostAlterTypeCleanup (List **wqueue, AlteredTableInfo *tab, LOCKMODE lockmode)
static void	ATPostAlterTypeParse (Oid oldId, Oid oldRelId, Oid refRelId, char *cmd, List **wqueue, LOCKMODE lockmode, bool rewrite)
static void	RebuildConstraintComment (AlteredTableInfo *tab, int pass, Oid objid, Relation rel, List *domname, const char *conname)
static void	TryReuseIndex (Oid oldId, IndexStmt *stmt)
static void	TryReuseForeignKey (Oid oldId, Constraint *con)
static ObjectAddress	ATExecAlterColumnGenericOptions (Relation rel, const char *colName, List *options, LOCKMODE lockmode)
static void	change_owner_fix_column_acls (Oid relationOid, Oid oldOwnerId, Oid newOwnerId)
static void	change_owner_recurse_to_sequences (Oid relationOid, Oid newOwnerId, LOCKMODE lockmode)
static ObjectAddress	ATExecClusterOn (Relation rel, const char *indexName, LOCKMODE lockmode)
static void	ATExecDropCluster (Relation rel, LOCKMODE lockmode)
static bool	ATPrepChangePersistence (Relation rel, bool toLogged)
static void	ATPrepSetTableSpace (AlteredTableInfo *tab, Relation rel, const char *tablespacename, LOCKMODE lockmode)
static void	ATExecSetTableSpace (Oid tableOid, Oid newTableSpace, LOCKMODE lockmode)
static void	ATExecSetTableSpaceNoStorage (Relation rel, Oid newTableSpace)
static void	ATExecSetRelOptions (Relation rel, List *defList, AlterTableType operation, LOCKMODE lockmode)
static void	ATExecEnableDisableTrigger (Relation rel, const char *trigname, char fires_when, bool skip_system, LOCKMODE lockmode)
static void	ATExecEnableDisableRule (Relation rel, const char *rulename, char fires_when, LOCKMODE lockmode)
static void	ATPrepAddInherit (Relation child_rel)
static ObjectAddress	ATExecAddInherit (Relation child_rel, RangeVar *parent, LOCKMODE lockmode)
static ObjectAddress	ATExecDropInherit (Relation rel, RangeVar *parent, LOCKMODE lockmode)
static void	drop_parent_dependency (Oid relid, Oid refclassid, Oid refobjid, DependencyType deptype)
static ObjectAddress	ATExecAddOf (Relation rel, const TypeName *ofTypename, LOCKMODE lockmode)
static void	ATExecDropOf (Relation rel, LOCKMODE lockmode)
static void	ATExecReplicaIdentity (Relation rel, ReplicaIdentityStmt *stmt, LOCKMODE lockmode)
static void	ATExecGenericOptions (Relation rel, List *options)
static void	ATExecEnableRowSecurity (Relation rel)
static void	ATExecDisableRowSecurity (Relation rel)
static void	ATExecForceNoForceRowSecurity (Relation rel, bool force_rls)
static void	index_copy_data (Relation rel, RelFileNode newrnode)
static const char *	storage_name (char c)
static void	RangeVarCallbackForDropRelation (const RangeVar *rel, Oid relOid, Oid oldRelOid, void *arg)
static void	RangeVarCallbackForAlterRelation (const RangeVar *rv, Oid relid, Oid oldrelid, void *arg)
static PartitionSpec *	transformPartitionSpec (Relation rel, PartitionSpec *partspec, char *strategy)
static void	ComputePartitionAttrs (ParseState *pstate, Relation rel, List *partParams, AttrNumber *partattrs, List **partexprs, Oid *partopclass, Oid *partcollation, char strategy)
static void	CreateInheritance (Relation child_rel, Relation parent_rel)
static void	RemoveInheritance (Relation child_rel, Relation parent_rel)
static ObjectAddress	ATExecAttachPartition (List **wqueue, Relation rel, PartitionCmd *cmd)
static void	AttachPartitionEnsureIndexes (Relation rel, Relation attachrel)
static void	QueuePartitionConstraintValidation (List **wqueue, Relation scanrel, List *partConstraint, bool validate_default)
static void	CloneRowTriggersToPartition (Relation parent, Relation partition)
static void	DropClonedTriggersFromPartition (Oid partitionId)
static ObjectAddress	ATExecDetachPartition (Relation rel, RangeVar *name)
static ObjectAddress	ATExecAttachPartitionIdx (List **wqueue, Relation rel, RangeVar *name)
static void	validatePartitionedIndex (Relation partedIdx, Relation partedTbl)
static void	refuseDupeIndexAttach (Relation parentIdx, Relation partIdx, Relation partitionTbl)
static List *	GetParentedForeignKeyRefs (Relation partition)
static void	ATDetachCheckNoForeignKeyRefs (Relation partition)
ObjectAddress	DefineRelation (CreateStmt *stmt, char relkind, Oid ownerId, ObjectAddress *typaddress, const char *queryString)
static void	DropErrorMsgNonExistent (RangeVar *rel, char rightkind, bool missing_ok)
static void	DropErrorMsgWrongType (const char *relname, char wrongkind, char rightkind)
void	RemoveRelations (DropStmt *drop)
void	ExecuteTruncate (TruncateStmt *stmt)
void	ExecuteTruncateGuts (List *explicit_rels, List *relids, List *relids_logged, DropBehavior behavior, bool restart_seqs)
void	SetRelationHasSubclass (Oid relationId, bool relhassubclass)
static void	renameatt_check (Oid myrelid, Form_pg_class classform, bool recursing)
static AttrNumber	renameatt_internal (Oid myrelid, const char *oldattname, const char *newattname, bool recurse, bool recursing, int expected_parents, DropBehavior behavior)
static void	RangeVarCallbackForRenameAttribute (const RangeVar *rv, Oid relid, Oid oldrelid, void *arg)
ObjectAddress	renameatt (RenameStmt *stmt)
static ObjectAddress	rename_constraint_internal (Oid myrelid, Oid mytypid, const char *oldconname, const char *newconname, bool recurse, bool recursing, int expected_parents)
ObjectAddress	RenameConstraint (RenameStmt *stmt)
ObjectAddress	RenameRelation (RenameStmt *stmt)
void	RenameRelationInternal (Oid myrelid, const char *newrelname, bool is_internal, bool is_index)
void	CheckTableNotInUse (Relation rel, const char *stmt)
Oid	AlterTableLookupRelation (AlterTableStmt *stmt, LOCKMODE lockmode)
void	AlterTable (AlterTableStmt *stmt, LOCKMODE lockmode, AlterTableUtilityContext *context)
void	AlterTableInternal (Oid relid, List *cmds, bool recurse)
LOCKMODE	AlterTableGetLockLevel (List *cmds)
void	find_composite_type_dependencies (Oid typeOid, Relation origRelation, const char *origTypeName)
void	check_of_type (HeapTuple typetuple)
static void	CreateFKCheckTrigger (Oid myRelOid, Oid refRelOid, Constraint *fkconstraint, Oid constraintOid, Oid indexOid, bool on_insert)
static void	RememberReplicaIdentityForRebuilding (Oid indoid, AlteredTableInfo *tab)
static void	RememberClusterOnForRebuilding (Oid indoid, AlteredTableInfo *tab)
void	ATExecChangeOwner (Oid relationOid, Oid newOwnerId, bool recursing, LOCKMODE lockmode)
Oid	AlterTableMoveAll (AlterTableMoveAllStmt *stmt)
static char *	decompile_conbin (HeapTuple contup, TupleDesc tupdesc)
static bool	constraints_equivalent (HeapTuple a, HeapTuple b, TupleDesc tupleDesc)
static void	relation_mark_replica_identity (Relation rel, char ri_type, Oid indexOid, bool is_internal)
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	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 *arg)
bool	PartConstraintImpliedByRelConstraint (Relation scanrel, List *partConstraint)
static void	RangeVarCallbackForAttachIndex (const RangeVar *rv, Oid relOid, Oid oldRelOid, void *arg)

Variables
static List *	on_commits = NIL
static const struct dropmsgstrings	dropmsgstringarray []

Macro Definition Documentation

AT_NUM_PASSES

#define AT_NUM_PASSES   11

Definition at line 152 of file tablecmds.c.

Referenced by ATRewriteCatalogs().

AT_PASS_ADD_COL

#define AT_PASS_ADD_COL   4 /* ADD COLUMN */

Definition at line 145 of file tablecmds.c.

Referenced by ATPrepCmd().

AT_PASS_ADD_CONSTR

#define AT_PASS_ADD_CONSTR   5 /* ADD constraints (initial examination) */

Definition at line 146 of file tablecmds.c.

Referenced by ATPrepCmd().

AT_PASS_ADD_INDEX

#define AT_PASS_ADD_INDEX   8 /* ADD indexes */

Definition at line 149 of file tablecmds.c.

Referenced by ATParseTransformCmd(), and ATPrepCmd().

AT_PASS_ADD_INDEXCONSTR

#define AT_PASS_ADD_INDEXCONSTR   7 /* ADD index-based constraints */

Definition at line 148 of file tablecmds.c.

Referenced by ATParseTransformCmd(), and ATPrepCmd().

AT_PASS_ADD_OTHERCONSTR

#define AT_PASS_ADD_OTHERCONSTR   9 /* ADD other constraints, defaults */

Definition at line 150 of file tablecmds.c.

Referenced by ATParseTransformCmd(), and ATPrepCmd().

AT_PASS_ALTER_TYPE

#define AT_PASS_ALTER_TYPE   1 /* ALTER COLUMN TYPE */

Definition at line 141 of file tablecmds.c.

Referenced by ATPrepCmd(), and ATRewriteCatalogs().

AT_PASS_COL_ATTRS

#define AT_PASS_COL_ATTRS   6 /* set column attributes, eg NOT NULL */

Definition at line 147 of file tablecmds.c.

Referenced by ATParseTransformCmd(), and ATPrepCmd().

AT_PASS_DROP

#define AT_PASS_DROP   0 /* DROP (all flavors) */

Definition at line 140 of file tablecmds.c.

Referenced by ATPrepCmd().

AT_PASS_MISC

#define AT_PASS_MISC   10 /* other stuff */

Definition at line 151 of file tablecmds.c.

Referenced by ATParseTransformCmd(), and ATPrepCmd().

AT_PASS_OLD_CONSTR

#define AT_PASS_OLD_CONSTR   3 /* re-add existing constraints */

Definition at line 143 of file tablecmds.c.

Referenced by ATPostAlterTypeCleanup(), and ATPostAlterTypeParse().

AT_PASS_OLD_INDEX

#define AT_PASS_OLD_INDEX   2 /* re-add existing indexes */

Definition at line 142 of file tablecmds.c.

Referenced by ATPostAlterTypeParse().

AT_PASS_UNSET

#define AT_PASS_UNSET   -1 /* UNSET will cause ERROR */

Definition at line 139 of file tablecmds.c.

Referenced by ATParseTransformCmd(), and ATPrepCmd().

ATT_COMPOSITE_TYPE

#define ATT_COMPOSITE_TYPE   0x0010

Definition at line 296 of file tablecmds.c.

Referenced by ATPrepCmd(), ATSimplePermissions(), and ATWrongRelkindError().

ATT_FOREIGN_TABLE

#define ATT_FOREIGN_TABLE   0x0020

Definition at line 297 of file tablecmds.c.

Referenced by ATAddCheckConstraint(), ATExecAddColumn(), ATExecAddInherit(), ATExecAttachPartition(), ATExecDropColumn(), ATExecDropConstraint(), ATPrepCmd(), ATSimplePermissions(), and ATWrongRelkindError().

ATT_INDEX

#define ATT_INDEX   0x0008

Definition at line 295 of file tablecmds.c.

Referenced by ATPrepCmd(), ATSimplePermissions(), and ATWrongRelkindError().

ATT_MATVIEW

#define ATT_MATVIEW   0x0004

Definition at line 294 of file tablecmds.c.

Referenced by ATPrepCmd(), ATSimplePermissions(), and ATWrongRelkindError().

ATT_PARTITIONED_INDEX

#define ATT_PARTITIONED_INDEX   0x0040

Definition at line 298 of file tablecmds.c.

Referenced by ATPrepCmd(), and ATSimplePermissions().

ATT_TABLE

#define ATT_TABLE   0x0001

Definition at line 292 of file tablecmds.c.

Referenced by ATAddCheckConstraint(), ATExecAddColumn(), ATExecAddInherit(), ATExecAttachPartition(), ATExecDropColumn(), ATExecDropConstraint(), ATPrepCmd(), ATSimplePermissions(), and ATWrongRelkindError().

ATT_VIEW

#define ATT_VIEW   0x0002

Definition at line 293 of file tablecmds.c.

Referenced by ATPrepCmd(), ATSimplePermissions(), and ATWrongRelkindError().

child_dependency_type

#define child_dependency_type

(

child_is_partition

)

((child_is_partition) ? DEPENDENCY_AUTO : DEPENDENCY_NORMAL)

Definition at line 305 of file tablecmds.c.

Referenced by RemoveInheritance(), and StoreCatalogInheritance1().

Typedef Documentation

AlteredTableInfo

typedef struct AlteredTableInfo AlteredTableInfo

NewColumnValue

typedef struct NewColumnValue NewColumnValue

NewConstraint

typedef struct NewConstraint NewConstraint

OnCommitItem

typedef struct OnCommitItem OnCommitItem

Function Documentation

add_column_collation_dependency()

static void add_column_collation_dependency ( Oid  relid, int32  attnum, Oid  collid  )

static

Definition at line 6429 of file tablecmds.c.

References attnum, ObjectAddress::classId, DEPENDENCY_NORMAL, ObjectAddress::objectId, ObjectAddress::objectSubId, OidIsValid, recordDependencyOn(), and OnCommitItem::relid.

Referenced by ATExecAddColumn(), and ATExecAlterColumnType().

{
    ObjectAddress myself,
                referenced;

    /* We know the default collation is pinned, so don't bother recording it */
    if (OidIsValid(collid) && collid != DEFAULT_COLLATION_OID)
    {
        myself.classId = RelationRelationId;
        myself.objectId = relid;
        myself.objectSubId = attnum;
        referenced.classId = CollationRelationId;
        referenced.objectId = collid;
        referenced.objectSubId = 0;
        recordDependencyOn(&myself, &referenced, DEPENDENCY_NORMAL);
    }
}

add_column_datatype_dependency()

static void add_column_datatype_dependency ( Oid  relid, int32  attnum, Oid  typid  )

static

Definition at line 6411 of file tablecmds.c.

References attnum, ObjectAddress::classId, DEPENDENCY_NORMAL, ObjectAddress::objectId, ObjectAddress::objectSubId, recordDependencyOn(), and OnCommitItem::relid.

Referenced by ATExecAddColumn(), and ATExecAlterColumnType().

{
    ObjectAddress myself,
                referenced;

    myself.classId = RelationRelationId;
    myself.objectId = relid;
    myself.objectSubId = attnum;
    referenced.classId = TypeRelationId;
    referenced.objectId = typid;
    referenced.objectSubId = 0;
    recordDependencyOn(&myself, &referenced, DEPENDENCY_NORMAL);
}

addFkRecurseReferenced()

static ObjectAddress addFkRecurseReferenced ( List **  wqueue, Constraint *  fkconstraint, Relation  rel, Relation  pkrel, Oid  indexOid, Oid  parentConstr, int  numfks, int16 *  pkattnum, int16 *  fkattnum, Oid *  pfeqoperators, Oid *  ppeqoperators, Oid *  ffeqoperators, bool  old_check_ok  )

static

Definition at line 8626 of file tablecmds.c.

References AttrMap::attnums, build_attrmap_by_name_if_req(), ChooseConstraintName(), ChooseForeignKeyConstraintNameAddition(), CommandCounterIncrement(), Constraint::conname, CONSTRAINT_RELATION, ConstraintNameIsUsed(), CreateConstraintEntry(), createForeignKeyActionTriggers(), Constraint::deferrable, DEPENDENCY_INTERNAL, elog, ereport, errcode(), errmsg(), ERROR, Constraint::fk_attrs, Constraint::fk_del_action, Constraint::fk_matchtype, Constraint::fk_upd_action, free_attrmap(), i, index_get_partition(), Constraint::initdeferred, Constraint::initially_valid, InvalidOid, NIL, NoLock, PartitionDescData::nparts, ObjectAddressSet, OidIsValid, PartitionDescData::oids, palloc(), pfree(), RelationData::rd_rel, recordDependencyOn(), RelationGetDescr, RelationGetNamespace, RelationGetPartitionDesc(), RelationGetRelationName, RelationGetRelid, ShareRowExclusiveLock, table_close(), and table_open().

Referenced by ATAddForeignKeyConstraint(), and CloneFkReferenced().

{
    ObjectAddress address;
    Oid         constrOid;
    char       *conname;
    bool        conislocal;
    int         coninhcount;
    bool        connoinherit;

    /*
     * Verify relkind for each referenced partition.  At the top level, this
     * is redundant with a previous check, but we need it when recursing.
     */
    if (pkrel->rd_rel->relkind != RELKIND_RELATION &&
        pkrel->rd_rel->relkind != RELKIND_PARTITIONED_TABLE)
        ereport(ERROR,
                (errcode(ERRCODE_WRONG_OBJECT_TYPE),
                 errmsg("referenced relation \"%s\" is not a table",
                        RelationGetRelationName(pkrel))));

    /*
     * Caller supplies us with a constraint name; however, it may be used in
     * this partition, so come up with a different one in that case.
     */
    if (ConstraintNameIsUsed(CONSTRAINT_RELATION,
                             RelationGetRelid(rel),
                             fkconstraint->conname))
        conname = ChooseConstraintName(RelationGetRelationName(rel),
                                       ChooseForeignKeyConstraintNameAddition(fkconstraint->fk_attrs),
                                       "fkey",
                                       RelationGetNamespace(rel), NIL);
    else
        conname = fkconstraint->conname;

    if (OidIsValid(parentConstr))
    {
        conislocal = false;
        coninhcount = 1;
        connoinherit = false;
    }
    else
    {
        conislocal = true;
        coninhcount = 0;

        /*
         * always inherit for partitioned tables, never for legacy inheritance
         */
        connoinherit = rel->rd_rel->relkind != RELKIND_PARTITIONED_TABLE;
    }

    /*
     * Record the FK constraint in pg_constraint.
     */
    constrOid = CreateConstraintEntry(conname,
                                      RelationGetNamespace(rel),
                                      CONSTRAINT_FOREIGN,
                                      fkconstraint->deferrable,
                                      fkconstraint->initdeferred,
                                      fkconstraint->initially_valid,
                                      parentConstr,
                                      RelationGetRelid(rel),
                                      fkattnum,
                                      numfks,
                                      numfks,
                                      InvalidOid,   /* not a domain constraint */
                                      indexOid,
                                      RelationGetRelid(pkrel),
                                      pkattnum,
                                      pfeqoperators,
                                      ppeqoperators,
                                      ffeqoperators,
                                      numfks,
                                      fkconstraint->fk_upd_action,
                                      fkconstraint->fk_del_action,
                                      fkconstraint->fk_matchtype,
                                      NULL, /* no exclusion constraint */
                                      NULL, /* no check constraint */
                                      NULL,
                                      conislocal,   /* islocal */
                                      coninhcount,  /* inhcount */
                                      connoinherit, /* conNoInherit */
                                      false);   /* is_internal */

    ObjectAddressSet(address, ConstraintRelationId, constrOid);

    /*
     * Mark the child constraint as part of the parent constraint; it must not
     * be dropped on its own.  (This constraint is deleted when the partition
     * is detached, but a special check needs to occur that the partition
     * contains no referenced values.)
     */
    if (OidIsValid(parentConstr))
    {
        ObjectAddress referenced;

        ObjectAddressSet(referenced, ConstraintRelationId, parentConstr);
        recordDependencyOn(&address, &referenced, DEPENDENCY_INTERNAL);
    }

    /* make new constraint visible, in case we add more */
    CommandCounterIncrement();

    /*
     * If the referenced table is a plain relation, create the action triggers
     * that enforce the constraint.
     */
    if (pkrel->rd_rel->relkind == RELKIND_RELATION)
    {
        createForeignKeyActionTriggers(rel, RelationGetRelid(pkrel),
                                       fkconstraint,
                                       constrOid, indexOid);
    }

    /*
     * If the referenced table is partitioned, recurse on ourselves to handle
     * each partition.  We need one pg_constraint row created for each
     * partition in addition to the pg_constraint row for the parent table.
     */
    if (pkrel->rd_rel->relkind == RELKIND_PARTITIONED_TABLE)
    {
        PartitionDesc pd = RelationGetPartitionDesc(pkrel);

        for (int i = 0; i < pd->nparts; i++)
        {
            Relation    partRel;
            AttrMap    *map;
            AttrNumber *mapped_pkattnum;
            Oid         partIndexId;

            partRel = table_open(pd->oids[i], ShareRowExclusiveLock);

            /*
             * Map the attribute numbers in the referenced side of the FK
             * definition to match the partition's column layout.
             */
            map = build_attrmap_by_name_if_req(RelationGetDescr(partRel),
                                               RelationGetDescr(pkrel));
            if (map)
            {
                mapped_pkattnum = palloc(sizeof(AttrNumber) * numfks);
                for (int j = 0; j < numfks; j++)
                    mapped_pkattnum[j] = map->attnums[pkattnum[j] - 1];
            }
            else
                mapped_pkattnum = pkattnum;

            /* do the deed */
            partIndexId = index_get_partition(partRel, indexOid);
            if (!OidIsValid(partIndexId))
                elog(ERROR, "index for %u not found in partition %s",
                     indexOid, RelationGetRelationName(partRel));
            addFkRecurseReferenced(wqueue, fkconstraint, rel, partRel,
                                   partIndexId, constrOid, numfks,
                                   mapped_pkattnum, fkattnum,
                                   pfeqoperators, ppeqoperators, ffeqoperators,
                                   old_check_ok);

            /* Done -- clean up (but keep the lock) */
            table_close(partRel, NoLock);
            if (map)
            {
                pfree(mapped_pkattnum);
                free_attrmap(map);
            }
        }
    }

    return address;
}

addFkRecurseReferencing()

static void addFkRecurseReferencing ( List **  wqueue, Constraint *  fkconstraint, Relation  rel, Relation  pkrel, Oid  indexOid, Oid  parentConstr, int  numfks, int16 *  pkattnum, int16 *  fkattnum, Oid *  pfeqoperators, Oid *  ppeqoperators, Oid *  ffeqoperators, bool  old_check_ok, LOCKMODE  lockmode  )

static

Definition at line 8831 of file tablecmds.c.

References AssertArg, ATGetQueueEntry(), AttrMap::attnums, build_attrmap_by_name(), CheckTableNotInUse(), ChooseConstraintName(), ChooseForeignKeyConstraintNameAddition(), CommandCounterIncrement(), NewConstraint::conid, Constraint::conname, CONSTR_FOREIGN, CONSTRAINT_RELATION, ConstraintNameIsUsed(), AlteredTableInfo::constraints, NewConstraint::contype, copyObject, CreateConstraintEntry(), createForeignKeyCheckTriggers(), Constraint::deferrable, DEPENDENCY_PARTITION_PRI, DEPENDENCY_PARTITION_SEC, ereport, errcode(), errmsg(), ERROR, Constraint::fk_attrs, Constraint::fk_del_action, Constraint::fk_matchtype, Constraint::fk_upd_action, get_constraint_name(), i, INDEX_MAX_KEYS, Constraint::initdeferred, Constraint::initially_valid, InvalidOid, lappend(), lfirst_node, NewConstraint::name, NIL, NoLock, PartitionDescData::nparts, ObjectAddressSet, OidIsValid, PartitionDescData::oids, palloc0(), NewConstraint::qual, RelationData::rd_rel, recordDependencyOn(), NewConstraint::refindid, NewConstraint::refrelid, RelationGetDescr, RelationGetFKeyList(), RelationGetNamespace, RelationGetPartitionDesc(), RelationGetRelationName, RelationGetRelid, Constraint::skip_validation, table_close(), table_open(), and tryAttachPartitionForeignKey().

Referenced by ATAddForeignKeyConstraint(), and CloneFkReferencing().

{
    AssertArg(OidIsValid(parentConstr));

    if (rel->rd_rel->relkind == RELKIND_FOREIGN_TABLE)
        ereport(ERROR,
                (errcode(ERRCODE_WRONG_OBJECT_TYPE),
                 errmsg("foreign key constraints are not supported on foreign tables")));

    /*
     * If the referencing relation is a plain table, add the check triggers to
     * it and, if necessary, schedule it to be checked in Phase 3.
     *
     * If the relation is partitioned, drill down to do it to its partitions.
     */
    if (rel->rd_rel->relkind == RELKIND_RELATION)
    {
        createForeignKeyCheckTriggers(RelationGetRelid(rel),
                                      RelationGetRelid(pkrel),
                                      fkconstraint,
                                      parentConstr,
                                      indexOid);

        /*
         * Tell Phase 3 to check that the constraint is satisfied by existing
         * rows. We can skip this during table creation, when requested
         * explicitly by specifying NOT VALID in an ADD FOREIGN KEY command,
         * and when we're recreating a constraint following a SET DATA TYPE
         * operation that did not impugn its validity.
         */
        if (wqueue && !old_check_ok && !fkconstraint->skip_validation)
        {
            NewConstraint *newcon;
            AlteredTableInfo *tab;

            tab = ATGetQueueEntry(wqueue, rel);

            newcon = (NewConstraint *) palloc0(sizeof(NewConstraint));
            newcon->name = get_constraint_name(parentConstr);
            newcon->contype = CONSTR_FOREIGN;
            newcon->refrelid = RelationGetRelid(pkrel);
            newcon->refindid = indexOid;
            newcon->conid = parentConstr;
            newcon->qual = (Node *) fkconstraint;

            tab->constraints = lappend(tab->constraints, newcon);
        }
    }
    else if (rel->rd_rel->relkind == RELKIND_PARTITIONED_TABLE)
    {
        PartitionDesc pd = RelationGetPartitionDesc(rel);

        /*
         * Recurse to take appropriate action on each partition; either we
         * find an existing constraint to reparent to ours, or we create a new
         * one.
         */
        for (int i = 0; i < pd->nparts; i++)
        {
            Oid         partitionId = pd->oids[i];
            Relation    partition = table_open(partitionId, lockmode);
            List       *partFKs;
            AttrMap    *attmap;
            AttrNumber  mapped_fkattnum[INDEX_MAX_KEYS];
            bool        attached;
            char       *conname;
            Oid         constrOid;
            ObjectAddress address,
                        referenced;
            ListCell   *cell;

            CheckTableNotInUse(partition, "ALTER TABLE");

            attmap = build_attrmap_by_name(RelationGetDescr(partition),
                                           RelationGetDescr(rel));
            for (int j = 0; j < numfks; j++)
                mapped_fkattnum[j] = attmap->attnums[fkattnum[j] - 1];

            /* Check whether an existing constraint can be repurposed */
            partFKs = copyObject(RelationGetFKeyList(partition));
            attached = false;
            foreach(cell, partFKs)
            {
                ForeignKeyCacheInfo *fk;

                fk = lfirst_node(ForeignKeyCacheInfo, cell);
                if (tryAttachPartitionForeignKey(fk,
                                                 partitionId,
                                                 parentConstr,
                                                 numfks,
                                                 mapped_fkattnum,
                                                 pkattnum,
                                                 pfeqoperators))
                {
                    attached = true;
                    break;
                }
            }
            if (attached)
            {
                table_close(partition, NoLock);
                continue;
            }

            /*
             * No luck finding a good constraint to reuse; create our own.
             */
            if (ConstraintNameIsUsed(CONSTRAINT_RELATION,
                                     RelationGetRelid(partition),
                                     fkconstraint->conname))
                conname = ChooseConstraintName(RelationGetRelationName(partition),
                                               ChooseForeignKeyConstraintNameAddition(fkconstraint->fk_attrs),
                                               "fkey",
                                               RelationGetNamespace(partition), NIL);
            else
                conname = fkconstraint->conname;
            constrOid =
                CreateConstraintEntry(conname,
                                      RelationGetNamespace(partition),
                                      CONSTRAINT_FOREIGN,
                                      fkconstraint->deferrable,
                                      fkconstraint->initdeferred,
                                      fkconstraint->initially_valid,
                                      parentConstr,
                                      partitionId,
                                      mapped_fkattnum,
                                      numfks,
                                      numfks,
                                      InvalidOid,
                                      indexOid,
                                      RelationGetRelid(pkrel),
                                      pkattnum,
                                      pfeqoperators,
                                      ppeqoperators,
                                      ffeqoperators,
                                      numfks,
                                      fkconstraint->fk_upd_action,
                                      fkconstraint->fk_del_action,
                                      fkconstraint->fk_matchtype,
                                      NULL,
                                      NULL,
                                      NULL,
                                      false,
                                      1,
                                      false,
                                      false);

            /*
             * Give this constraint partition-type dependencies on the parent
             * constraint as well as the table.
             */
            ObjectAddressSet(address, ConstraintRelationId, constrOid);
            ObjectAddressSet(referenced, ConstraintRelationId, parentConstr);
            recordDependencyOn(&address, &referenced, DEPENDENCY_PARTITION_PRI);
            ObjectAddressSet(referenced, RelationRelationId, partitionId);
            recordDependencyOn(&address, &referenced, DEPENDENCY_PARTITION_SEC);

            /* Make all this visible before recursing */
            CommandCounterIncrement();

            /* call ourselves to finalize the creation and we're done */
            addFkRecurseReferencing(wqueue, fkconstraint, partition, pkrel,
                                    indexOid,
                                    constrOid,
                                    numfks,
                                    pkattnum,
                                    mapped_fkattnum,
                                    pfeqoperators,
                                    ppeqoperators,
                                    ffeqoperators,
                                    old_check_ok,
                                    lockmode);

            table_close(partition, NoLock);
        }
    }
}

AlterIndexNamespaces()

static void AlterIndexNamespaces ( Relation  classRel, Relation  rel, Oid  oldNspOid, Oid  newNspOid, ObjectAddresses *  objsMoved  )

static

Definition at line 15107 of file tablecmds.c.

References add_exact_object_address(), AlterRelationNamespaceInternal(), ObjectAddress::classId, lfirst_oid, list_free(), object_address_present(), ObjectAddress::objectId, ObjectAddress::objectSubId, and RelationGetIndexList().

Referenced by AlterTableNamespaceInternal().

{
    List       *indexList;
    ListCell   *l;

    indexList = RelationGetIndexList(rel);

    foreach(l, indexList)
    {
        Oid         indexOid = lfirst_oid(l);
        ObjectAddress thisobj;

        thisobj.classId = RelationRelationId;
        thisobj.objectId = indexOid;
        thisobj.objectSubId = 0;

        /*
         * Note: currently, the index will not have its own dependency on the
         * namespace, so we don't need to do changeDependencyFor(). There's no
         * row type in pg_type, either.
         *
         * XXX this objsMoved test may be pointless -- surely we have a single
         * dependency link from a relation to each index?
         */
        if (!object_address_present(&thisobj, objsMoved))
        {
            AlterRelationNamespaceInternal(classRel, indexOid,
                                           oldNspOid, newNspOid,
                                           false, objsMoved);
            add_exact_object_address(&thisobj, objsMoved);
        }
    }

    list_free(indexList);
}

AlterRelationNamespaceInternal()

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

Definition at line 15037 of file tablecmds.c.

References add_exact_object_address(), Assert, CatalogTupleUpdate(), changeDependencyFor(), ObjectAddress::classId, elog, ereport, errcode(), errmsg(), ERROR, get_namespace_name(), get_relname_relid(), GETSTRUCT, heap_freetuple(), HeapTupleIsValid, InvalidOid, InvokeObjectPostAlterHook, NameStr, object_address_present(), ObjectAddress::objectId, ObjectIdGetDatum, ObjectAddress::objectSubId, RELOID, SearchSysCacheCopy1, 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;

        CatalogTupleUpdate(classRel, &classTup->t_self, 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);
}

AlterSeqNamespaces()

static void AlterSeqNamespaces ( Relation  classRel, Relation  rel, Oid  oldNspOid, Oid  newNspOid, ObjectAddresses *  objsMoved, LOCKMODE  lockmode  )

static

Definition at line 15152 of file tablecmds.c.

References AccessShareLock, AlterRelationNamespaceInternal(), Assert, BTEqualStrategyNumber, DEPENDENCY_AUTO, DEPENDENCY_INTERNAL, DependReferenceIndexId, GETSTRUCT, HeapTupleIsValid, InvalidOid, sort-test::key, NoLock, ObjectIdGetDatum, relation_close(), relation_open(), RelationGetForm, RelationGetRelid, DropRelationCallbackState::relkind, ScanKeyInit(), systable_beginscan(), systable_endscan(), systable_getnext(), and table_open().

Referenced by AlterTableNamespaceInternal().

{
    Relation    depRel;
    SysScanDesc scan;
    ScanKeyData key[2];
    HeapTuple   tup;

    /*
     * SERIAL sequences are those having an auto dependency on one of the
     * table's columns (we don't care *which* column, exactly).
     */
    depRel = table_open(DependRelationId, AccessShareLock);

    ScanKeyInit(&key[0],
                Anum_pg_depend_refclassid,
                BTEqualStrategyNumber, F_OIDEQ,
                ObjectIdGetDatum(RelationRelationId));
    ScanKeyInit(&key[1],
                Anum_pg_depend_refobjid,
                BTEqualStrategyNumber, F_OIDEQ,
                ObjectIdGetDatum(RelationGetRelid(rel)));
    /* we leave refobjsubid unspecified */

    scan = systable_beginscan(depRel, DependReferenceIndexId, true,
                              NULL, 2, key);

    while (HeapTupleIsValid(tup = systable_getnext(scan)))
    {
        Form_pg_depend depForm = (Form_pg_depend) GETSTRUCT(tup);
        Relation    seqRel;

        /* skip dependencies other than auto dependencies on columns */
        if (depForm->refobjsubid == 0 ||
            depForm->classid != RelationRelationId ||
            depForm->objsubid != 0 ||
            !(depForm->deptype == DEPENDENCY_AUTO || depForm->deptype == DEPENDENCY_INTERNAL))
            continue;

        /* Use relation_open just in case it's an index */
        seqRel = relation_open(depForm->objid, lockmode);

        /* skip non-sequence relations */
        if (RelationGetForm(seqRel)->relkind != RELKIND_SEQUENCE)
        {
            /* No need to keep the lock */
            relation_close(seqRel, lockmode);
            continue;
        }

        /* Fix the pg_class and pg_depend entries */
        AlterRelationNamespaceInternal(classRel, depForm->objid,
                                       oldNspOid, newNspOid,
                                       true, objsMoved);

        /*
         * Sequences used to have entries in pg_type, but no longer do.  If we
         * ever re-instate that, we'll need to move the pg_type entry to the
         * new namespace, too (using AlterTypeNamespaceInternal).
         */
        Assert(RelationGetForm(seqRel)->reltype == InvalidOid);

        /* Now we can close it.  Keep the lock till end of transaction. */
        relation_close(seqRel, NoLock);
    }

    systable_endscan(scan);

    relation_close(depRel, AccessShareLock);
}

AlterTable()

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

Definition at line 3617 of file tablecmds.c.

References ATController(), CheckTableNotInUse(), AlterTableStmt::cmds, RangeVar::inh, NoLock, AlterTableStmt::relation, relation_open(), and AlterTableUtilityContext::relid.

Referenced by ProcessUtilitySlow().

{
    Relation    rel;

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

    CheckTableNotInUse(rel, "ALTER TABLE");

    ATController(stmt, rel, stmt->cmds, stmt->relation->inh, lockmode, context);
}

AlterTableGetLockLevel()

LOCKMODE AlterTableGetLockLevel

(

List *

cmds

)

Definition at line 3691 of file tablecmds.c.

References AccessExclusiveLock, AccessShareLock, AlterTableGetRelOptionsLockLevel(), AT_AddColumn, AT_AddColumnToView, AT_AddConstraint, AT_AddConstraintRecurse, AT_AddIdentity, AT_AddIndex, AT_AddIndexConstraint, AT_AddInherit, AT_AddOf, AT_AlterColumnGenericOptions, AT_AlterColumnType, AT_AlterConstraint, AT_AttachPartition, AT_ChangeOwner, AT_CheckNotNull, AT_ClusterOn, AT_ColumnDefault, AT_DetachPartition, AT_DisableRowSecurity, AT_DisableRule, AT_DisableTrig, AT_DisableTrigAll, AT_DisableTrigUser, AT_DropCluster, AT_DropColumn, AT_DropConstraint, AT_DropExpression, AT_DropIdentity, AT_DropInherit, AT_DropNotNull, AT_DropOf, AT_DropOids, AT_EnableAlwaysRule, AT_EnableAlwaysTrig, AT_EnableReplicaRule, AT_EnableReplicaTrig, AT_EnableRowSecurity, AT_EnableRule, AT_EnableTrig, AT_EnableTrigAll, AT_EnableTrigUser, AT_ForceRowSecurity, AT_GenericOptions, AT_NoForceRowSecurity, AT_ReAddConstraint, AT_ReAddDomainConstraint, AT_ReplaceRelOptions, AT_ReplicaIdentity, AT_ResetOptions, AT_ResetRelOptions, AT_SetIdentity, 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 */
                cmd_lockmode = AccessExclusiveLock;
                break;

                /*
                 * These subcommands may require addition of toast tables. If
                 * we add a toast table to a table currently being scanned, we
                 * might miss data added to the new toast table by concurrent
                 * insert transactions.
                 */
            case AT_SetStorage: /* may add toast tables, see
                                 * ATRewriteCatalogs() */
                cmd_lockmode = AccessExclusiveLock;
                break;

                /*
                 * Removing constraints can affect SELECTs that have been
                 * optimized assuming the constraint holds true. See also
                 * CloneFkReferenced.
                 */
            case AT_DropConstraint: /* as DROP INDEX */
            case AT_DropNotNull:    /* may change some SQL plans */
                cmd_lockmode = AccessExclusiveLock;
                break;

                /*
                 * Subcommands that may be visible to concurrent SELECTs
                 */
            case AT_DropColumn: /* change visible to SELECT */
            case AT_AddColumnToView:    /* CREATE VIEW */
            case AT_DropOids:   /* used to equiv to DropColumn */
            case AT_EnableAlwaysRule:   /* may change SELECT rules */
            case AT_EnableReplicaRule:  /* may change SELECT rules */
            case AT_EnableRule: /* may change SELECT rules */
            case AT_DisableRule:    /* may change SELECT rules */
                cmd_lockmode = AccessExclusiveLock;
                break;

                /*
                 * Changing owner may remove implicit SELECT privileges
                 */
            case AT_ChangeOwner:    /* change visible to SELECT */
                cmd_lockmode = AccessExclusiveLock;
                break;

                /*
                 * Changing foreign table options may affect optimization.
                 */
            case AT_GenericOptions:
            case AT_AlterColumnGenericOptions:
                cmd_lockmode = AccessExclusiveLock;
                break;

                /*
                 * These subcommands affect write operations only.
                 */
            case AT_EnableTrig:
            case AT_EnableAlwaysTrig:
            case AT_EnableReplicaTrig:
            case AT_EnableTrigAll:
            case AT_EnableTrigUser:
            case AT_DisableTrig:
            case AT_DisableTrigAll:
            case AT_DisableTrigUser:
                cmd_lockmode = ShareRowExclusiveLock;
                break;

                /*
                 * These subcommands affect write operations only. XXX
                 * Theoretically, these could be ShareRowExclusiveLock.
                 */
            case AT_ColumnDefault:
            case AT_AlterConstraint:
            case AT_AddIndex:   /* from ADD CONSTRAINT */
            case AT_AddIndexConstraint:
            case AT_ReplicaIdentity:
            case AT_SetNotNull:
            case AT_EnableRowSecurity:
            case AT_DisableRowSecurity:
            case AT_ForceRowSecurity:
            case AT_NoForceRowSecurity:
            case AT_AddIdentity:
            case AT_DropIdentity:
            case AT_SetIdentity:
            case AT_DropExpression:
                cmd_lockmode = AccessExclusiveLock;
                break;

            case AT_AddConstraint:
            case AT_AddConstraintRecurse:   /* becomes AT_AddConstraint */
            case AT_ReAddConstraint:    /* becomes AT_AddConstraint */
            case AT_ReAddDomainConstraint:  /* becomes AT_AddConstraint */
                if (IsA(cmd->def, Constraint))
                {
                    Constraint *con = (Constraint *) cmd->def;

                    switch (con->contype)
                    {
                        case CONSTR_EXCLUSION:
                        case CONSTR_PRIMARY:
                        case CONSTR_UNIQUE:

                            /*
                             * Cases essentially the same as CREATE INDEX. We
                             * could reduce the lock strength to ShareLock if
                             * we can work out how to allow concurrent catalog
                             * updates. XXX Might be set down to
                             * ShareRowExclusiveLock but requires further
                             * analysis.
                             */
                            cmd_lockmode = AccessExclusiveLock;
                            break;
                        case CONSTR_FOREIGN:

                            /*
                             * We add triggers to both tables when we add a
                             * Foreign Key, so the lock level must be at least
                             * as strong as CREATE TRIGGER.
                             */
                            cmd_lockmode = ShareRowExclusiveLock;
                            break;

                        default:
                            cmd_lockmode = AccessExclusiveLock;
                    }
                }
                break;

                /*
                 * These subcommands affect inheritance behaviour. Queries
                 * started before us will continue to see the old inheritance
                 * behaviour, while queries started after we commit will see
                 * new behaviour. No need to prevent reads or writes to the
                 * subtable while we hook it up though. Changing the TupDesc
                 * may be a problem, so keep highest lock.
                 */
            case AT_AddInherit:
            case AT_DropInherit:
                cmd_lockmode = AccessExclusiveLock;
                break;

                /*
                 * These subcommands affect implicit row type conversion. They
                 * have affects similar to CREATE/DROP CAST on queries. don't
                 * provide for invalidating parse trees as a result of such
                 * changes, so we keep these at AccessExclusiveLock.
                 */
            case AT_AddOf:
            case AT_DropOf:
                cmd_lockmode = AccessExclusiveLock;
                break;

                /*
                 * Only used by CREATE OR REPLACE VIEW which must conflict
                 * with an SELECTs currently using the view.
                 */
            case AT_ReplaceRelOptions:
                cmd_lockmode = AccessExclusiveLock;
                break;

                /*
                 * These subcommands affect general strategies for performance
                 * and maintenance, though don't change the semantic results
                 * from normal data reads and writes. Delaying an ALTER TABLE
                 * behind currently active writes only delays the point where
                 * the new strategy begins to take effect, so there is no
                 * benefit in waiting. In this case the minimum restriction
                 * applies: we don't currently allow concurrent catalog
                 * updates.
                 */
            case AT_SetStatistics:  /* Uses MVCC in getTableAttrs() */
            case AT_ClusterOn:  /* Uses MVCC in getIndexes() */
            case AT_DropCluster:    /* Uses MVCC in getIndexes() */
            case AT_SetOptions: /* Uses MVCC in getTableAttrs() */
            case AT_ResetOptions:   /* Uses MVCC in getTableAttrs() */
                cmd_lockmode = ShareUpdateExclusiveLock;
                break;

            case AT_SetLogged:
            case AT_SetUnLogged:
                cmd_lockmode = AccessExclusiveLock;
                break;

            case AT_ValidateConstraint: /* Uses MVCC in getConstraints() */
                cmd_lockmode = ShareUpdateExclusiveLock;
                break;

                /*
                 * Rel options are more complex than first appears. Options
                 * are set here for tables, views and indexes; for historical
                 * reasons these can all be used with ALTER TABLE, so we can't
                 * decide between them using the basic grammar.
                 */
            case AT_SetRelOptions:  /* Uses MVCC in getIndexes() and
                                     * getTables() */
            case AT_ResetRelOptions:    /* Uses MVCC in getIndexes() and
                                         * getTables() */
                cmd_lockmode = AlterTableGetRelOptionsLockLevel((List *) cmd->def);
                break;

            case AT_AttachPartition:
                cmd_lockmode = ShareUpdateExclusiveLock;
                break;

            case AT_DetachPartition:
                cmd_lockmode = AccessExclusiveLock;
                break;

            case AT_CheckNotNull:

                /*
                 * This only examines the table's schema; but lock must be
                 * strong enough to prevent concurrent DROP NOT NULL.
                 */
                cmd_lockmode = AccessShareLock;
                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;
}

AlterTableInternal()

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

Definition at line 3646 of file tablecmds.c.

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

Referenced by AlterTableMoveAll(), and DefineVirtualRelation().

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

    rel = relation_open(relid, lockmode);

    EventTriggerAlterTableRelid(relid);

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

AlterTableLookupRelation()

Oid AlterTableLookupRelation	(	AlterTableStmt *	stmt,
		LOCKMODE	lockmode
	)

Definition at line 3561 of file tablecmds.c.

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

Referenced by ProcessUtilitySlow().

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

AlterTableMoveAll()

Oid AlterTableMoveAll

(

AlterTableMoveAllStmt *

stmt

)

Definition at line 13231 of file tablecmds.c.

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

Referenced by ProcessUtilitySlow().

{
    List       *relations = NIL;
    ListCell   *l;
    ScanKeyData key[1];
    Relation    rel;
    TableScanDesc scan;
    HeapTuple   tuple;
    Oid         orig_tablespaceoid;
    Oid         new_tablespaceoid;
    List       *role_oids = roleSpecsToIds(stmt->roles);

    /* Ensure we were not asked to move something we can't */
    if (stmt->objtype != OBJECT_TABLE && stmt->objtype != OBJECT_INDEX &&
        stmt->objtype != OBJECT_MATVIEW)
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                 errmsg("only tables, indexes, and materialized views exist in tablespaces")));

    /* Get the orig and new tablespace OIDs */
    orig_tablespaceoid = get_tablespace_oid(stmt->orig_tablespacename, false);
    new_tablespaceoid = get_tablespace_oid(stmt->new_tablespacename, false);

    /* Can't move shared relations in to or out of pg_global */
    /* This is also checked by ATExecSetTableSpace, but nice to stop earlier */
    if (orig_tablespaceoid == GLOBALTABLESPACE_OID ||
        new_tablespaceoid == GLOBALTABLESPACE_OID)
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                 errmsg("cannot move relations in to or out of pg_global tablespace")));

    /*
     * Must have CREATE rights on the new tablespace, unless it is the
     * database default tablespace (which all users implicitly have CREATE
     * rights on).
     */
    if (OidIsValid(new_tablespaceoid) && new_tablespaceoid != MyDatabaseTableSpace)
    {
        AclResult   aclresult;

        aclresult = pg_tablespace_aclcheck(new_tablespaceoid, GetUserId(),
                                           ACL_CREATE);
        if (aclresult != ACLCHECK_OK)
            aclcheck_error(aclresult, OBJECT_TABLESPACE,
                           get_tablespace_name(new_tablespaceoid));
    }

    /*
     * Now that the checks are done, check if we should set either to
     * InvalidOid because it is our database's default tablespace.
     */
    if (orig_tablespaceoid == MyDatabaseTableSpace)
        orig_tablespaceoid = InvalidOid;

    if (new_tablespaceoid == MyDatabaseTableSpace)
        new_tablespaceoid = InvalidOid;

    /* no-op */
    if (orig_tablespaceoid == new_tablespaceoid)
        return new_tablespaceoid;

    /*
     * Walk the list of objects in the tablespace and move them. This will
     * only find objects in our database, of course.
     */
    ScanKeyInit(&key[0],
                Anum_pg_class_reltablespace,
                BTEqualStrategyNumber, F_OIDEQ,
                ObjectIdGetDatum(orig_tablespaceoid));

    rel = table_open(RelationRelationId, AccessShareLock);
    scan = table_beginscan_catalog(rel, 1, key);
    while ((tuple = heap_getnext(scan, ForwardScanDirection)) != NULL)
    {
        Form_pg_class relForm = (Form_pg_class) GETSTRUCT(tuple);
        Oid         relOid = relForm->oid;

        /*
         * Do not move objects in pg_catalog as part of this, if an admin
         * really wishes to do so, they can issue the individual ALTER
         * commands directly.
         *
         * Also, explicitly avoid any shared tables, temp tables, or TOAST
         * (TOAST will be moved with the main table).
         */
        if (IsCatalogNamespace(relForm->relnamespace) ||
            relForm->relisshared ||
            isAnyTempNamespace(relForm->relnamespace) ||
            IsToastNamespace(relForm->relnamespace))
            continue;

        /* Only move the object type requested */
        if ((stmt->objtype == OBJECT_TABLE &&
             relForm->relkind != RELKIND_RELATION &&
             relForm->relkind != RELKIND_PARTITIONED_TABLE) ||
            (stmt->objtype == OBJECT_INDEX &&
             relForm->relkind != RELKIND_INDEX &&
             relForm->relkind != RELKIND_PARTITIONED_INDEX) ||
            (stmt->objtype == OBJECT_MATVIEW &&
             relForm->relkind != RELKIND_MATVIEW))
            continue;

        /* Check if we are only moving objects owned by certain roles */
        if (role_oids != NIL && !list_member_oid(role_oids, relForm->relowner))
            continue;

        /*
         * Handle permissions-checking here since we are locking the tables
         * and also to avoid doing a bunch of work only to fail part-way. Note
         * that permissions will also be checked by AlterTableInternal().
         *
         * Caller must be considered an owner on the table to move it.
         */
        if (!pg_class_ownercheck(relOid, GetUserId()))
            aclcheck_error(ACLCHECK_NOT_OWNER, get_relkind_objtype(get_rel_relkind(relOid)),
                           NameStr(relForm->relname));

        if (stmt->nowait &&
            !ConditionalLockRelationOid(relOid, AccessExclusiveLock))
            ereport(ERROR,
                    (errcode(ERRCODE_OBJECT_IN_USE),
                     errmsg("aborting because lock on relation \"%s.%s\" is not available",
                            get_namespace_name(relForm->relnamespace),
                            NameStr(relForm->relname))));
        else
            LockRelationOid(relOid, AccessExclusiveLock);

        /* Add to our list of objects to move */
        relations = lappend_oid(relations, relOid);
    }

    table_endscan(scan);
    table_close(rel, AccessShareLock);

    if (relations == NIL)
        ereport(NOTICE,
                (errcode(ERRCODE_NO_DATA_FOUND),
                 errmsg("no matching relations in tablespace \"%s\" found",
                        orig_tablespaceoid == InvalidOid ? "(database default)" :
                        get_tablespace_name(orig_tablespaceoid))));

    /* Everything is locked, loop through and move all of the relations. */
    foreach(l, relations)
    {
        List       *cmds = NIL;
        AlterTableCmd *cmd = makeNode(AlterTableCmd);

        cmd->subtype = AT_SetTableSpace;
        cmd->name = stmt->new_tablespacename;

        cmds = lappend(cmds, cmd);

        EventTriggerAlterTableStart((Node *) stmt);
        /* OID is set by AlterTableInternal */
        AlterTableInternal(lfirst_oid(l), cmds, false);
        EventTriggerAlterTableEnd();
    }

    return new_tablespaceoid;
}

AlterTableNamespace()

ObjectAddress AlterTableNamespace	(	AlterObjectSchemaStmt *	stmt,
		Oid *	oldschema
	)

Definition at line 14927 of file tablecmds.c.

References AccessExclusiveLock, AlterTableNamespaceInternal(), CheckSetNamespace(), DEPENDENCY_AUTO, DEPENDENCY_INTERNAL, ereport, errcode(), errdetail(), errmsg(), ERROR, free_object_addresses(), get_rel_name(), InvalidObjectAddress, makeRangeVar(), AlterObjectSchemaStmt::missing_ok, new_object_addresses(), NoLock, NOTICE, ObjectAddressSet, OidIsValid, RangeVarCallbackForAlterRelation(), RangeVarGetAndCheckCreationNamespace(), RangeVarGetRelidExtended(), RelationData::rd_rel, AlterObjectSchemaStmt::relation, relation_close(), relation_open(), RelationGetNamespace, RelationGetRelationName, OnCommitItem::relid, RVR_MISSING_OK, 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 ? RVR_MISSING_OK : 0,
                                     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, DEPENDENCY_AUTO, &tableId, &colId) ||
            sequenceIsOwned(relid, DEPENDENCY_INTERNAL, &tableId, &colId))
            ereport(ERROR,
                    (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                     errmsg("cannot move an owned sequence into another schema"),
                     errdetail("Sequence \"%s\" is linked to table \"%s\".",
                               RelationGetRelationName(rel),
                               get_rel_name(tableId))));
    }

    /* Get and lock schema OID and check its permissions. */
    newrv = makeRangeVar(stmt->newschema, RelationGetRelationName(rel), -1);
    nspOid = RangeVarGetAndCheckCreationNamespace(newrv, NoLock, NULL);

    /* common checks on switching namespaces */
    CheckSetNamespace(oldNspOid, nspOid);

    objsMoved = new_object_addresses();
    AlterTableNamespaceInternal(rel, oldNspOid, nspOid, objsMoved);
    free_object_addresses(objsMoved);

    ObjectAddressSet(myself, RelationRelationId, relid);

    if (oldschema)
        *oldschema = oldNspOid;

    /* close rel, but keep lock until commit */
    relation_close(rel, NoLock);

    return myself;
}

AlterTableNamespaceInternal()

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

Definition at line 14998 of file tablecmds.c.

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

Referenced by AlterObjectNamespace_oid(), and AlterTableNamespace().

{
    Relation    classRel;

    Assert(objsMoved != NULL);

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

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

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

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

    table_close(classRel, RowExclusiveLock);
}

ATAddCheckConstraint()

static ObjectAddress ATAddCheckConstraint ( List **  wqueue, AlteredTableInfo *  tab, Relation  rel, Constraint *  constr, bool  recurse, bool  recursing, bool  is_readd, LOCKMODE  lockmode  )

static

Definition at line 8051 of file tablecmds.c.

References AddRelationNewConstraints(), Assert, ATGetQueueEntry(), ATSimplePermissions(), ATT_FOREIGN_TABLE, ATT_TABLE, CheckTableNotInUse(), CommandCounterIncrement(), Constraint::conname, CookedConstraint::conoid, AlteredTableInfo::constraints, CookedConstraint::contype, NewConstraint::contype, copyObject, ereport, errcode(), errmsg(), ERROR, CookedConstraint::expr, find_inheritance_children(), InvalidObjectAddress, Constraint::is_no_inherit, lappend(), lfirst, lfirst_oid, list_length(), list_make1, CookedConstraint::name, NewConstraint::name, NIL, NoLock, ObjectAddressSet, palloc0(), NewConstraint::qual, RelationGetRelid, CookedConstraint::skip_validation, table_close(), and table_open().

Referenced by ATExecAddConstraint().

{
    List       *newcons;
    ListCell   *lcon;
    List       *children;
    ListCell   *child;
    ObjectAddress address = InvalidObjectAddress;

    /* At top level, permission check was done in ATPrepCmd, else do it */
    if (recursing)
        ATSimplePermissions(rel, ATT_TABLE | ATT_FOREIGN_TABLE);

    /*
     * Call AddRelationNewConstraints to do the work, making sure it works on
     * a copy of the Constraint so transformExpr can't modify the original. It
     * returns a list of cooked constraints.
     *
     * If the constraint ends up getting merged with a pre-existing one, it's
     * omitted from the returned list, which is what we want: we do not need
     * to do any validation work.  That can only happen at child tables,
     * though, since we disallow merging at the top level.
     */
    newcons = AddRelationNewConstraints(rel, NIL,
                                        list_make1(copyObject(constr)),
                                        recursing | is_readd,   /* allow_merge */
                                        !recursing, /* is_local */
                                        is_readd,   /* is_internal */
                                        NULL);  /* queryString not available
                                                 * here */

    /* we don't expect more than one constraint here */
    Assert(list_length(newcons) <= 1);

    /* Add each to-be-validated constraint to Phase 3's queue */
    foreach(lcon, newcons)
    {
        CookedConstraint *ccon = (CookedConstraint *) lfirst(lcon);

        if (!ccon->skip_validation)
        {
            NewConstraint *newcon;

            newcon = (NewConstraint *) palloc0(sizeof(NewConstraint));
            newcon->name = ccon->name;
            newcon->contype = ccon->contype;
            newcon->qual = ccon->expr;

            tab->constraints = lappend(tab->constraints, newcon);
        }

        /* Save the actually assigned name if it was defaulted */
        if (constr->conname == NULL)
            constr->conname = ccon->name;

        ObjectAddressSet(address, ConstraintRelationId, ccon->conoid);
    }

    /* At this point we must have a locked-down name to use */
    Assert(constr->conname != NULL);

    /* Advance command counter in case same table is visited multiple times */
    CommandCounterIncrement();

    /*
     * If the constraint got merged with an existing constraint, we're done.
     * We mustn't recurse to child tables in this case, because they've
     * already got the constraint, and visiting them again would lead to an
     * incorrect value for coninhcount.
     */
    if (newcons == NIL)
        return address;

    /*
     * If adding a NO INHERIT constraint, no need to find our children.
     */
    if (constr->is_no_inherit)
        return address;

    /*
     * Propagate to children as appropriate.  Unlike most other ALTER
     * routines, we have to do this one level of recursion at a time; we can't
     * use find_all_inheritors to do it in one pass.
     */
    children = find_inheritance_children(RelationGetRelid(rel), lockmode);

    /*
     * Check if ONLY was specified with ALTER TABLE.  If so, allow the
     * constraint creation only if there are no children currently.  Error out
     * otherwise.
     */
    if (!recurse && children != NIL)
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_TABLE_DEFINITION),
                 errmsg("constraint must be added to child tables too")));

    foreach(child, children)
    {
        Oid         childrelid = lfirst_oid(child);
        Relation    childrel;
        AlteredTableInfo *childtab;

        /* find_inheritance_children already got lock */
        childrel = table_open(childrelid, NoLock);
        CheckTableNotInUse(childrel, "ALTER TABLE");

        /* Find or create work queue entry for this table */
        childtab = ATGetQueueEntry(wqueue, childrel);

        /* Recurse to child */
        ATAddCheckConstraint(wqueue, childtab, childrel,
                             constr, recurse, true, is_readd, lockmode);

        table_close(childrel, NoLock);
    }

    return address;
}

ATAddForeignKeyConstraint()

static ObjectAddress ATAddForeignKeyConstraint ( List **  wqueue, AlteredTableInfo *  tab, Relation  rel, Constraint *  fkconstraint, Oid  parentConstr, bool  recurse, bool  recursing, LOCKMODE  lockmode  )

static

Definition at line 8187 of file tablecmds.c.

References addFkRecurseReferenced(), addFkRecurseReferencing(), allowSystemTableMods, Assert, BTEqualStrategyNumber, can_coerce_type(), checkFkeyPermissions(), CLAOID, COERCION_IMPLICIT, Constraint::conname, elog, ereport, errcode(), errdetail(), errmsg(), ERROR, findFkeyCast(), Constraint::fk_attrs, Constraint::fk_del_action, Constraint::fk_upd_action, FKCONSTR_ACTION_CASCADE, FKCONSTR_ACTION_SETDEFAULT, FKCONSTR_ACTION_SETNULL, format_type_be(), get_opfamily_member(), getBaseType(), GETSTRUCT, HeapTupleIsValid, i, INDEX_MAX_KEYS, Constraint::initially_valid, InvalidOid, IsSystemRelation(), lfirst_oid, list_head(), list_length(), list_nth(), lnext(), MemSet, NIL, NoLock, ObjectAddress::objectId, ObjectIdGetDatum, OidIsValid, Constraint::old_conpfeqop, Constraint::old_pktable_oid, AlteredTableInfo::oldDesc, Constraint::pk_attrs, Constraint::pktable, RelationData::rd_islocaltemp, RelationData::rd_rel, RelationGetDescr, RelationGetRelationName, RelationGetRelid, ReleaseSysCache(), SearchSysCache1(), ShareRowExclusiveLock, Constraint::skip_validation, strVal, table_close(), table_open(), table_openrv(), transformColumnNameList(), transformFkeyCheckAttrs(), transformFkeyGetPrimaryKey(), and TupleDescAttr.

Referenced by ATExecAddConstraint().

{
    Relation    pkrel;
    int16       pkattnum[INDEX_MAX_KEYS];
    int16       fkattnum[INDEX_MAX_KEYS];
    Oid         pktypoid[INDEX_MAX_KEYS];
    Oid         fktypoid[INDEX_MAX_KEYS];
    Oid         opclasses[INDEX_MAX_KEYS];
    Oid         pfeqoperators[INDEX_MAX_KEYS];
    Oid         ppeqoperators[INDEX_MAX_KEYS];
    Oid         ffeqoperators[INDEX_MAX_KEYS];
    int         i;
    int         numfks,
                numpks;
    Oid         indexOid;
    bool        old_check_ok;
    ObjectAddress address;
    ListCell   *old_pfeqop_item = list_head(fkconstraint->old_conpfeqop);

    /*
     * Grab ShareRowExclusiveLock on the pk table, so that someone doesn't
     * delete rows out from under us.
     */
    if (OidIsValid(fkconstraint->old_pktable_oid))
        pkrel = table_open(fkconstraint->old_pktable_oid, ShareRowExclusiveLock);
    else
        pkrel = table_openrv(fkconstraint->pktable, ShareRowExclusiveLock);

    /*
     * Validity checks (permission checks wait till we have the column
     * numbers)
     */
    if (rel->rd_rel->relkind == RELKIND_PARTITIONED_TABLE)
    {
        if (!recurse)
            ereport(ERROR,
                    (errcode(ERRCODE_WRONG_OBJECT_TYPE),
                     errmsg("cannot use ONLY for foreign key on partitioned table \"%s\" referencing relation \"%s\"",
                            RelationGetRelationName(rel),
                            RelationGetRelationName(pkrel))));
        if (fkconstraint->skip_validation && !fkconstraint->initially_valid)
            ereport(ERROR,
                    (errcode(ERRCODE_WRONG_OBJECT_TYPE),
                     errmsg("cannot add NOT VALID foreign key on partitioned table \"%s\" referencing relation \"%s\"",
                            RelationGetRelationName(rel),
                            RelationGetRelationName(pkrel)),
                     errdetail("This feature is not yet supported on partitioned tables.")));
    }

    if (pkrel->rd_rel->relkind != RELKIND_RELATION &&
        pkrel->rd_rel->relkind != RELKIND_PARTITIONED_TABLE)
        ereport(ERROR,
                (errcode(ERRCODE_WRONG_OBJECT_TYPE),
                 errmsg("referenced relation \"%s\" is not a table",
                        RelationGetRelationName(pkrel))));

    if (!allowSystemTableMods && IsSystemRelation(pkrel))
        ereport(ERROR,
                (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
                 errmsg("permission denied: \"%s\" is a system catalog",
                        RelationGetRelationName(pkrel))));

    /*
     * References from permanent or unlogged tables to temp tables, and from
     * permanent tables to unlogged tables, are disallowed because the
     * referenced data can vanish out from under us.  References from temp
     * tables to any other table type are also disallowed, because other
     * backends might need to run the RI triggers on the perm table, but they
     * can't reliably see tuples in the local buffers of other backends.
     */
    switch (rel->rd_rel->relpersistence)
    {
        case RELPERSISTENCE_PERMANENT:
            if (pkrel->rd_rel->relpersistence != RELPERSISTENCE_PERMANENT)
                ereport(ERROR,
                        (errcode(ERRCODE_INVALID_TABLE_DEFINITION),
                         errmsg("constraints on permanent tables may reference only permanent tables")));
            break;
        case RELPERSISTENCE_UNLOGGED:
            if (pkrel->rd_rel->relpersistence != RELPERSISTENCE_PERMANENT
                && pkrel->rd_rel->relpersistence != RELPERSISTENCE_UNLOGGED)
                ereport(ERROR,
                        (errcode(ERRCODE_INVALID_TABLE_DEFINITION),
                         errmsg("constraints on unlogged tables may reference only permanent or unlogged tables")));
            break;
        case RELPERSISTENCE_TEMP:
            if (pkrel->rd_rel->relpersistence != RELPERSISTENCE_TEMP)
                ereport(ERROR,
                        (errcode(ERRCODE_INVALID_TABLE_DEFINITION),
                         errmsg("constraints on temporary tables may reference only temporary tables")));
            if (!pkrel->rd_islocaltemp || !rel->rd_islocaltemp)
                ereport(ERROR,
                        (errcode(ERRCODE_INVALID_TABLE_DEFINITION),
                         errmsg("constraints on temporary tables must involve temporary tables of this session")));
            break;
    }

    /*
     * Look up the referencing attributes to make sure they exist, and record
     * their attnums and type OIDs.
     */
    MemSet(pkattnum, 0, sizeof(pkattnum));
    MemSet(fkattnum, 0, sizeof(fkattnum));
    MemSet(pktypoid, 0, sizeof(pktypoid));
    MemSet(fktypoid, 0, sizeof(fktypoid));
    MemSet(opclasses, 0, sizeof(opclasses));
    MemSet(pfeqoperators, 0, sizeof(pfeqoperators));
    MemSet(ppeqoperators, 0, sizeof(ppeqoperators));
    MemSet(ffeqoperators, 0, sizeof(ffeqoperators));

    numfks = transformColumnNameList(RelationGetRelid(rel),
                                     fkconstraint->fk_attrs,
                                     fkattnum, fktypoid);

    /*
     * If the attribute list for the referenced table was omitted, lookup the
     * definition of the primary key and use it.  Otherwise, validate the
     * supplied attribute list.  In either case, discover the index OID and
     * index opclasses, and the attnums and type OIDs of the attributes.
     */
    if (fkconstraint->pk_attrs == NIL)
    {
        numpks = transformFkeyGetPrimaryKey(pkrel, &indexOid,
                                            &fkconstraint->pk_attrs,
                                            pkattnum, pktypoid,
                                            opclasses);
    }
    else
    {
        numpks = transformColumnNameList(RelationGetRelid(pkrel),
                                         fkconstraint->pk_attrs,
                                         pkattnum, pktypoid);
        /* Look for an index matching the column list */
        indexOid = transformFkeyCheckAttrs(pkrel, numpks, pkattnum,
                                           opclasses);
    }

    /*
     * Now we can check permissions.
     */
    checkFkeyPermissions(pkrel, pkattnum, numpks);

    /*
     * Check some things for generated columns.
     */
    for (i = 0; i < numfks; i++)
    {
        char        attgenerated = TupleDescAttr(RelationGetDescr(rel), fkattnum[i] - 1)->attgenerated;

        if (attgenerated)
        {
            /*
             * Check restrictions on UPDATE/DELETE actions, per SQL standard
             */
            if (fkconstraint->fk_upd_action == FKCONSTR_ACTION_SETNULL ||
                fkconstraint->fk_upd_action == FKCONSTR_ACTION_SETDEFAULT ||
                fkconstraint->fk_upd_action == FKCONSTR_ACTION_CASCADE)
                ereport(ERROR,
                        (errcode(ERRCODE_SYNTAX_ERROR),
                         errmsg("invalid %s action for foreign key constraint containing generated column",
                                "ON UPDATE")));
            if (fkconstraint->fk_del_action == FKCONSTR_ACTION_SETNULL ||
                fkconstraint->fk_del_action == FKCONSTR_ACTION_SETDEFAULT)
                ereport(ERROR,
                        (errcode(ERRCODE_SYNTAX_ERROR),
                         errmsg("invalid %s action for foreign key constraint containing generated column",
                                "ON DELETE")));
        }
    }

    /*
     * Look up the equality operators to use in the constraint.
     *
     * Note that we have to be careful about the difference between the actual
     * PK column type and the opclass' declared input type, which might be
     * only binary-compatible with it.  The declared opcintype is the right
     * thing to probe pg_amop with.
     */
    if (numfks != numpks)
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_FOREIGN_KEY),
                 errmsg("number of referencing and referenced columns for foreign key disagree")));

    /*
     * On the strength of a previous constraint, we might avoid scanning
     * tables to validate this one.  See below.
     */
    old_check_ok = (fkconstraint->old_conpfeqop != NIL);
    Assert(!old_check_ok || numfks == list_length(fkconstraint->old_conpfeqop));

    for (i = 0; i < numpks; i++)
    {
        Oid         pktype = pktypoid[i];
        Oid         fktype = fktypoid[i];
        Oid         fktyped;
        HeapTuple   cla_ht;
        Form_pg_opclass cla_tup;
        Oid         amid;
        Oid         opfamily;
        Oid         opcintype;
        Oid         pfeqop;
        Oid         ppeqop;
        Oid         ffeqop;
        int16       eqstrategy;
        Oid         pfeqop_right;

        /* We need several fields out of the pg_opclass entry */
        cla_ht = SearchSysCache1(CLAOID, ObjectIdGetDatum(opclasses[i]));
        if (!HeapTupleIsValid(cla_ht))
            elog(ERROR, "cache lookup failed for opclass %u", opclasses[i]);
        cla_tup = (Form_pg_opclass) GETSTRUCT(cla_ht);
        amid = cla_tup->opcmethod;
        opfamily = cla_tup->opcfamily;
        opcintype = cla_tup->opcintype;
        ReleaseSysCache(cla_ht);

        /*
         * Check it's a btree; currently this can never fail since no other
         * index AMs support unique indexes.  If we ever did have other types
         * of unique indexes, we'd need a way to determine which operator
         * strategy number is equality.  (Is it reasonable to insist that
         * every such index AM use btree's number for equality?)
         */
        if (amid != BTREE_AM_OID)
            elog(ERROR, "only b-tree indexes are supported for foreign keys");
        eqstrategy = BTEqualStrategyNumber;

        /*
         * There had better be a primary equality operator for the index.
         * We'll use it for PK = PK comparisons.
         */
        ppeqop = get_opfamily_member(opfamily, opcintype, opcintype,
                                     eqstrategy);

        if (!OidIsValid(ppeqop))
            elog(ERROR, "missing operator %d(%u,%u) in opfamily %u",
                 eqstrategy, opcintype, opcintype, opfamily);

        /*
         * Are there equality operators that take exactly the FK type? Assume
         * we should look through any domain here.
         */
        fktyped = getBaseType(fktype);

        pfeqop = get_opfamily_member(opfamily, opcintype, fktyped,
                                     eqstrategy);
        if (OidIsValid(pfeqop))
        {
            pfeqop_right = fktyped;
            ffeqop = get_opfamily_member(opfamily, fktyped, fktyped,
                                         eqstrategy);
        }
        else
        {
            /* keep compiler quiet */
            pfeqop_right = InvalidOid;
            ffeqop = InvalidOid;
        }

        if (!(OidIsValid(pfeqop) && OidIsValid(ffeqop)))
        {
            /*
             * Otherwise, look for an implicit cast from the FK type to the
             * opcintype, and if found, use the primary equality operator.
             * This is a bit tricky because opcintype might be a polymorphic
             * type such as ANYARRAY or ANYENUM; so what we have to test is
             * whether the two actual column types can be concurrently cast to
             * that type.  (Otherwise, we'd fail to reject combinations such
             * as int[] and point[].)
             */
            Oid         input_typeids[2];
            Oid         target_typeids[2];

            input_typeids[0] = pktype;
            input_typeids[1] = fktype;
            target_typeids[0] = opcintype;
            target_typeids[1] = opcintype;
            if (can_coerce_type(2, input_typeids, target_typeids,
                                COERCION_IMPLICIT))
            {
                pfeqop = ffeqop = ppeqop;
                pfeqop_right = opcintype;
            }
        }

        if (!(OidIsValid(pfeqop) && OidIsValid(ffeqop)))
            ereport(ERROR,
                    (errcode(ERRCODE_DATATYPE_MISMATCH),
                     errmsg("foreign key constraint \"%s\" cannot be implemented",
                            fkconstraint->conname),
                     errdetail("Key columns \"%s\" and \"%s\" "
                               "are of incompatible types: %s and %s.",
                               strVal(list_nth(fkconstraint->fk_attrs, i)),
                               strVal(list_nth(fkconstraint->pk_attrs, i)),
                               format_type_be(fktype),
                               format_type_be(pktype))));

        if (old_check_ok)
        {
            /*
             * When a pfeqop changes, revalidate the constraint.  We could
             * permit intra-opfamily changes, but that adds subtle complexity
             * without any concrete benefit for core types.  We need not
             * assess ppeqop or ffeqop, which RI_Initial_Check() does not use.
             */
            old_check_ok = (pfeqop == lfirst_oid(old_pfeqop_item));
            old_pfeqop_item = lnext(fkconstraint->old_conpfeqop,
                                    old_pfeqop_item);
        }
        if (old_check_ok)
        {
            Oid         old_fktype;
            Oid         new_fktype;
            CoercionPathType old_pathtype;
            CoercionPathType new_pathtype;
            Oid         old_castfunc;
            Oid         new_castfunc;
            Form_pg_attribute attr = TupleDescAttr(tab->oldDesc,
                                                   fkattnum[i] - 1);

            /*
             * Identify coercion pathways from each of the old and new FK-side
             * column types to the right (foreign) operand type of the pfeqop.
             * We may assume that pg_constraint.conkey is not changing.
             */
            old_fktype = attr->atttypid;
            new_fktype = fktype;
            old_pathtype = findFkeyCast(pfeqop_right, old_fktype,
                                        &old_castfunc);
            new_pathtype = findFkeyCast(pfeqop_right, new_fktype,
                                        &new_castfunc);

            /*
             * Upon a change to the cast from the FK column to its pfeqop
             * operand, revalidate the constraint.  For this evaluation, a
             * binary coercion cast is equivalent to no cast at all.  While
             * type implementors should design implicit casts with an eye
             * toward consistency of operations like equality, we cannot
             * assume here that they have done so.
             *
             * A function with a polymorphic argument could change behavior
             * arbitrarily in response to get_fn_expr_argtype().  Therefore,
             * when the cast destination is polymorphic, we only avoid
             * revalidation if the input type has not changed at all.  Given
             * just the core data types and operator classes, this requirement
             * prevents no would-be optimizations.
             *
             * If the cast converts from a base type to a domain thereon, then
             * that domain type must be the opcintype of the unique index.
             * Necessarily, the primary key column must then be of the domain
             * type.  Since the constraint was previously valid, all values on
             * the foreign side necessarily exist on the primary side and in
             * turn conform to the domain.  Consequently, we need not treat
             * domains specially here.
             *
             * Since we require that all collations share the same notion of
             * equality (which they do, because texteq reduces to bitwise
             * equality), we don't compare collation here.
             *
             * We need not directly consider the PK type.  It's necessarily
             * binary coercible to the opcintype of the unique index column,
             * and ri_triggers.c will only deal with PK datums in terms of
             * that opcintype.  Changing the opcintype also changes pfeqop.
             */
            old_check_ok = (new_pathtype == old_pathtype &&
                            new_castfunc == old_castfunc &&
                            (!IsPolymorphicType(pfeqop_right) ||
                             new_fktype == old_fktype));
        }

        pfeqoperators[i] = pfeqop;
        ppeqoperators[i] = ppeqop;
        ffeqoperators[i] = ffeqop;
    }

    /*
     * Create all the constraint and trigger objects, recursing to partitions
     * as necessary.  First handle the referenced side.
     */
    address = addFkRecurseReferenced(wqueue, fkconstraint, rel, pkrel,
                                     indexOid,
                                     InvalidOid,    /* no parent constraint */
                                     numfks,
                                     pkattnum,
                                     fkattnum,
                                     pfeqoperators,
                                     ppeqoperators,
                                     ffeqoperators,
                                     old_check_ok);

    /* Now handle the referencing side. */
    addFkRecurseReferencing(wqueue, fkconstraint, rel, pkrel,
                            indexOid,
                            address.objectId,
                            numfks,
                            pkattnum,
                            fkattnum,
                            pfeqoperators,
                            ppeqoperators,
                            ffeqoperators,
                            old_check_ok,
                            lockmode);

    /*
     * Done.  Close pk table, but keep lock until we've committed.
     */
    table_close(pkrel, NoLock);

    return address;
}

ATCheckPartitionsNotInUse()

static void ATCheckPartitionsNotInUse ( Relation  rel, LOCKMODE  lockmode  )

static

Definition at line 5643 of file tablecmds.c.

References CheckTableNotInUse(), find_all_inheritors(), for_each_cell, lfirst_oid, list_free(), list_second_cell(), NoLock, RelationData::rd_rel, RelationGetRelid, table_close(), and table_open().

Referenced by ATPrepCmd().

{
    if (rel->rd_rel->relkind == RELKIND_PARTITIONED_TABLE)
    {
        List       *inh;
        ListCell   *cell;

        inh = find_all_inheritors(RelationGetRelid(rel), lockmode, NULL);
        /* first element is the parent rel; must ignore it */
        for_each_cell(cell, inh, list_second_cell(inh))
        {
            Relation    childrel;

            /* find_all_inheritors already got lock */
            childrel = table_open(lfirst_oid(cell), NoLock);
            CheckTableNotInUse(childrel, "ALTER TABLE");
            table_close(childrel, NoLock);
        }
        list_free(inh);
    }
}

ATColumnChangeRequiresRewrite()

static bool ATColumnChangeRequiresRewrite ( Node *  expr, AttrNumber  varattno  )

static

Definition at line 11130 of file tablecmds.c.

References arg, CoerceToDomain::arg, FuncExpr::args, Assert, DomainHasConstraints(), FuncExpr::funcid, IsA, linitial, CoerceToDomain::resulttype, and TimestampTimestampTzRequiresRewrite().

Referenced by ATPrepAlterColumnType().

{
    Assert(expr != NULL);

    for (;;)
    {
        /* only one varno, so no need to check that */
        if (IsA(expr, Var) && ((Var *) expr)->varattno == varattno)
            return false;
        else if (IsA(expr, RelabelType))
            expr = (Node *) ((RelabelType *) expr)->arg;
        else if (IsA(expr, CoerceToDomain))
        {
            CoerceToDomain *d = (CoerceToDomain *) expr;

            if (DomainHasConstraints(d->resulttype))
                return true;
            expr = (Node *) d->arg;
        }
        else if (IsA(expr, FuncExpr))
        {
            FuncExpr   *f = (FuncExpr *) expr;

            switch (f->funcid)
            {
                case F_TIMESTAMPTZ_TIMESTAMP:
                case F_TIMESTAMP_TIMESTAMPTZ:
                    if (TimestampTimestampTzRequiresRewrite())
                        return true;
                    else
                        expr = linitial(f->args);
                    break;
                default:
                    return true;
            }
        }
        else
            return true;
    }
}

ATController()

static void ATController ( AlterTableStmt *  parsetree, Relation  rel, List *  cmds, bool  recurse, LOCKMODE  lockmode, AlterTableUtilityContext *  context  )

static

Definition at line 3952 of file tablecmds.c.

References ATPrepCmd(), ATRewriteCatalogs(), ATRewriteTables(), lfirst, NIL, NoLock, and relation_close().

Referenced by AlterTable(), and AlterTableInternal().

{
    List       *wqueue = NIL;
    ListCell   *lcmd;

    /* Phase 1: preliminary examination of commands, create work queue */
    foreach(lcmd, cmds)
    {
        AlterTableCmd *cmd = (AlterTableCmd *) lfirst(lcmd);

        ATPrepCmd(&wqueue, rel, cmd, recurse, false, lockmode, context);
    }

    /* Close the relation, but keep lock until commit */
    relation_close(rel, NoLock);

    /* Phase 2: update system catalogs */
    ATRewriteCatalogs(&wqueue, lockmode, context);

    /* Phase 3: scan/rewrite tables as needed, and run afterStmts */
    ATRewriteTables(parsetree, &wqueue, lockmode, context);
}

ATDetachCheckNoForeignKeyRefs()

static void ATDetachCheckNoForeignKeyRefs ( Relation  partition )

static

Definition at line 17435 of file tablecmds.c.

References Assert, CONSTROID, elog, ERROR, GetParentedForeignKeyRefs(), GETSTRUCT, HeapTupleIsValid, InvalidOid, lfirst_oid, MemSet, NameStr, NoLock, ObjectIdGetDatum, OidIsValid, RelationGetRelid, ReleaseSysCache(), RI_PartitionRemove_Check(), SearchSysCache1(), ShareLock, table_close(), table_open(), Trigger::tgconstraint, Trigger::tgconstrindid, Trigger::tgconstrrelid, Trigger::tgdeferrable, Trigger::tgenabled, Trigger::tginitdeferred, Trigger::tgisinternal, Trigger::tgname, Trigger::tgoid, and TRIGGER_FIRES_ON_ORIGIN.

Referenced by ATExecDetachPartition().

{
    List       *constraints;
    ListCell   *cell;

    constraints = GetParentedForeignKeyRefs(partition);

    foreach(cell, constraints)
    {
        Oid         constrOid = lfirst_oid(cell);
        HeapTuple   tuple;
        Form_pg_constraint constrForm;
        Relation    rel;
        Trigger     trig;

        tuple = SearchSysCache1(CONSTROID, ObjectIdGetDatum(constrOid));
        if (!HeapTupleIsValid(tuple))
            elog(ERROR, "cache lookup failed for constraint %u", constrOid);
        constrForm = (Form_pg_constraint) GETSTRUCT(tuple);

        Assert(OidIsValid(constrForm->conparentid));
        Assert(constrForm->confrelid == RelationGetRelid(partition));

        /* prevent data changes into the referencing table until commit */
        rel = table_open(constrForm->conrelid, ShareLock);

        MemSet(&trig, 0, sizeof(trig));
        trig.tgoid = InvalidOid;
        trig.tgname = NameStr(constrForm->conname);
        trig.tgenabled = TRIGGER_FIRES_ON_ORIGIN;
        trig.tgisinternal = true;
        trig.tgconstrrelid = RelationGetRelid(partition);
        trig.tgconstrindid = constrForm->conindid;
        trig.tgconstraint = constrForm->oid;
        trig.tgdeferrable = false;
        trig.tginitdeferred = false;
        /* we needn't fill in remaining fields */

        RI_PartitionRemove_Check(&trig, rel, partition);

        ReleaseSysCache(tuple);

        table_close(rel, NoLock);
    }
}

AtEOSubXact_on_commit_actions()

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

Definition at line 15428 of file tablecmds.c.

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

Referenced by AbortSubTransaction(), and CommitSubTransaction().

{
    ListCell   *cur_item;

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

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

AtEOXact_on_commit_actions()

void AtEOXact_on_commit_actions

(

bool

isCommit

)

Definition at line 15396 of file tablecmds.c.

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

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

{
    ListCell   *cur_item;

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

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

ATExecAddColumn()

static ObjectAddress ATExecAddColumn ( List **  wqueue, AlteredTableInfo *  tab, Relation  rel, AlterTableCmd **  cmd, bool  recurse, bool  recursing, LOCKMODE  lockmode, int  cur_pass, AlterTableUtilityContext *  context  )

static

Definition at line 5952 of file tablecmds.c.

References ACL_USAGE, aclcheck_error_type(), ACLCHECK_OK, add_column_collation_dependency(), add_column_datatype_dependency(), AddRelationNewConstraints(), TypeName::arrayBounds, Assert, AT_REWRITE_DEFAULT_VAL, ATGetQueueEntry(), ATParseTransformCmd(), ATSimplePermissions(), ATT_FOREIGN_TABLE, ATT_TABLE, RawColumnDefault::attnum, NewColumnValue::attnum, build_column_default(), castNode, CatalogTupleUpdate(), check_for_column_name_collision(), CheckAttributeType(), CheckTableNotInUse(), COERCE_IMPLICIT_CAST, coerce_to_target_type(), COERCION_ASSIGNMENT, ColumnDef::colname, CommandCounterIncrement(), copyObject, AlterTableCmd::def, DomainHasConstraints(), elog, ereport, errcode(), errdetail(), errmsg(), ERROR, NewColumnValue::expr, expression_planner(), find_inheritance_children(), FormData_pg_attribute, RawColumnDefault::generated, ColumnDef::generated, get_collation_name(), get_typcollation(), getBaseTypeAndTypmod(), GetColumnDefCollation(), GETSTRUCT, GetUserId(), heap_freetuple(), HeapTupleIsValid, ColumnDef::identity, ColumnDef::identitySequence, ColumnDef::inhcount, InsertPgAttributeTuple(), InvalidObjectAddress, InvokeObjectPostCreateHook, NewColumnValue::is_generated, ColumnDef::is_local, ColumnDef::is_not_null, lappend(), lfirst_oid, list_length(), list_make1, list_make1_oid, makeNode, makeNullConst(), MaxHeapAttributeNumber, RawColumnDefault::missingMode, namestrcpy(), newval, AlteredTableInfo::newvals, NIL, NoLock, NOTICE, ObjectAddressSubSet, ObjectIdGetDatum, palloc(), palloc0(), pg_type_aclcheck(), RangeVarGetRelid, RawColumnDefault::raw_default, ColumnDef::raw_default, RelationData::rd_att, RelationData::rd_rel, RelationGetRelationName, RelationGetRelid, ReleaseSysCache(), DropRelationCallbackState::relkind, RELOID, AlteredTableInfo::rewrite, RowExclusiveLock, SearchSysCacheCopy1, SearchSysCacheCopyAttName(), NextValueExpr::seqid, HeapTupleData::t_self, table_close(), table_open(), TupleDescAttr, NextValueExpr::typeId, ColumnDef::typeName, typenameType(), typenameTypeIdAndMod(), and AlteredTableInfo::verify_new_notnull.

Referenced by ATExecCmd().

{
    Oid         myrelid = RelationGetRelid(rel);
    ColumnDef  *colDef = castNode(ColumnDef, (*cmd)->def);
    bool        if_not_exists = (*cmd)->missing_ok;
    Relation    pgclass,
                attrdesc;
    HeapTuple   reltup;
    FormData_pg_attribute attribute;
    int         newattnum;
    char        relkind;
    HeapTuple   typeTuple;
    Oid         typeOid;
    int32       typmod;
    Oid         collOid;
    Form_pg_type tform;
    Expr       *defval;
    List       *children;
    ListCell   *child;
    AlterTableCmd *childcmd;
    AclResult   aclresult;
    ObjectAddress address;

    /* At top level, permission check was done in ATPrepCmd, else do it */
    if (recursing)
        ATSimplePermissions(rel, ATT_TABLE | ATT_FOREIGN_TABLE);

    if (rel->rd_rel->relispartition && !recursing)
        ereport(ERROR,
                (errcode(ERRCODE_WRONG_OBJECT_TYPE),
                 errmsg("cannot add column to a partition")));

    attrdesc = table_open(AttributeRelationId, RowExclusiveLock);

    /*
     * Are we adding the column to a recursion child?  If so, check whether to
     * merge with an existing definition for the column.  If we do merge, we
     * must not recurse.  Children will already have the column, and recursing
     * into them would mess up attinhcount.
     */
    if (colDef->inhcount > 0)
    {
        HeapTuple   tuple;

        /* Does child already have a column by this name? */
        tuple = SearchSysCacheCopyAttName(myrelid, colDef->colname);
        if (HeapTupleIsValid(tuple))
        {
            Form_pg_attribute childatt = (Form_pg_attribute) GETSTRUCT(tuple);
            Oid         ctypeId;
            int32       ctypmod;
            Oid         ccollid;

            /* Child column must match on type, typmod, and collation */
            typenameTypeIdAndMod(NULL, colDef->typeName, &ctypeId, &ctypmod);
            if (ctypeId != childatt->atttypid ||
                ctypmod != childatt->atttypmod)
                ereport(ERROR,
                        (errcode(ERRCODE_DATATYPE_MISMATCH),
                         errmsg("child table \"%s\" has different type for column \"%s\"",
                                RelationGetRelationName(rel), colDef->colname)));
            ccollid = GetColumnDefCollation(NULL, colDef, ctypeId);
            if (ccollid != childatt->attcollation)
                ereport(ERROR,
                        (errcode(ERRCODE_COLLATION_MISMATCH),
                         errmsg("child table \"%s\" has different collation for column \"%s\"",
                                RelationGetRelationName(rel), colDef->colname),
                         errdetail("\"%s\" versus \"%s\"",
                                   get_collation_name(ccollid),
                                   get_collation_name(childatt->attcollation))));

            /* Bump the existing child att's inhcount */
            childatt->attinhcount++;
            CatalogTupleUpdate(attrdesc, &tuple->t_self, tuple);

            heap_freetuple(tuple);

            /* Inform the user about the merge */
            ereport(NOTICE,
                    (errmsg("merging definition of column \"%s\" for child \"%s\"",
                            colDef->colname, RelationGetRelationName(rel))));

            table_close(attrdesc, RowExclusiveLock);
            return InvalidObjectAddress;
        }
    }

    /* skip if the name already exists and if_not_exists is true */
    if (!check_for_column_name_collision(rel, colDef->colname, if_not_exists))
    {
        table_close(attrdesc, RowExclusiveLock);
        return InvalidObjectAddress;
    }

    /*
     * Okay, we need to add the column, so go ahead and do parse
     * transformation.  This can result in queueing up, or even immediately
     * executing, subsidiary operations (such as creation of unique indexes);
     * so we mustn't do it until we have made the if_not_exists check.
     *
     * When recursing, the command was already transformed and we needn't do
     * so again.  Also, if context isn't given we can't transform.  (That
     * currently happens only for AT_AddColumnToView; we expect that view.c
     * passed us a ColumnDef that doesn't need work.)
     */
    if (context != NULL && !recursing)
    {
        *cmd = ATParseTransformCmd(wqueue, tab, rel, *cmd, recurse, lockmode,
                                   cur_pass, context);
        Assert(*cmd != NULL);
        colDef = castNode(ColumnDef, (*cmd)->def);
    }

    /*
     * Cannot add identity column if table has children, because identity does
     * not inherit.  (Adding column and identity separately will work.)
     */
    if (colDef->identity &&
        recurse &&
        find_inheritance_children(myrelid, NoLock) != NIL)
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_TABLE_DEFINITION),
                 errmsg("cannot recursively add identity column to table that has child tables")));

    pgclass = table_open(RelationRelationId, RowExclusiveLock);

    reltup = SearchSysCacheCopy1(RELOID, ObjectIdGetDatum(myrelid));
    if (!HeapTupleIsValid(reltup))
        elog(ERROR, "cache lookup failed for relation %u", myrelid);
    relkind = ((Form_pg_class) GETSTRUCT(reltup))->relkind;

    /* Determine the new attribute's number */
    newattnum = ((Form_pg_class) GETSTRUCT(reltup))->relnatts + 1;
    if (newattnum > MaxHeapAttributeNumber)
        ereport(ERROR,
                (errcode(ERRCODE_TOO_MANY_COLUMNS),
                 errmsg("tables can have at most %d columns",
                        MaxHeapAttributeNumber)));

    typeTuple = typenameType(NULL, colDef->typeName, &typmod);
    tform = (Form_pg_type) GETSTRUCT(typeTuple);
    typeOid = tform->oid;

    aclresult = pg_type_aclcheck(typeOid, GetUserId(), ACL_USAGE);
    if (aclresult != ACLCHECK_OK)
        aclcheck_error_type(aclresult, typeOid);

    collOid = GetColumnDefCollation(NULL, colDef, typeOid);

    /* make sure datatype is legal for a column */
    CheckAttributeType(colDef->colname, typeOid, collOid,
                       list_make1_oid(rel->rd_rel->reltype),
                       0);

    /* construct new attribute's pg_attribute entry */
    attribute.attrelid = myrelid;
    namestrcpy(&(attribute.attname), colDef->colname);
    attribute.atttypid = typeOid;
    attribute.attstattarget = (newattnum > 0) ? -1 : 0;
    attribute.attlen = tform->typlen;
    attribute.atttypmod = typmod;
    attribute.attnum = newattnum;
    attribute.attbyval = tform->typbyval;
    attribute.attndims = list_length(colDef->typeName->arrayBounds);
    attribute.attstorage = tform->typstorage;
    attribute.attalign = tform->typalign;
    attribute.attnotnull = colDef->is_not_null;
    attribute.atthasdef = false;
    attribute.atthasmissing = false;
    attribute.attidentity = colDef->identity;
    attribute.attgenerated = colDef->generated;
    attribute.attisdropped = false;
    attribute.attislocal = colDef->is_local;
    attribute.attinhcount = colDef->inhcount;
    attribute.attcollation = collOid;
    /* attribute.attacl is handled by InsertPgAttributeTuple */

    ReleaseSysCache(typeTuple);

    InsertPgAttributeTuple(attrdesc, &attribute, (Datum) 0, NULL);

    table_close(attrdesc, RowExclusiveLock);

    /*
     * Update pg_class tuple as appropriate
     */
    ((Form_pg_class) GETSTRUCT(reltup))->relnatts = newattnum;

    CatalogTupleUpdate(pgclass, &reltup->t_self, reltup);

    heap_freetuple(reltup);

    /* Post creation hook for new attribute */
    InvokeObjectPostCreateHook(RelationRelationId, myrelid, newattnum);

    table_close(pgclass, RowExclusiveLock);

    /* Make the attribute's catalog entry visible */
    CommandCounterIncrement();

    /*
     * Store the DEFAULT, if any, in the catalogs
     */
    if (colDef->raw_default)
    {
        RawColumnDefault *rawEnt;

        rawEnt = (RawColumnDefault *) palloc(sizeof(RawColumnDefault));
        rawEnt->attnum = attribute.attnum;
        rawEnt->raw_default = copyObject(colDef->raw_default);

        /*
         * Attempt to skip a complete table rewrite by storing the specified
         * DEFAULT value outside of the heap.  This may be disabled inside
         * AddRelationNewConstraints if the optimization cannot be applied.
         */
        rawEnt->missingMode = (!colDef->generated);

        rawEnt->generated = colDef->generated;

        /*
         * This function is intended for CREATE TABLE, so it processes a
         * _list_ of defaults, but we just do one.
         */
        AddRelationNewConstraints(rel, list_make1(rawEnt), NIL,
                                  false, true, false, NULL);

        /* Make the additional catalog changes visible */
        CommandCounterIncrement();

        /*
         * Did the request for a missing value work? If not we'll have to do a
         * rewrite
         */
        if (!rawEnt->missingMode)
            tab->rewrite |= AT_REWRITE_DEFAULT_VAL;
    }

    /*
     * Tell Phase 3 to fill in the default expression, if there is one.
     *
     * If there is no default, Phase 3 doesn't have to do anything, because
     * that effectively means that the default is NULL.  The heap tuple access
     * routines always check for attnum > # of attributes in tuple, and return
     * NULL if so, so without any modification of the tuple data we will get
     * the effect of NULL values in the new column.
     *
     * An exception occurs when the new column is of a domain type: the domain
     * might have a NOT NULL constraint, or a check constraint that indirectly
     * rejects nulls.  If there are any domain constraints then we construct
     * an explicit NULL default value that will be passed through
     * CoerceToDomain processing.  (This is a tad inefficient, since it causes
     * rewriting the table which we really don't have to do, but the present
     * design of domain processing doesn't offer any simple way of checking
     * the constraints more directly.)
     *
     * Note: we use build_column_default, and not just the cooked default
     * returned by AddRelationNewConstraints, so that the right thing happens
     * when a datatype's default applies.
     *
     * Note: it might seem that this should happen at the end of Phase 2, so
     * that the effects of subsequent subcommands can be taken into account.
     * It's intentional that we do it now, though.  The new column should be
     * filled according to what is said in the ADD COLUMN subcommand, so that
     * the effects are the same as if this subcommand had been run by itself
     * and the later subcommands had been issued in new ALTER TABLE commands.
     *
     * We can skip this entirely for relations without storage, since Phase 3
     * is certainly not going to touch them.  System attributes don't have
     * interesting defaults, either.
     */
    if (RELKIND_HAS_STORAGE(relkind) && attribute.attnum > 0)
    {
        /*
         * For an identity column, we can't use build_column_default(),
         * because the sequence ownership isn't set yet.  So do it manually.
         */
        if (colDef->identity)
        {
            NextValueExpr *nve = makeNode(NextValueExpr);

            nve->seqid = RangeVarGetRelid(colDef->identitySequence, NoLock, false);
            nve->typeId = typeOid;

            defval = (Expr *) nve;

            /* must do a rewrite for identity columns */
            tab->rewrite |= AT_REWRITE_DEFAULT_VAL;
        }
        else
            defval = (Expr *) build_column_default(rel, attribute.attnum);

        if (!defval && DomainHasConstraints(typeOid))
        {
            Oid         baseTypeId;
            int32       baseTypeMod;
            Oid         baseTypeColl;

            baseTypeMod = typmod;
            baseTypeId = getBaseTypeAndTypmod(typeOid, &baseTypeMod);
            baseTypeColl = get_typcollation(baseTypeId);
            defval = (Expr *) makeNullConst(baseTypeId, baseTypeMod, baseTypeColl);
            defval = (Expr *) coerce_to_target_type(NULL,
                                                    (Node *) defval,
                                                    baseTypeId,
                                                    typeOid,
                                                    typmod,
                                                    COERCION_ASSIGNMENT,
                                                    COERCE_IMPLICIT_CAST,
                                                    -1);
            if (defval == NULL) /* should not happen */
                elog(ERROR, "failed to coerce base type to domain");
        }

        if (defval)
        {
            NewColumnValue *newval;

            newval = (NewColumnValue *) palloc0(sizeof(NewColumnValue));
            newval->attnum = attribute.attnum;
            newval->expr = expression_planner(defval);
            newval->is_generated = (colDef->generated != '\0');

            tab->newvals = lappend(tab->newvals, newval);
        }

        if (DomainHasConstraints(typeOid))
            tab->rewrite |= AT_REWRITE_DEFAULT_VAL;

        if (!TupleDescAttr(rel->rd_att, attribute.attnum - 1)->atthasmissing)
        {
            /*
             * If the new column is NOT NULL, and there is no missing value,
             * tell Phase 3 it needs to check for NULLs.
             */
            tab->verify_new_notnull |= colDef->is_not_null;
        }
    }

    /*
     * Add needed dependency entries for the new column.
     */
    add_column_datatype_dependency(myrelid, newattnum, attribute.atttypid);
    add_column_collation_dependency(myrelid, newattnum, attribute.attcollation);

    /*
     * Propagate to children as appropriate.  Unlike most other ALTER
     * routines, we have to do this one level of recursion at a time; we can't
     * use find_all_inheritors to do it in one pass.
     */
    children = find_inheritance_children(RelationGetRelid(rel), lockmode);

    /*
     * If we are told not to recurse, there had better not be any child
     * tables; else the addition would put them out of step.
     */
    if (children && !recurse)
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_TABLE_DEFINITION),
                 errmsg("column must be added to child tables too")));

    /* Children should see column as singly inherited */
    if (!recursing)
    {
        childcmd = copyObject(*cmd);
        colDef = castNode(ColumnDef, childcmd->def);
        colDef->inhcount = 1;
        colDef->is_local = false;
    }
    else
        childcmd = *cmd;        /* no need to copy again */

    foreach(child, children)
    {
        Oid         childrelid = lfirst_oid(child);
        Relation    childrel;
        AlteredTableInfo *childtab;

        /* find_inheritance_children already got lock */
        childrel = table_open(childrelid, NoLock);
        CheckTableNotInUse(childrel, "ALTER TABLE");

        /* Find or create work queue entry for this table */
        childtab = ATGetQueueEntry(wqueue, childrel);

        /* Recurse to child; return value is ignored */
        ATExecAddColumn(wqueue, childtab, childrel,
                        &childcmd, recurse, true,
                        lockmode, cur_pass, context);

        table_close(childrel, NoLock);
    }

    ObjectAddressSubSet(address, RelationRelationId, myrelid, newattnum);
    return address;
}

ATExecAddConstraint()

static ObjectAddress ATExecAddConstraint ( List **  wqueue, AlteredTableInfo *  tab, Relation  rel, Constraint *  newConstraint, bool  recurse, bool  is_readd, LOCKMODE  lockmode  )

static

Definition at line 7936 of file tablecmds.c.

References Assert, ATAddCheckConstraint(), ATAddForeignKeyConstraint(), ChooseConstraintName(), ChooseForeignKeyConstraintNameAddition(), Constraint::conname, CONSTR_CHECK, CONSTR_FOREIGN, CONSTRAINT_RELATION, ConstraintNameIsUsed(), Constraint::contype, elog, ereport, errcode(), ERRCODE_DUPLICATE_OBJECT, errmsg(), ERROR, Constraint::fk_attrs, InvalidObjectAddress, InvalidOid, IsA, NIL, RelationGetNamespace, RelationGetRelationName, and RelationGetRelid.

Referenced by ATExecCmd().

{
    ObjectAddress address = InvalidObjectAddress;

    Assert(IsA(newConstraint, Constraint));

    /*
     * Currently, we only expect to see CONSTR_CHECK and CONSTR_FOREIGN nodes
     * arriving here (see the preprocessing done in parse_utilcmd.c).  Use a
     * switch anyway to make it easier to add more code later.
     */
    switch (newConstraint->contype)
    {
        case CONSTR_CHECK:
            address =
                ATAddCheckConstraint(wqueue, tab, rel,
                                     newConstraint, recurse, false, is_readd,
                                     lockmode);
            break;

        case CONSTR_FOREIGN:

            /*
             * Assign or validate constraint name
             */
            if (newConstraint->conname)
            {
                if (ConstraintNameIsUsed(CONSTRAINT_RELATION,
                                         RelationGetRelid(rel),
                                         newConstraint->conname))
                    ereport(ERROR,
                            (errcode(ERRCODE_DUPLICATE_OBJECT),
                             errmsg("constraint \"%s\" for relation \"%s\" already exists",
                                    newConstraint->conname,
                                    RelationGetRelationName(rel))));
            }
            else
                newConstraint->conname =
                    ChooseConstraintName(RelationGetRelationName(rel),
                                         ChooseForeignKeyConstraintNameAddition(newConstraint->fk_attrs),
                                         "fkey",
                                         RelationGetNamespace(rel),
                                         NIL);

            address = ATAddForeignKeyConstraint(wqueue, tab, rel,
                                                newConstraint, InvalidOid,
                                                recurse, false,
                                                lockmode);
            break;

        default:
            elog(ERROR, "unrecognized constraint type: %d",
                 (int) newConstraint->contype);
    }

    return address;
}

ATExecAddIdentity()

static ObjectAddress ATExecAddIdentity ( Relation  rel, const char *  colName, Node *  def, LOCKMODE  lockmode  )

static

Definition at line 6864 of file tablecmds.c.

References attnum, castNode, CatalogTupleUpdate(), ereport, errcode(), errmsg(), ERROR, GETSTRUCT, heap_freetuple(), HeapTupleIsValid, ColumnDef::identity, InvokeObjectPostAlterHook, ObjectAddressSubSet, RelationGetRelationName, RelationGetRelid, RowExclusiveLock, SearchSysCacheCopyAttName(), HeapTupleData::t_self, table_close(), and table_open().

Referenced by ATExecCmd().

{
    Relation    attrelation;
    HeapTuple   tuple;
    Form_pg_attribute attTup;
    AttrNumber  attnum;
    ObjectAddress address;
    ColumnDef  *cdef = castNode(ColumnDef, def);

    attrelation = table_open(AttributeRelationId, RowExclusiveLock);

    tuple = SearchSysCacheCopyAttName(RelationGetRelid(rel), colName);
    if (!HeapTupleIsValid(tuple))
        ereport(ERROR,
                (errcode(ERRCODE_UNDEFINED_COLUMN),
                 errmsg("column \"%s\" of relation \"%s\" does not exist",
                        colName, RelationGetRelationName(rel))));
    attTup = (Form_pg_attribute) GETSTRUCT(tuple);
    attnum = attTup->attnum;

    /* Can't alter a system attribute */
    if (attnum <= 0)
        ereport(ERROR,
                (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                 errmsg("cannot alter system column \"%s\"",
                        colName)));

    /*
     * Creating a column as identity implies NOT NULL, so adding the identity
     * to an existing column that is not NOT NULL would create a state that
     * cannot be reproduced without contortions.
     */
    if (!attTup->attnotnull)
        ereport(ERROR,
                (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
                 errmsg("column \"%s\" of relation \"%s\" must be declared NOT NULL before identity can be added",
                        colName, RelationGetRelationName(rel))));

    if (attTup->attidentity)
        ereport(ERROR,
                (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
                 errmsg("column \"%s\" of relation \"%s\" is already an identity column",
                        colName, RelationGetRelationName(rel))));

    if (attTup->atthasdef)
        ereport(ERROR,
                (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
                 errmsg("column \"%s\" of relation \"%s\" already has a default value",
                        colName, RelationGetRelationName(rel))));

    attTup->attidentity = cdef->identity;
    CatalogTupleUpdate(attrelation, &tuple->t_self, tuple);

    InvokeObjectPostAlterHook(RelationRelationId,
                              RelationGetRelid(rel),
                              attTup->attnum);
    ObjectAddressSubSet(address, RelationRelationId,
                        RelationGetRelid(rel), attnum);
    heap_freetuple(tuple);

    table_close(attrelation, RowExclusiveLock);

    return address;
}

ATExecAddIndex()

static ObjectAddress ATExecAddIndex ( AlteredTableInfo *  tab, Relation  rel, IndexStmt *  stmt, bool  is_rebuild, LOCKMODE  lockmode  )

static

Definition at line 7784 of file tablecmds.c.

References Assert, IndexStmt::concurrent, DefineIndex(), index_close(), index_open(), InvalidOid, IsA, NoLock, ObjectAddress::objectId, OidIsValid, IndexStmt::oldCreateSubid, IndexStmt::oldFirstRelfilenodeSubid, IndexStmt::oldNode, RelationData::rd_createSubid, RelationData::rd_firstRelfilenodeSubid, RelationData::rd_node, RelationGetRelid, RelationPreserveStorage(), AlteredTableInfo::rewrite, and IndexStmt::transformed.

Referenced by ATExecCmd().

{
    bool        check_rights;
    bool        skip_build;
    bool        quiet;
    ObjectAddress address;

    Assert(IsA(stmt, IndexStmt));
    Assert(!stmt->concurrent);

    /* The IndexStmt has already been through transformIndexStmt */
    Assert(stmt->transformed);

    /* suppress schema rights check when rebuilding existing index */
    check_rights = !is_rebuild;
    /* skip index build if phase 3 will do it or we're reusing an old one */
    skip_build = tab->rewrite > 0 || OidIsValid(stmt->oldNode);
    /* suppress notices when rebuilding existing index */
    quiet = is_rebuild;

    address = DefineIndex(RelationGetRelid(rel),
                          stmt,
                          InvalidOid,   /* no predefined OID */
                          InvalidOid,   /* no parent index */
                          InvalidOid,   /* no parent constraint */
                          true, /* is_alter_table */
                          check_rights,
                          false,    /* check_not_in_use - we did it already */
                          skip_build,
                          quiet);

    /*
     * If TryReuseIndex() stashed a relfilenode for us, we used it for the new
     * index instead of building from scratch.  Restore associated fields.
     * This may store InvalidSubTransactionId in both fields, in which case
     * relcache.c will assume it can rebuild the relcache entry.  Hence, do
     * this after the CCI that made catalog rows visible to any rebuild.  The
     * DROP of the old edition of this index will have scheduled the storage
     * for deletion at commit, so cancel that pending deletion.
     */
    if (OidIsValid(stmt->oldNode))
    {
        Relation    irel = index_open(address.objectId, NoLock);

        irel->rd_createSubid = stmt->oldCreateSubid;
        irel->rd_firstRelfilenodeSubid = stmt->oldFirstRelfilenodeSubid;
        RelationPreserveStorage(irel->rd_node, true);
        index_close(irel, NoLock);
    }

    return address;
}

ATExecAddIndexConstraint()

static ObjectAddress ATExecAddIndexConstraint ( AlteredTableInfo *  tab, Relation  rel, IndexStmt *  stmt, LOCKMODE  lockmode  )

static

Definition at line 7844 of file tablecmds.c.

References AccessShareLock, allowSystemTableMods, Assert, BuildIndexInfo(), IndexStmt::deferrable, elog, ereport, errcode(), errmsg(), ERROR, IndexStmt::idxname, IndexInfo::ii_Unique, index_check_primary_key(), index_close(), INDEX_CONSTR_CREATE_DEFERRABLE, INDEX_CONSTR_CREATE_INIT_DEFERRED, INDEX_CONSTR_CREATE_MARK_AS_PRIMARY, INDEX_CONSTR_CREATE_REMOVE_OLD_DEPS, INDEX_CONSTR_CREATE_UPDATE_INDEX, index_constraint_create(), index_open(), IndexStmt::indexOid, IndexStmt::initdeferred, InvalidOid, IsA, IndexStmt::isconstraint, NoLock, NOTICE, OidIsValid, IndexStmt::primary, pstrdup(), RelationData::rd_rel, RelationGetRelationName, and RenameRelationInternal().

Referenced by ATExecCmd().

{
    Oid         index_oid = stmt->indexOid;
    Relation    indexRel;
    char       *indexName;
    IndexInfo  *indexInfo;
    char       *constraintName;
    char        constraintType;
    ObjectAddress address;
    bits16      flags;

    Assert(IsA(stmt, IndexStmt));
    Assert(OidIsValid(index_oid));
    Assert(stmt->isconstraint);

    /*
     * Doing this on partitioned tables is not a simple feature to implement,
     * so let's punt for now.
     */
    if (rel->rd_rel->relkind == RELKIND_PARTITIONED_TABLE)
        ereport(ERROR,
                (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                 errmsg("ALTER TABLE / ADD CONSTRAINT USING INDEX is not supported on partitioned tables")));

    indexRel = index_open(index_oid, AccessShareLock);

    indexName = pstrdup(RelationGetRelationName(indexRel));

    indexInfo = BuildIndexInfo(indexRel);

    /* this should have been checked at parse time */
    if (!indexInfo->ii_Unique)
        elog(ERROR, "index \"%s\" is not unique", indexName);

    /*
     * Determine name to assign to constraint.  We require a constraint to
     * have the same name as the underlying index; therefore, use the index's
     * existing name as the default constraint name, and if the user
     * explicitly gives some other name for the constraint, rename the index
     * to match.
     */
    constraintName = stmt->idxname;
    if (constraintName == NULL)
        constraintName = indexName;
    else if (strcmp(constraintName, indexName) != 0)
    {
        ereport(NOTICE,
                (errmsg("ALTER TABLE / ADD CONSTRAINT USING INDEX will rename index \"%s\" to \"%s\"",
                        indexName, constraintName)));
        RenameRelationInternal(index_oid, constraintName, false, true);
    }

    /* Extra checks needed if making primary key */
    if (stmt->primary)
        index_check_primary_key(rel, indexInfo, true, stmt);

    /* Note we currently don't support EXCLUSION constraints here */
    if (stmt->primary)
        constraintType = CONSTRAINT_PRIMARY;
    else
        constraintType = CONSTRAINT_UNIQUE;

    /* Create the catalog entries for the constraint */
    flags = INDEX_CONSTR_CREATE_UPDATE_INDEX |
        INDEX_CONSTR_CREATE_REMOVE_OLD_DEPS |
        (stmt->initdeferred ? INDEX_CONSTR_CREATE_INIT_DEFERRED : 0) |
        (stmt->deferrable ? INDEX_CONSTR_CREATE_DEFERRABLE : 0) |
        (stmt->primary ? INDEX_CONSTR_CREATE_MARK_AS_PRIMARY : 0);

    address = index_constraint_create(rel,
                                      index_oid,
                                      InvalidOid,
                                      indexInfo,
                                      constraintName,
                                      constraintType,
                                      flags,
                                      allowSystemTableMods,
                                      false);   /* is_internal */

    index_close(indexRel, NoLock);

    return address;
}

ATExecAddInherit()

static ObjectAddress ATExecAddInherit ( Relation  child_rel, RangeVar *  parent, LOCKMODE  lockmode