tablecmds.c File Reference

#include "postgres.h"
#include "access/attmap.h"
#include "access/genam.h"
#include "access/gist.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/toast_compression.h"
#include "access/xact.h"
#include "access/xlog.h"
#include "access/xloginsert.h"
#include "catalog/catalog.h"
#include "catalog/heap.h"
#include "catalog/index.h"
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/partition.h"
#include "catalog/pg_am.h"
#include "catalog/pg_attrdef.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_largeobject.h"
#include "catalog/pg_namespace.h"
#include "catalog/pg_opclass.h"
#include "catalog/pg_policy.h"
#include "catalog/pg_rewrite.h"
#include "catalog/pg_statistic_ext.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/sequence.h"
#include "commands/tablecmds.h"
#include "commands/tablespace.h"
#include "commands/trigger.h"
#include "commands/typecmds.h"
#include "commands/user.h"
#include "commands/vacuum.h"
#include "executor/executor.h"
#include "foreign/fdwapi.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_coerce.h"
#include "parser/parse_collate.h"
#include "parser/parse_expr.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 "utils/usercontext.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	ForeignTruncateInfo
struct	AttachIndexCallbackState
struct	SplitPartitionContext

Macros
#define	AT_NUM_PASSES   (AT_PASS_MISC + 1)
#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	ATT_SEQUENCE   0x0080
#define	child_dependency_type(child_is_partition)    ((child_is_partition) ? DEPENDENCY_AUTO : DEPENDENCY_NORMAL)

Typedefs
typedef struct OnCommitItem	OnCommitItem
typedef enum AlterTablePass	AlterTablePass
typedef struct AlteredTableInfo	AlteredTableInfo
typedef struct NewConstraint	NewConstraint
typedef struct NewColumnValue	NewColumnValue
typedef struct ForeignTruncateInfo	ForeignTruncateInfo
typedef struct SplitPartitionContext	SplitPartitionContext

Enumerations
enum	AlterTablePass {   AT_PASS_UNSET = -1 , AT_PASS_DROP , AT_PASS_ALTER_TYPE , AT_PASS_ADD_COL ,   AT_PASS_SET_EXPRESSION , AT_PASS_OLD_COL_ATTRS , AT_PASS_OLD_INDEX , AT_PASS_OLD_CONSTR ,   AT_PASS_ADD_CONSTR , AT_PASS_COL_ATTRS , AT_PASS_ADD_INDEXCONSTR , AT_PASS_ADD_INDEX ,   AT_PASS_ADD_OTHERCONSTR , AT_PASS_MISC }

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 *columns, const List *supers, char relpersistence, bool is_partition, List **supconstr, List **supnotnulls)
static List *	MergeCheckConstraint (List *constraints, const char *name, Node *expr)
static void	MergeChildAttribute (List *inh_columns, int exist_attno, int newcol_attno, const ColumnDef *newdef)
static ColumnDef *	MergeInheritedAttribute (List *inh_columns, int exist_attno, const ColumnDef *newdef)
static void	MergeAttributesIntoExisting (Relation child_rel, Relation parent_rel, bool ispartition)
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, const List *columns)
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 bool	ATExecAlterConstrRecurse (Constraint *cmdcon, Relation conrel, Relation tgrel, Relation rel, HeapTuple contuple, List **otherrelids, LOCKMODE lockmode)
static ObjectAddress	ATExecValidateConstraint (List **wqueue, 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, bool *pk_has_without_overlaps)
static Oid	transformFkeyCheckAttrs (Relation pkrel, int numattrs, int16 *attnums, bool with_period, Oid *opclasses, bool *pk_has_without_overlaps)
static void	checkFkeyPermissions (Relation rel, int16 *attnums, int natts)
static CoercionPathType	findFkeyCast (Oid targetTypeId, Oid sourceTypeId, Oid *funcid)
static void	validateForeignKeyConstraint (char *conname, Relation rel, Relation pkrel, Oid pkindOid, Oid constraintOid, bool hasperiod)
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, AlterTableCmd *cmd, LOCKMODE lockmode, AlterTablePass cur_pass, AlterTableUtilityContext *context)
static AlterTableCmd *	ATParseTransformCmd (List **wqueue, AlteredTableInfo *tab, Relation rel, AlterTableCmd *cmd, bool recurse, LOCKMODE lockmode, AlterTablePass 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 (AlterTableType cmdtype, 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, AlterTablePass 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 ObjectAddress	ATExecDropNotNull (Relation rel, const char *colName, bool recurse, LOCKMODE lockmode)
static bool	set_attnotnull (List **wqueue, Relation rel, AttrNumber attnum, bool recurse, LOCKMODE lockmode)
static ObjectAddress	ATExecSetNotNull (List **wqueue, Relation rel, char *constrname, char *colName, bool recurse, bool recursing, List **readyRels, LOCKMODE lockmode)
static ObjectAddress	ATExecSetAttNotNull (List **wqueue, 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	ATExecCookedColumnDefault (Relation rel, AttrNumber attnum, Node *newDefault)
static ObjectAddress	ATExecAddIdentity (Relation rel, const char *colName, Node *def, LOCKMODE lockmode, bool recurse, bool recursing)
static ObjectAddress	ATExecSetIdentity (Relation rel, const char *colName, Node *def, LOCKMODE lockmode, bool recurse, bool recursing)
static ObjectAddress	ATExecDropIdentity (Relation rel, const char *colName, bool missing_ok, LOCKMODE lockmode, bool recurse, bool recursing)
static ObjectAddress	ATExecSetExpression (AlteredTableInfo *tab, Relation rel, const char *colName, Node *newExpr, LOCKMODE lockmode)
static void	ATPrepDropExpression (Relation rel, AlterTableCmd *cmd, bool recurse, bool recursing, LOCKMODE lockmode)
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 void	ATPrepAddPrimaryKey (List **wqueue, Relation rel, AlterTableCmd *cmd, LOCKMODE lockmode, AlterTableUtilityContext *context)
static ObjectAddress	ATExecAddIndex (AlteredTableInfo *tab, Relation rel, IndexStmt *stmt, bool is_rebuild, LOCKMODE lockmode)
static ObjectAddress	ATExecAddStatistics (AlteredTableInfo *tab, Relation rel, CreateStatsStmt *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	ATAddCheckNNConstraint (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, 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, int numfkdelsetcols, int16 *fkdelsetcols, bool old_check_ok, Oid parentDelTrigger, Oid parentUpdTrigger, bool with_period)
static void	validateFkOnDeleteSetColumns (int numfks, const int16 *fkattnums, int numfksetcols, const int16 *fksetcolsattnums, List *fksetcols)
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, int numfkdelsetcols, int16 *fkdelsetcols, bool old_check_ok, LOCKMODE lockmode, Oid parentInsTrigger, Oid parentUpdTrigger, bool with_period)
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, Oid parentInsTrigger, Oid parentUpdTrigger, Oid *insertTrigOid, Oid *updateTrigOid)
static void	createForeignKeyActionTriggers (Relation rel, Oid refRelOid, Constraint *fkconstraint, Oid constraintOid, Oid indexOid, Oid parentDelTrigger, Oid parentUpdTrigger, Oid *deleteTrigOid, Oid *updateTrigOid)
static bool	tryAttachPartitionForeignKey (ForeignKeyCacheInfo *fk, Oid partRelid, Oid parentConstrOid, int numfks, AttrNumber *mapped_conkey, AttrNumber *confkey, Oid *conpfeqop, Oid parentInsTrigger, Oid parentUpdTrigger, Relation trigrel)
static void	GetForeignKeyActionTriggers (Relation trigrel, Oid conoid, Oid confrelid, Oid conrelid, Oid *deleteTriggerOid, Oid *updateTriggerOid)
static void	GetForeignKeyCheckTriggers (Relation trigrel, Oid conoid, Oid confrelid, Oid conrelid, Oid *insertTriggerOid, Oid *updateTriggerOid)
static void	ATExecDropConstraint (Relation rel, const char *constrName, DropBehavior behavior, bool recurse, bool missing_ok, LOCKMODE lockmode)
static ObjectAddress	dropconstraint_internal (Relation rel, HeapTuple constraintTup, DropBehavior behavior, bool recurse, bool recursing, bool missing_ok, List **readyRels, 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	RememberAllDependentForRebuilding (AlteredTableInfo *tab, AlterTableType subtype, Relation rel, AttrNumber attnum, const char *colName)
static void	RememberConstraintForRebuilding (Oid conoid, AlteredTableInfo *tab)
static void	RememberIndexForRebuilding (Oid indoid, AlteredTableInfo *tab)
static void	RememberStatisticsForRebuilding (Oid stxoid, 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, AlterTablePass 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 void	ATPrepSetAccessMethod (AlteredTableInfo *tab, Relation rel, const char *amname)
static void	ATExecSetAccessMethodNoStorage (Relation rel, Oid newAccessMethod)
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, bool recurse, 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	ATExecSetRowSecurity (Relation rel, bool rls)
static void	ATExecForceNoForceRowSecurity (Relation rel, bool force_rls)
static ObjectAddress	ATExecSetCompression (Relation rel, const char *column, Node *newValue, LOCKMODE lockmode)
static void	index_copy_data (Relation rel, RelFileLocator newrlocator)
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)
static void	ComputePartitionAttrs (ParseState *pstate, Relation rel, List *partParams, AttrNumber *partattrs, List **partexprs, Oid *partopclass, Oid *partcollation, PartitionStrategy strategy)
static void	CreateInheritance (Relation child_rel, Relation parent_rel, bool ispartition)
static void	RemoveInheritance (Relation child_rel, Relation parent_rel, bool expect_detached)
static void	ATInheritAdjustNotNulls (Relation parent_rel, Relation child_rel, int inhcount)
static ObjectAddress	ATExecAttachPartition (List **wqueue, Relation rel, PartitionCmd *cmd, AlterTableUtilityContext *context)
static void	AttachPartitionEnsureIndexes (List **wqueue, 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	DetachAddConstraintIfNeeded (List **wqueue, Relation partRel)
static void	DropClonedTriggersFromPartition (Oid partitionId)
static ObjectAddress	ATExecDetachPartition (List **wqueue, AlteredTableInfo *tab, Relation rel, RangeVar *name, bool concurrent)
static void	DetachPartitionFinalize (Relation rel, Relation partRel, bool concurrent, Oid defaultPartOid)
static ObjectAddress	ATExecDetachPartitionFinalize (Relation rel, RangeVar *name)
static ObjectAddress	ATExecAttachPartitionIdx (List **wqueue, Relation parentIdx, RangeVar *name)
static void	validatePartitionedIndex (Relation partedIdx, Relation partedTbl)
static void	refuseDupeIndexAttach (Relation parentIdx, Relation partIdx, Relation partitionTbl)
static void	verifyPartitionIndexNotNull (IndexInfo *iinfo, Relation partIdx)
static List *	GetParentedForeignKeyRefs (Relation partition)
static void	ATDetachCheckNoForeignKeyRefs (Relation partition)
static char	GetAttributeCompression (Oid atttypid, const char *compression)
static char	GetAttributeStorage (Oid atttypid, const char *storagemode)
static void	ATExecSplitPartition (List **wqueue, AlteredTableInfo *tab, Relation rel, PartitionCmd *cmd, AlterTableUtilityContext *context)
static void	ATExecMergePartitions (List **wqueue, AlteredTableInfo *tab, Relation rel, PartitionCmd *cmd, AlterTableUtilityContext *context)
ObjectAddress	DefineRelation (CreateStmt *stmt, char relkind, Oid ownerId, ObjectAddress *typaddress, const char *queryString)
TupleDesc	BuildDescForRelation (const List *columns)
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, bool run_as_table_owner)
void	SetRelationHasSubclass (Oid relationId, bool relhassubclass)
bool	CheckRelationTableSpaceMove (Relation rel, Oid newTableSpaceId)
void	SetRelationTableSpace (Relation rel, Oid newTableSpaceId, RelFileNumber newRelFilenumber)
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	ResetRelRewrite (Oid myrelid)
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)
static const char *	alter_table_type_to_string (AlterTableType cmdtype)
void	find_composite_type_dependencies (Oid typeOid, Relation origRelation, const char *origTypeName)
void	check_of_type (HeapTuple typetuple)
static void	SetIndexStorageProperties (Relation rel, Relation attrelation, AttrNumber attnum, bool setstorage, char newstorage, bool setcompression, char newcompression, LOCKMODE lockmode)
static Oid	CreateFKCheckTrigger (Oid myRelOid, Oid refRelOid, Constraint *fkconstraint, Oid constraintOid, Oid indexOid, Oid parentTrigOid, 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	MarkInheritDetached (Relation child_rel, Relation parent_rel)
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	RangeVarCallbackMaintainsTable (const RangeVar *relation, Oid relId, Oid oldRelId, void *arg)
void	RangeVarCallbackOwnsRelation (const RangeVar *relation, Oid relId, Oid oldRelId, void *arg)
bool	PartConstraintImpliedByRelConstraint (Relation scanrel, List *partConstraint)
static void	attachPartitionTable (List **wqueue, Relation rel, Relation attachrel, PartitionBoundSpec *bound)
static void	RangeVarCallbackForAttachIndex (const RangeVar *rv, Oid relOid, Oid oldRelOid, void *arg)
static SplitPartitionContext *	createSplitPartitionContext (Relation partRel)
static void	deleteSplitPartitionContext (SplitPartitionContext *pc, int ti_options)
static void	moveSplitTableRows (Relation rel, Relation splitRel, List *partlist, List *newPartRels, Oid defaultPartOid)
static void	createPartitionTable (RangeVar *newPartName, RangeVar *modelRelName, AlterTableUtilityContext *context)
static void	moveMergedTablesRows (Relation rel, List *mergingPartitionsList, Relation newPartRel)

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

Macro Definition Documentation

AT_NUM_PASSES

#define AT_NUM_PASSES   (AT_PASS_MISC + 1)

Definition at line 164 of file tablecmds.c.

ATT_COMPOSITE_TYPE

#define ATT_COMPOSITE_TYPE   0x0010

Definition at line 330 of file tablecmds.c.

ATT_FOREIGN_TABLE

#define ATT_FOREIGN_TABLE   0x0020

Definition at line 331 of file tablecmds.c.

ATT_INDEX

#define ATT_INDEX   0x0008

Definition at line 329 of file tablecmds.c.

ATT_MATVIEW

#define ATT_MATVIEW   0x0004

Definition at line 328 of file tablecmds.c.

ATT_PARTITIONED_INDEX

#define ATT_PARTITIONED_INDEX   0x0040

Definition at line 332 of file tablecmds.c.

ATT_SEQUENCE

#define ATT_SEQUENCE   0x0080

Definition at line 333 of file tablecmds.c.

ATT_TABLE

#define ATT_TABLE   0x0001

Definition at line 326 of file tablecmds.c.

ATT_VIEW

#define ATT_VIEW   0x0002

Definition at line 327 of file tablecmds.c.

child_dependency_type

#define child_dependency_type

(

child_is_partition

)

((child_is_partition) ? DEPENDENCY_AUTO : DEPENDENCY_NORMAL)

Definition at line 354 of file tablecmds.c.

Typedef Documentation

AlteredTableInfo

typedef struct AlteredTableInfo AlteredTableInfo

AlterTablePass

typedef enum AlterTablePass AlterTablePass

ForeignTruncateInfo

typedef struct ForeignTruncateInfo ForeignTruncateInfo

NewColumnValue

typedef struct NewColumnValue NewColumnValue

NewConstraint

typedef struct NewConstraint NewConstraint

OnCommitItem

typedef struct OnCommitItem OnCommitItem

SplitPartitionContext

typedef struct SplitPartitionContext SplitPartitionContext

Enumeration Type Documentation

AlterTablePass

enum AlterTablePass

Enumerator
AT_PASS_UNSET
AT_PASS_DROP
AT_PASS_ALTER_TYPE
AT_PASS_ADD_COL
AT_PASS_SET_EXPRESSION
AT_PASS_OLD_COL_ATTRS
AT_PASS_OLD_INDEX
AT_PASS_OLD_CONSTR
AT_PASS_ADD_CONSTR
AT_PASS_COL_ATTRS
AT_PASS_ADD_INDEXCONSTR
AT_PASS_ADD_INDEX
AT_PASS_ADD_OTHERCONSTR
AT_PASS_MISC

Definition at line 145 of file tablecmds.c.

{
    AT_PASS_UNSET = -1,         /* UNSET will cause ERROR */
    AT_PASS_DROP,               /* DROP (all flavors) */
    AT_PASS_ALTER_TYPE,         /* ALTER COLUMN TYPE */
    AT_PASS_ADD_COL,            /* ADD COLUMN */
    AT_PASS_SET_EXPRESSION,     /* ALTER SET EXPRESSION */
    AT_PASS_OLD_COL_ATTRS,      /* re-install attnotnull */
    AT_PASS_OLD_INDEX,          /* re-add existing indexes */
    AT_PASS_OLD_CONSTR,         /* re-add existing constraints */
    /* We could support a RENAME COLUMN pass here, but not currently used */
    AT_PASS_ADD_CONSTR,         /* ADD constraints (initial examination) */
    AT_PASS_COL_ATTRS,          /* set column attributes, eg NOT NULL */
    AT_PASS_ADD_INDEXCONSTR,    /* ADD index-based constraints */
    AT_PASS_ADD_INDEX,          /* ADD indexes */
    AT_PASS_ADD_OTHERCONSTR,    /* ADD other constraints, defaults */
    AT_PASS_MISC,               /* other stuff */
} AlterTablePass;

Function Documentation

add_column_collation_dependency()

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

static

Definition at line 7545 of file tablecmds.c.

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

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

Referenced by ATExecAddColumn(), and ATExecAlterColumnType().

add_column_datatype_dependency()

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

static

Definition at line 7527 of file tablecmds.c.

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

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

Referenced by ATExecAddColumn(), and ATExecAlterColumnType().

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, int  numfkdelsetcols, int16 *  fkdelsetcols, bool  old_check_ok, Oid  parentDelTrigger, Oid  parentUpdTrigger, bool  with_period  )

static

Definition at line 10482 of file tablecmds.c.

{
    ObjectAddress address;
    Oid         constrOid;
    char       *conname;
    bool        conislocal;
    int         coninhcount;
    bool        connoinherit;
    Oid         deleteTriggerOid,
                updateTriggerOid;
 
    /*
     * 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,
                                      fkdelsetcols,
                                      numfkdelsetcols,
                                      fkconstraint->fk_matchtype,
                                      NULL, /* no exclusion constraint */
                                      NULL, /* no check constraint */
                                      NULL,
                                      conislocal,   /* islocal */
                                      coninhcount,  /* inhcount */
                                      connoinherit, /* conNoInherit */
                                      with_period,  /* conPeriod */
                                      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();
 
    /*
     * Create the action triggers that enforce the constraint.
     */
    createForeignKeyActionTriggers(rel, RelationGetRelid(pkrel),
                                   fkconstraint,
                                   constrOid, indexOid,
                                   parentDelTrigger, parentUpdTrigger,
                                   &deleteTriggerOid, &updateTriggerOid);
 
    /*
     * 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, true);
 
        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),
                                               false);
            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,
                                   numfkdelsetcols, fkdelsetcols,
                                   old_check_ok,
                                   deleteTriggerOid, updateTriggerOid,
                                   with_period);
 
            /* Done -- clean up (but keep the lock) */
            table_close(partRel, NoLock);
            if (map)
            {
                pfree(mapped_pkattnum);
                free_attrmap(map);
            }
        }
    }
 
    return address;
}

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, j, 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().

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, int  numfkdelsetcols, int16 *  fkdelsetcols, bool  old_check_ok, LOCKMODE  lockmode, Oid  parentInsTrigger, Oid  parentUpdTrigger, bool  with_period  )

static

Definition at line 10705 of file tablecmds.c.

{
    Oid         insertTriggerOid,
                updateTriggerOid;
 
    Assert(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")));
 
    /*
     * 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.
     */
    createForeignKeyCheckTriggers(RelationGetRelid(rel),
                                  RelationGetRelid(pkrel),
                                  fkconstraint,
                                  parentConstr,
                                  indexOid,
                                  parentInsTrigger, parentUpdTrigger,
                                  &insertTriggerOid, &updateTriggerOid);
 
    if (rel->rd_rel->relkind == RELKIND_RELATION)
    {
        /*
         * 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->conwithperiod = fkconstraint->fk_with_period;
            newcon->qual = (Node *) fkconstraint;
 
            tab->constraints = lappend(tab->constraints, newcon);
        }
    }
    else if (rel->rd_rel->relkind == RELKIND_PARTITIONED_TABLE)
    {
        PartitionDesc pd = RelationGetPartitionDesc(rel, true);
        Relation    trigrel;
 
        /*
         * Triggers of the foreign keys will be manipulated a bunch of times
         * in the loop below.  To avoid repeatedly opening/closing the trigger
         * catalog relation, we open it here and pass it to the subroutines
         * called below.
         */
        trigrel = table_open(TriggerRelationId, RowExclusiveLock);
 
        /*
         * 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),
                                           false);
            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,
                                                 insertTriggerOid,
                                                 updateTriggerOid,
                                                 trigrel))
                {
                    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,
                                      fkdelsetcols,
                                      numfkdelsetcols,
                                      fkconstraint->fk_matchtype,
                                      NULL,
                                      NULL,
                                      NULL,
                                      false,
                                      1,
                                      false,
                                      with_period,  /* conPeriod */
                                      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,
                                    numfkdelsetcols,
                                    fkdelsetcols,
                                    old_check_ok,
                                    lockmode,
                                    insertTriggerOid,
                                    updateTriggerOid,
                                    with_period);
 
            table_close(partition, NoLock);
        }
 
        table_close(trigrel, RowExclusiveLock);
    }
}

References Assert, ATGetQueueEntry(), AttrMap::attnums, build_attrmap_by_name(), CheckTableNotInUse(), ChooseConstraintName(), ChooseForeignKeyConstraintNameAddition(), CommandCounterIncrement(), NewConstraint::conid, Constraint::conname, CONSTR_FOREIGN, CONSTRAINT_RELATION, ConstraintNameIsUsed(), AlteredTableInfo::constraints, NewConstraint::contype, NewConstraint::conwithperiod, 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, Constraint::fk_with_period, get_constraint_name(), i, INDEX_MAX_KEYS, Constraint::initdeferred, Constraint::initially_valid, InvalidOid, j, 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, RowExclusiveLock, Constraint::skip_validation, table_close(), table_open(), and tryAttachPartitionForeignKey().

Referenced by ATAddForeignKeyConstraint(), and CloneFkReferencing().

alter_table_type_to_string()

static const char* alter_table_type_to_string ( AlterTableType  cmdtype )

static

Definition at line 6463 of file tablecmds.c.

{
    switch (cmdtype)
    {
        case AT_AddColumn:
        case AT_AddColumnToView:
            return "ADD COLUMN";
        case AT_ColumnDefault:
        case AT_CookedColumnDefault:
            return "ALTER COLUMN ... SET DEFAULT";
        case AT_DropNotNull:
            return "ALTER COLUMN ... DROP NOT NULL";
        case AT_SetNotNull:
            return "ALTER COLUMN ... SET NOT NULL";
        case AT_SetAttNotNull:
            return NULL;        /* not real grammar */
        case AT_SetExpression:
            return "ALTER COLUMN ... SET EXPRESSION";
        case AT_DropExpression:
            return "ALTER COLUMN ... DROP EXPRESSION";
        case AT_SetStatistics:
            return "ALTER COLUMN ... SET STATISTICS";
        case AT_SetOptions:
            return "ALTER COLUMN ... SET";
        case AT_ResetOptions:
            return "ALTER COLUMN ... RESET";
        case AT_SetStorage:
            return "ALTER COLUMN ... SET STORAGE";
        case AT_SetCompression:
            return "ALTER COLUMN ... SET COMPRESSION";
        case AT_DropColumn:
            return "DROP COLUMN";
        case AT_AddIndex:
        case AT_ReAddIndex:
            return NULL;        /* not real grammar */
        case AT_AddConstraint:
        case AT_ReAddConstraint:
        case AT_ReAddDomainConstraint:
        case AT_AddIndexConstraint:
            return "ADD CONSTRAINT";
        case AT_AlterConstraint:
            return "ALTER CONSTRAINT";
        case AT_ValidateConstraint:
            return "VALIDATE CONSTRAINT";
        case AT_DropConstraint:
            return "DROP CONSTRAINT";
        case AT_ReAddComment:
            return NULL;        /* not real grammar */
        case AT_AlterColumnType:
            return "ALTER COLUMN ... SET DATA TYPE";
        case AT_AlterColumnGenericOptions:
            return "ALTER COLUMN ... OPTIONS";
        case AT_ChangeOwner:
            return "OWNER TO";
        case AT_ClusterOn:
            return "CLUSTER ON";
        case AT_DropCluster:
            return "SET WITHOUT CLUSTER";
        case AT_SetAccessMethod:
            return "SET ACCESS METHOD";
        case AT_SetLogged:
            return "SET LOGGED";
        case AT_SetUnLogged:
            return "SET UNLOGGED";
        case AT_DropOids:
            return "SET WITHOUT OIDS";
        case AT_SetTableSpace:
            return "SET TABLESPACE";
        case AT_SetRelOptions:
            return "SET";
        case AT_ResetRelOptions:
            return "RESET";
        case AT_ReplaceRelOptions:
            return NULL;        /* not real grammar */
        case AT_EnableTrig:
            return "ENABLE TRIGGER";
        case AT_EnableAlwaysTrig:
            return "ENABLE ALWAYS TRIGGER";
        case AT_EnableReplicaTrig:
            return "ENABLE REPLICA TRIGGER";
        case AT_DisableTrig:
            return "DISABLE TRIGGER";
        case AT_EnableTrigAll:
            return "ENABLE TRIGGER ALL";
        case AT_DisableTrigAll:
            return "DISABLE TRIGGER ALL";
        case AT_EnableTrigUser:
            return "ENABLE TRIGGER USER";
        case AT_DisableTrigUser:
            return "DISABLE TRIGGER USER";
        case AT_EnableRule:
            return "ENABLE RULE";
        case AT_EnableAlwaysRule:
            return "ENABLE ALWAYS RULE";
        case AT_EnableReplicaRule:
            return "ENABLE REPLICA RULE";
        case AT_DisableRule:
            return "DISABLE RULE";
        case AT_AddInherit:
            return "INHERIT";
        case AT_DropInherit:
            return "NO INHERIT";
        case AT_AddOf:
            return "OF";
        case AT_DropOf:
            return "NOT OF";
        case AT_ReplicaIdentity:
            return "REPLICA IDENTITY";
        case AT_EnableRowSecurity:
            return "ENABLE ROW SECURITY";
        case AT_DisableRowSecurity:
            return "DISABLE ROW SECURITY";
        case AT_ForceRowSecurity:
            return "FORCE ROW SECURITY";
        case AT_NoForceRowSecurity:
            return "NO FORCE ROW SECURITY";
        case AT_GenericOptions:
            return "OPTIONS";
        case AT_AttachPartition:
            return "ATTACH PARTITION";
        case AT_DetachPartition:
            return "DETACH PARTITION";
        case AT_DetachPartitionFinalize:
            return "DETACH PARTITION ... FINALIZE";
        case AT_SplitPartition:
            return "SPLIT PARTITION";
        case AT_MergePartitions:
            return "MERGE PARTITIONS";
        case AT_AddIdentity:
            return "ALTER COLUMN ... ADD IDENTITY";
        case AT_SetIdentity:
            return "ALTER COLUMN ... SET";
        case AT_DropIdentity:
            return "ALTER COLUMN ... DROP IDENTITY";
        case AT_ReAddStatistics:
            return NULL;        /* not real grammar */
    }
 
    return NULL;
}

References AT_AddColumn, AT_AddColumnToView, AT_AddConstraint, AT_AddIdentity, AT_AddIndex, AT_AddIndexConstraint, AT_AddInherit, AT_AddOf, AT_AlterColumnGenericOptions, AT_AlterColumnType, AT_AlterConstraint, AT_AttachPartition, AT_ChangeOwner, AT_ClusterOn, AT_ColumnDefault, AT_CookedColumnDefault, AT_DetachPartition, AT_DetachPartitionFinalize, AT_DisableRowSecurity, AT_DisableRule, AT_DisableTrig, AT_DisableTrigAll, AT_DisableTrigUser, AT_DropCluster, AT_DropColumn, AT_DropConstraint, AT_DropExpression, AT_DropIdentity, AT_DropInherit, AT_DropNotNull, AT_DropOf, AT_DropOids, AT_EnableAlwaysRule, AT_EnableAlwaysTrig, AT_EnableReplicaRule, AT_EnableReplicaTrig, AT_EnableRowSecurity, AT_EnableRule, AT_EnableTrig, AT_EnableTrigAll, AT_EnableTrigUser, AT_ForceRowSecurity, AT_GenericOptions, AT_MergePartitions, AT_NoForceRowSecurity, AT_ReAddComment, AT_ReAddConstraint, AT_ReAddDomainConstraint, AT_ReAddIndex, AT_ReAddStatistics, AT_ReplaceRelOptions, AT_ReplicaIdentity, AT_ResetOptions, AT_ResetRelOptions, AT_SetAccessMethod, AT_SetAttNotNull, AT_SetCompression, AT_SetExpression, AT_SetIdentity, AT_SetLogged, AT_SetNotNull, AT_SetOptions, AT_SetRelOptions, AT_SetStatistics, AT_SetStorage, AT_SetTableSpace, AT_SetUnLogged, AT_SplitPartition, and AT_ValidateConstraint.

Referenced by ATSimplePermissions().

AlterIndexNamespaces()

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

static

Definition at line 18051 of file tablecmds.c.

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

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

Referenced by AlterTableNamespaceInternal().

AlterRelationNamespaceInternal()

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

Definition at line 17981 of file tablecmds.c.

{
    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, "could not 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);
}

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, SearchSysCacheCopy1, and HeapTupleData::t_self.

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

AlterSeqNamespaces()

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

static

Definition at line 18096 of file tablecmds.c.

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

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

Referenced by AlterTableNamespaceInternal().

AlterTable()

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

Definition at line 4433 of file tablecmds.c.

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

References ATController(), CheckTableNotInUse(), context, NoLock, relation_open(), and stmt.

Referenced by ProcessUtilitySlow().

AlterTableGetLockLevel()

LOCKMODE AlterTableGetLockLevel

(

List *

cmds

)

Definition at line 4507 of file tablecmds.c.

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

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

Referenced by AlterTableInternal(), and ProcessUtilitySlow().

AlterTableInternal()

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

Definition at line 4462 of file tablecmds.c.

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

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

Referenced by AlterTableMoveAll(), and DefineVirtualRelation().

AlterTableLookupRelation()

Oid AlterTableLookupRelation	(	AlterTableStmt *	stmt,
		LOCKMODE	lockmode
	)

Definition at line 4374 of file tablecmds.c.

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

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

Referenced by ProcessUtilitySlow().

AlterTableMoveAll()

Oid AlterTableMoveAll

(

AlterTableMoveAllStmt *

stmt

)

Definition at line 15890 of file tablecmds.c.

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

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

Referenced by ProcessUtilitySlow().

AlterTableNamespace()

ObjectAddress AlterTableNamespace	(	AlterObjectSchemaStmt *	stmt,
		Oid *	oldschema
	)

Definition at line 17876 of file tablecmds.c.

{
    Relation    rel;
    Oid         relid;
    Oid         oldNspOid;
    Oid         nspOid;
    RangeVar   *newrv;
    ObjectAddresses *objsMoved;
    ObjectAddress myself;
 
    relid = RangeVarGetRelidExtended(stmt->relation, AccessExclusiveLock,
                                     stmt->missing_ok ? RVR_MISSING_OK : 0,
                                     RangeVarCallbackForAlterRelation,
                                     (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;
}

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

Referenced by ExecAlterObjectSchemaStmt().

AlterTableNamespaceInternal()

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

Definition at line 17947 of file tablecmds.c.

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

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

Referenced by AlterObjectNamespace_oid(), and AlterTableNamespace().

ATAddCheckNNConstraint()

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

static

Definition at line 9728 of file tablecmds.c.

{
    List       *newcons;
    ListCell   *lcon;
    List       *children;
    ListCell   *child;
    ObjectAddress address = InvalidObjectAddress;
 
    /* Guard against stack overflow due to overly deep inheritance tree. */
    check_stack_depth();
 
    /* At top level, permission check was done in ATPrepCmd, else do it */
    if (recursing)
        ATSimplePermissions(AT_AddConstraint, 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 && ccon->contype != CONSTR_NOTNULL)
        {
            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;
 
        /*
         * If adding a not-null constraint, set the pg_attribute flag and tell
         * phase 3 to verify existing rows, if needed.
         */
        if (constr->contype == CONSTR_NOTNULL)
            set_attnotnull(wqueue, rel, ccon->attnum,
                           !ccon->is_no_inherit, lockmode);
 
        ObjectAddressSet(address, ConstraintRelationId, ccon->conoid);
    }
 
    /* At this point we must have a locked-down name to use */
    Assert(newcons == NIL || 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")));
 
    /*
     * The constraint must appear as inherited in children, so create a
     * modified constraint object to use.
     */
    constr = copyObject(constr);
    constr->inhcount = 1;
    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.  XXX if we didn't create a constraint on the
         * parent because it already existed, and we do create one on a child,
         * should we return that child's constraint ObjectAddress here?
         */
        ATAddCheckNNConstraint(wqueue, childtab, childrel,
                               constr, recurse, true, is_readd, lockmode);
 
        table_close(childrel, NoLock);
    }
 
    return address;
}

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

Referenced by ATExecAddConstraint(), and DetachAddConstraintIfNeeded().

ATAddForeignKeyConstraint()

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

static

Definition at line 9886 of file tablecmds.c.

{
    Relation    pkrel;
    int16       pkattnum[INDEX_MAX_KEYS] = {0};
    int16       fkattnum[INDEX_MAX_KEYS] = {0};
    Oid         pktypoid[INDEX_MAX_KEYS] = {0};
    Oid         fktypoid[INDEX_MAX_KEYS] = {0};
    Oid         opclasses[INDEX_MAX_KEYS] = {0};
    Oid         pfeqoperators[INDEX_MAX_KEYS] = {0};
    Oid         ppeqoperators[INDEX_MAX_KEYS] = {0};
    Oid         ffeqoperators[INDEX_MAX_KEYS] = {0};
    int16       fkdelsetcols[INDEX_MAX_KEYS] = {0};
    bool        with_period;
    bool        pk_has_without_overlaps;
    int         i;
    int         numfks,
                numpks,
                numfkdelsetcols;
    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 (!RelationIsPermanent(pkrel))
                ereport(ERROR,
                        (errcode(ERRCODE_INVALID_TABLE_DEFINITION),
                         errmsg("constraints on permanent tables may reference only permanent tables")));
            break;
        case RELPERSISTENCE_UNLOGGED:
            if (!RelationIsPermanent(pkrel)
                && 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.
     */
    numfks = transformColumnNameList(RelationGetRelid(rel),
                                     fkconstraint->fk_attrs,
                                     fkattnum, fktypoid);
    with_period = fkconstraint->fk_with_period || fkconstraint->pk_with_period;
    if (with_period && !fkconstraint->fk_with_period)
        ereport(ERROR,
                errcode(ERRCODE_INVALID_FOREIGN_KEY),
                errmsg("foreign key uses PERIOD on the referenced table but not the referencing table"));
 
    numfkdelsetcols = transformColumnNameList(RelationGetRelid(rel),
                                              fkconstraint->fk_del_set_cols,
                                              fkdelsetcols, NULL);
    validateFkOnDeleteSetColumns(numfks, fkattnum,
                                 numfkdelsetcols, fkdelsetcols,
                                 fkconstraint->fk_del_set_cols);
 
    /*
     * 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, &pk_has_without_overlaps);
 
        /* If the primary key uses WITHOUT OVERLAPS, the fk must use PERIOD */
        if (pk_has_without_overlaps && !fkconstraint->fk_with_period)
            ereport(ERROR,
                    errcode(ERRCODE_INVALID_FOREIGN_KEY),
                    errmsg("foreign key uses PERIOD on the referenced table but not the referencing table"));
    }
    else
    {
        numpks = transformColumnNameList(RelationGetRelid(pkrel),
                                         fkconstraint->pk_attrs,
                                         pkattnum, pktypoid);
 
        /* Since we got pk_attrs, one should be a period. */
        if (with_period && !fkconstraint->pk_with_period)
            ereport(ERROR,
                    errcode(ERRCODE_INVALID_FOREIGN_KEY),
                    errmsg("foreign key uses PERIOD on the referencing table but not the referenced table"));
 
        /* Look for an index matching the column list */
        indexOid = transformFkeyCheckAttrs(pkrel, numpks, pkattnum,
                                           with_period, opclasses, &pk_has_without_overlaps);
    }
 
    /*
     * If the referenced primary key has WITHOUT OVERLAPS, the foreign key
     * must use PERIOD.
     */
    if (pk_has_without_overlaps && !with_period)
        ereport(ERROR,
                errcode(ERRCODE_INVALID_FOREIGN_KEY),
                errmsg("foreign key must use PERIOD when referencing a primary using WITHOUT OVERLAPS"));
 
    /*
     * 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")));
        }
    }
 
    /*
     * Some actions are currently unsupported for foreign keys using PERIOD.
     */
    if (fkconstraint->fk_with_period)
    {
        if (fkconstraint->fk_upd_action == FKCONSTR_ACTION_CASCADE ||
            fkconstraint->fk_upd_action == FKCONSTR_ACTION_SETNULL ||
            fkconstraint->fk_upd_action == FKCONSTR_ACTION_SETDEFAULT)
            ereport(ERROR,
                    errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                    errmsg("unsupported %s action for foreign key constraint using PERIOD",
                           "ON UPDATE"));
 
        if (fkconstraint->fk_del_action == FKCONSTR_ACTION_CASCADE ||
            fkconstraint->fk_del_action == FKCONSTR_ACTION_SETNULL ||
            fkconstraint->fk_del_action == FKCONSTR_ACTION_SETDEFAULT)
            ereport(ERROR,
                    errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                    errmsg("unsupported %s action for foreign key constraint using PERIOD",
                           "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);
 
        if (with_period)
        {
            StrategyNumber rtstrategy;
            bool        for_overlaps = with_period && i == numpks - 1;
 
            /*
             * GiST indexes are required to support temporal foreign keys
             * because they combine equals and overlaps.
             */
            if (amid != GIST_AM_OID)
                elog(ERROR, "only GiST indexes are supported for temporal foreign keys");
 
            rtstrategy = for_overlaps ? RTOverlapStrategyNumber : RTEqualStrategyNumber;
 
            /*
             * An opclass can use whatever strategy numbers it wants, so we
             * ask the opclass what number it actually uses instead of our RT*
             * constants.
             */
            eqstrategy = GistTranslateStratnum(opclasses[i], rtstrategy);
            if (eqstrategy == InvalidStrategy)
            {
                HeapTuple   tuple;
 
                tuple = SearchSysCache1(CLAOID, ObjectIdGetDatum(opclasses[i]));
                if (!HeapTupleIsValid(tuple))
                    elog(ERROR, "cache lookup failed for operator class %u", opclasses[i]);
 
                ereport(ERROR,
                        errcode(ERRCODE_UNDEFINED_OBJECT),
                        for_overlaps
                        ? errmsg("could not identify an overlaps operator for foreign key")
                        : errmsg("could not identify an equality operator for foreign key"),
                        errdetail("Could not translate strategy number %d for operator class \"%s\" for access method \"%s\".",
                                  rtstrategy, NameStr(((Form_pg_opclass) GETSTRUCT(tuple))->opcname), "gist"));
            }
        }
        else
        {
            /*
             * 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.  (We could use
             * something like GistTranslateStratnum.)
             */
            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;
    }
 
    /*
     * For FKs with PERIOD we need additional operators to check whether the
     * referencing row's range is contained by the aggregated ranges of the
     * referenced row(s). For rangetypes and multirangetypes this is
     * fk.periodatt <@ range_agg(pk.periodatt). Those are the only types we
     * support for now. FKs will look these up at "runtime", but we should
     * make sure the lookup works here, even if we don't use the values.
     */
    if (with_period)
    {
        Oid         periodoperoid;
        Oid         aggedperiodoperoid;
 
        FindFKPeriodOpers(opclasses[numpks - 1], &periodoperoid, &aggedperiodoperoid);
    }
 
    /*
     * 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,
                                     numfkdelsetcols,
                                     fkdelsetcols,
                                     old_check_ok,
                                     InvalidOid, InvalidOid,
                                     with_period);
 
    /* Now handle the referencing side. */
    addFkRecurseReferencing(wqueue, fkconstraint, rel, pkrel,
                            indexOid,
                            address.objectId,
                            numfks,
                            pkattnum,
                            fkattnum,
                            pfeqoperators,
                            ppeqoperators,
                            ffeqoperators,
                            numfkdelsetcols,
                            fkdelsetcols,
                            old_check_ok,
                            lockmode,
                            InvalidOid, InvalidOid,
                            with_period);
 
    /*
     * Done.  Close pk table, but keep lock until we've committed.
     */
    table_close(pkrel, NoLock);
 
    return address;
}

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

Referenced by ATExecAddConstraint().

ATCheckPartitionsNotInUse()

static void ATCheckPartitionsNotInUse ( Relation  rel, LOCKMODE  lockmode  )

static

Definition at line 6732 of file tablecmds.c.

{
    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_from(cell, inh, 1)
        {
            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);
    }
}

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

Referenced by ATPrepCmd().

ATColumnChangeRequiresRewrite()

static bool ATColumnChangeRequiresRewrite ( Node *  expr, AttrNumber  varattno  )

static

Definition at line 13662 of file tablecmds.c.

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

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

Referenced by ATPrepAlterColumnType().

ATController()

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

static

Definition at line 4778 of file tablecmds.c.

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

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

Referenced by AlterTable(), and AlterTableInternal().

ATDetachCheckNoForeignKeyRefs()

static void ATDetachCheckNoForeignKeyRefs ( Relation  partition )

static

Definition at line 20814 of file tablecmds.c.

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

References Assert, elog, ERROR, GetParentedForeignKeyRefs(), GETSTRUCT, HeapTupleIsValid, InvalidOid, lfirst_oid, 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().

AtEOSubXact_on_commit_actions()

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

Definition at line 18379 of file tablecmds.c.

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

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

Referenced by AbortSubTransaction(), and CommitSubTransaction().

AtEOXact_on_commit_actions()

void AtEOXact_on_commit_actions

(

bool

isCommit

)

Definition at line 18347 of file tablecmds.c.

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

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

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

ATExecAddColumn()

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

static

Definition at line 7081 of file tablecmds.c.

{
    Oid         myrelid = RelationGetRelid(rel);
    ColumnDef  *colDef = castNode(ColumnDef, (*cmd)->def);
    bool        if_not_exists = (*cmd)->missing_ok;
    Relation    pgclass,
                attrdesc;
    HeapTuple   reltup;
    Form_pg_attribute attribute;
    int         newattnum;
    char        relkind;
    Expr       *defval;
    List       *children;
    ListCell   *child;
    AlterTableCmd *childcmd;
    ObjectAddress address;
    TupleDesc   tupdesc;
 
    /* since this function recurses, it could be driven to stack overflow */
    check_stack_depth();
 
    /* At top level, permission check was done in ATPrepCmd, else do it */
    if (recursing)
        ATSimplePermissions((*cmd)->subtype, 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++;
            if (childatt->attinhcount < 0)
                ereport(ERROR,
                        errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
                        errmsg("too many inheritance parents"));
            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);
 
            /* Make the child column change visible */
            CommandCounterIncrement();
 
            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);
    }
 
    /*
     * Regular inheritance children are independent enough not to inherit the
     * identity column from parent hence cannot recursively add identity
     * column if the table has inheritance children.
     *
     * Partitions, on the other hand, are integral part of a partitioned table
     * and inherit identity column.  Hence propagate identity column down the
     * partition hierarchy.
     */
    if (colDef->identity &&
        recurse &&
        rel->rd_rel->relkind != RELKIND_PARTITIONED_TABLE &&
        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)));
 
    /*
     * Construct new attribute's pg_attribute entry.
     */
    tupdesc = BuildDescForRelation(list_make1(colDef));
 
    attribute = TupleDescAttr(tupdesc, 0);
 
    /* Fix up attribute number */
    attribute->attnum = newattnum;
 
    /* make sure datatype is legal for a column */
    CheckAttributeType(NameStr(attribute->attname), attribute->atttypid, attribute->attcollation,
                       list_make1_oid(rel->rd_rel->reltype),
                       0);
 
    InsertPgAttributeTuples(attrdesc, tupdesc, myrelid, NULL, 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))
    {
        /*
         * 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 = attribute->atttypid;
 
            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(attribute->atttypid))
        {
            Oid         baseTypeId;
            int32       baseTypeMod;
            Oid         baseTypeColl;
 
            baseTypeMod = attribute->atttypmod;
            baseTypeId = getBaseTypeAndTypmod(attribute->atttypid, &baseTypeMod);
            baseTypeColl = get_typcollation(baseTypeId);
            defval = (Expr *) makeNullConst(baseTypeId, baseTypeMod, baseTypeColl);
            defval = (Expr *) coerce_to_target_type(NULL,
                                                    (Node *) defval,
                                                    baseTypeId,
                                                    attribute->atttypid,
                                                    attribute->atttypmod,
                                                    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(attribute->atttypid))
            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;
}

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

Referenced by ATExecCmd().

ATExecAddConstraint()

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

static

Definition at line 9612 of file tablecmds.c.

{
    ObjectAddress address = InvalidObjectAddress;
 
    Assert(IsA(newConstraint, Constraint));
 
    /*
     * Currently, we only expect to see CONSTR_CHECK, CONSTR_NOTNULL and
     * CONSTR_FOREIGN nodes arriving here (see the preprocessing done in
     * parse_utilcmd.c).
     */
    switch (newConstraint->contype)
    {
        case CONSTR_CHECK:
        case CONSTR_NOTNULL:
            address =
                ATAddCheckNNConstraint(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,
                                                recurse, false,
                                                lockmode);
            break;
 
        default:
            elog(ERROR, "unrecognized constraint type: %d",
                 (int) newConstraint->contype);
    }
 
    return address;
}

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

Referenced by ATExecCmd().

ATExecAddIdentity()

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

static

Definition at line 8201 of file tablecmds.c.

{
    Relation    attrelation;
    HeapTuple   tuple;
    Form_pg_attribute attTup;
    AttrNumber  attnum;
    ObjectAddress address;
    ColumnDef  *cdef = castNode(ColumnDef, def);
    bool        ispartitioned;
 
    ispartitioned = (rel->rd_rel->relkind == RELKIND_PARTITIONED_TABLE);
    if (ispartitioned && !recurse)
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_TABLE_DEFINITION),
                 errmsg("cannot add identity to a column of only the partitioned table"),
                 errhint("Do not specify the ONLY keyword.")));
 
    if (rel->rd_rel->relispartition && !recursing)
        ereport(ERROR,
                errcode(ERRCODE_INVALID_TABLE_DEFINITION),
                errmsg("cannot add identity to a column of a partition"));
 
    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);
 
    /*
     * Recurse to propagate the identity column to partitions.  Identity is
     * not inherited in regular inheritance children.
     */
    if (recurse && ispartitioned)
    {
        List       *children;
        ListCell   *lc;
 
        children = find_inheritance_children(RelationGetRelid(rel), lockmode);
 
        foreach(lc, children)
        {
            Relation    childrel;
 
            childrel = table_open(lfirst_oid(lc), NoLock);
            ATExecAddIdentity(childrel, colName, def, lockmode, recurse, true);
            table_close(childrel, NoLock);
        }
    }
 
    return address;
}

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

Referenced by ATExecCmd().

ATExecAddIndex()

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

static

Definition at line 9436 of file tablecmds.c.

{
    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 || RelFileNumberIsValid(stmt->oldNumber);
    /* 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 */
                          -1,   /* total_parts unknown */
                          true, /* is_alter_table */
                          check_rights,
                          false,    /* check_not_in_use - we did it already */
                          skip_build,
                          quiet);
 
    /*
     * If TryReuseIndex() stashed a relfilenumber 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 (RelFileNumberIsValid(stmt->oldNumber))
    {
        Relation    irel = index_open(address.objectId, NoLock);
 
        irel->rd_createSubid = stmt->oldCreateSubid;
        irel->rd_firstRelfilelocatorSubid = stmt->oldFirstRelfilelocatorSubid;
        RelationPreserveStorage(irel->rd_locator, true);
        index_close(irel, NoLock);
    }
 
    return address;
}

References Assert, DefineIndex(), index_close(), index_open(), InvalidOid, IsA, NoLock, ObjectAddress::objectId, RelationData::rd_createSubid, RelationData::rd_firstRelfilelocatorSubid, RelationData::rd_locator, RelationGetRelid, RelationPreserveStorage(), RelFileNumberIsValid, AlteredTableInfo::rewrite, and stmt.

Referenced by ATExecCmd().

ATExecAddIndexConstraint()

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

static

Definition at line 9520 of file tablecmds.c.

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

References AccessShareLock, allowSystemTableMods, Assert, BuildIndexInfo(), elog, ereport, errcode(), errmsg(), ERROR, 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(), InvalidOid, IsA, NoLock, NOTICE, OidIsValid, pstrdup(), RelationData::rd_rel, RelationGetRelationName, RenameRelationInternal(), and stmt.

Referenced by ATExecCmd().

ATExecAddInherit()

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

static

Definition at line 16166 of file tablecmds.c.

{
    Relation    parent_rel;
    List       *children;
    ObjectAddress address;
    const char *trigger_name;
 
    /*
     * A self-exclusive lock is needed here.  See the similar case in
     * MergeAttributes() for a full explanation.
     */
    parent_rel = table_openrv(parent, ShareUpdateExclusiveLock);
 
    /*
     * Must be owner of both parent and child -- child was checked by
     * ATSimplePermissions call in ATPrepCmd
     */
    ATSimplePermissions(AT_AddInherit, parent_rel, ATT_TABLE | ATT_FOREIGN_TABLE);
 
    /* Permanent rels cannot inherit from temporary ones */
    if (parent_rel->rd_rel->relpersistence == RELPERSISTENCE_TEMP &&
        child_rel->rd_rel->relpersistence != RELPERSISTENCE_TEMP)
        ereport(ERROR,
                (errcode(ERRCODE_WRONG_OBJECT_TYPE),
                 errmsg("cannot inherit from temporary relation \"%s\"",
                        RelationGetRelationName(parent_rel))));
 
    /* If parent rel is temp, it must belong to this session */
    if (parent_rel->rd_rel->relpersistence == RELPERSISTENCE_TEMP &&
        !parent_rel->rd_islocaltemp)
        ereport(ERROR,
                (errcode(ERRCODE_WRONG_OBJECT_TYPE),
                 errmsg("cannot inherit from temporary relation of another session")));
 
    /* Ditto for the child */
    if (child_rel->rd_rel->relpersistence == RELPERSISTENCE_TEMP &&
        !child_rel->rd_islocaltemp)
        ereport(ERROR,
                (errcode(ERRCODE_WRONG_OBJECT_TYPE),
                 errmsg("cannot inherit to temporary relation of another session")));
 
    /* Prevent partitioned tables from becoming inheritance parents */
    if (parent_rel->rd_rel->relkind == RELKIND_PARTITIONED_TABLE)
        ereport(ERROR,
                (errcode(ERRCODE_WRONG_OBJECT_TYPE),
                 errmsg("cannot inherit from partitioned table \"%s\"",
                        parent->relname)));
 
    /* Likewise for partitions */
    if (parent_rel->rd_rel->relispartition)
        ereport(ERROR,
                (errcode(ERRCODE_WRONG_OBJECT_TYPE),
                 errmsg("cannot inherit from a partition")));
 
    /*
     * Prevent circularity by seeing if proposed parent inherits from child.
     * (In particular, this disallows making a rel inherit from itself.)
     *
     * This is not completely bulletproof because of race conditions: in
     * multi-level inheritance trees, someone else could concurrently be
     * making another inheritance link that closes the loop but does not join
     * either of the rels we have locked.  Preventing that seems to require
     * exclusive locks on the entire inheritance tree, which is a cure worse
     * than the disease.  find_all_inheritors() will cope with circularity
     * anyway, so don't sweat it too much.
     *
     * We use weakest lock we can on child's children, namely AccessShareLock.
     */
    children = find_all_inheritors(RelationGetRelid(child_rel),
                                   AccessShareLock, NULL);
 
    if (list_member_oid(children, RelationGetRelid(parent_rel)))
        ereport(ERROR,
                (errcode(ERRCODE_DUPLICATE_TABLE),
                 errmsg("circular inheritance not allowed"),
                 errdetail("\"%s\" is already a child of \"%s\".",
                           parent->relname,
                           RelationGetRelationName(child_rel))));
 
    /*
     * If child_rel has row-level triggers with transition tables, we
     * currently don't allow it to become an inheritance child.  See also
     * prohibitions in ATExecAttachPartition() and CreateTrigger().
     */
    trigger_name = FindTriggerIncompatibleWithInheritance(child_rel->trigdesc);
    if (trigger_name != NULL)
        ereport(ERROR,
                (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                 errmsg("trigger \"%s\" prevents table \"%s\" from becoming an inheritance child",
                        trigger_name, RelationGetRelationName(child_rel)),
                 errdetail("ROW triggers with transition tables are not supported in inheritance hierarchies.")));
 
    /* OK to create inheritance */
    CreateInheritance(child_rel, parent_rel, false);
 
    /*
     * If parent_rel has a primary key, then child_rel has not-null
     * constraints that make these columns as non nullable.  Make those
     * constraints as inherited.
     */
    ATInheritAdjustNotNulls(parent_rel, child_rel, 1);
 
    ObjectAddressSet(address, RelationRelationId,
                     RelationGetRelid(parent_rel));
 
    /* keep our lock on the parent relation until commit */
    table_close(parent_rel, NoLock);
 
    return address;
}

References AccessShareLock, AT_AddInherit, ATInheritAdjustNotNulls(), ATSimplePermissions(), ATT_FOREIGN_TABLE, ATT_TABLE, CreateInheritance(), ereport, errcode(), errdetail(), errmsg(), ERROR, find_all_inheritors(), FindTriggerIncompatibleWithInheritance(), list_member_oid(), NoLock, ObjectAddressSet, RelationData::rd_islocaltemp, RelationData::rd_rel, RelationGetRelationName, RelationGetRelid, RangeVar::relname, ShareUpdateExclusiveLock, table_close(), table_openrv(), and RelationData::trigdesc.

Referenced by ATExecCmd().

ATExecAddOf()

static ObjectAddress ATExecAddOf ( Relation  rel, const TypeName *  ofTypename, LOCKMODE  lockmode  )

static

Definition at line 17155 of file tablecmds.c.

{
    Oid         relid = RelationGetRelid(rel);
    Type        typetuple;
    Form_pg_type typeform;
    Oid         typeid;
    Relation    inheritsRelation,
                relationRelation;
    SysScanDesc scan;
    ScanKeyData key;
    AttrNumber  table_attno,
                type_attno;
    TupleDesc   typeTupleDesc,
                tableTupleDesc;
    ObjectAddress tableobj,
                typeobj;
    HeapTuple   classtuple;
 
    /* Validate the type. */
    typetuple = typenameType(NULL, ofTypename, NULL);
    check_of_type(typetuple);
    typeform = (Form_pg_type) GETSTRUCT(typetuple);
    typeid = typeform->oid;
 
    /* Fail if the table has any inheritance parents. */
    inheritsRelation = table_open(InheritsRelationId, AccessShareLock);
    ScanKeyInit(&key,
                Anum_pg_inherits_inhrelid,
                BTEqualStrategyNumber, F_OIDEQ,
                ObjectIdGetDatum(relid));
    scan = systable_beginscan(inheritsRelation, InheritsRelidSeqnoIndexId,
                              true, NULL, 1, &key);
    if (HeapTupleIsValid(systable_getnext(scan)))
        ereport(ERROR,
                (errcode(ERRCODE_WRONG_OBJECT_TYPE),
                 errmsg("typed tables cannot inherit")));
    systable_endscan(scan);
    table_close(inheritsRelation, AccessShareLock);
 
    /*
     * Check the tuple descriptors for compatibility.  Unlike inheritance, we
     * require that the order also match.  However, attnotnull need not match.
     */
    typeTupleDesc = lookup_rowtype_tupdesc(typeid, -1);
    tableTupleDesc = RelationGetDescr(rel);
    table_attno = 1;
    for (type_attno = 1; type_attno <= typeTupleDesc->natts; type_attno++)
    {
        Form_pg_attribute type_attr,
                    table_attr;
        const char *type_attname,
                   *table_attname;
 
        /* Get the next non-dropped type attribute. */
        type_attr = TupleDescAttr(typeTupleDesc, type_attno - 1);
        if (type_attr->attisdropped)
            continue;
        type_attname = NameStr(type_attr->attname);
 
        /* Get the next non-dropped table attribute. */
        do
        {
            if (table_attno > tableTupleDesc->natts)
                ereport(ERROR,
                        (errcode(ERRCODE_DATATYPE_MISMATCH),
                         errmsg("table is missing column \"%s\"",
                                type_attname)));
            table_attr = TupleDescAttr(tableTupleDesc, table_attno - 1);
            table_attno++;
        } while (table_attr->attisdropped);
        table_attname = NameStr(table_attr->attname);
 
        /* Compare name. */
        if (strncmp(table_attname, type_attname, NAMEDATALEN) != 0)
            ereport(ERROR,
                    (errcode(ERRCODE_DATATYPE_MISMATCH),
                     errmsg("table has column \"%s\" where type requires \"%s\"",
                            table_attname, type_attname)));
 
        /* Compare type. */
        if (table_attr->atttypid != type_attr->atttypid ||
            table_attr->atttypmod != type_attr->atttypmod ||
            table_attr->attcollation != type_attr->attcollation)
            ereport(ERROR,
                    (errcode(ERRCODE_DATATYPE_MISMATCH),
                     errmsg("table \"%s\" has different type for column \"%s\"",
                            RelationGetRelationName(rel), type_attname)));
    }
    ReleaseTupleDesc(typeTupleDesc);
 
    /* Any remaining columns at the end of the table had better be dropped. */
    for (; table_attno <= tableTupleDesc->natts; table_attno++)
    {
        Form_pg_attribute table_attr = TupleDescAttr(tableTupleDesc,
                                                     table_attno - 1);
 
        if (!table_attr->attisdropped)
            ereport(ERROR,
                    (errcode(ERRCODE_DATATYPE_MISMATCH),
                     errmsg("table has extra column \"%s\"",
                            NameStr(table_attr->attname))));
    }
 
    /* If the table was already typed, drop the existing dependency. */
    if (rel->rd_rel->reloftype)
        drop_parent_dependency(relid, TypeRelationId, rel->rd_rel->reloftype,
                               DEPENDENCY_NORMAL);
 
    /* Record a dependency on the new type. */
    tableobj.classId = RelationRelationId;
    tableobj.objectId = relid;
    tableobj.objectSubId = 0;
    typeobj.classId = TypeRelationId;
    typeobj.objectId = typeid;
    typeobj.objectSubId = 0;
    recordDependencyOn(&tableobj, &typeobj, DEPENDENCY_NORMAL);
 
    /* Update pg_class.reloftype */
    relationRelation = table_open(RelationRelationId, RowExclusiveLock);
    classtuple = SearchSysCacheCopy1(RELOID, ObjectIdGetDatum(relid));
    if (!HeapTupleIsValid(classtuple))
        elog(ERROR, "cache lookup failed for relation %u", relid);
    ((Form_pg_class) GETSTRUCT(classtuple))->reloftype = typeid;
    CatalogTupleUpdate(relationRelation, &classtuple->t_self, classtuple);
 
    InvokeObjectPostAlterHook(RelationRelationId, relid, 0);
 
    heap_freetuple(classtuple);
    table_close(relationRelation, RowExclusiveLock);
 
    ReleaseSysCache(typetuple);
 
    return typeobj;
}

References AccessShareLock, BTEqualStrategyNumber, CatalogTupleUpdate(), check_of_type(), ObjectAddress::classId, DEPENDENCY_NORMAL, drop_parent_dependency(), elog, ereport, errcode(), errmsg(), ERROR, GETSTRUCT, heap_freetuple(), HeapTupleIsValid, InvokeObjectPostAlterHook, sort-test::key, lookup_rowtype_tupdesc(), NAMEDATALEN, NameStr, TupleDescData::natts, ObjectAddress::objectId, ObjectIdGetDatum(), ObjectAddress::objectSubId, RelationData::rd_rel, recordDependencyOn(), RelationGetDescr, RelationGetRelationName, RelationGetRelid, ReleaseSysCache(), ReleaseTupleDesc, RowExclusiveLock, ScanKeyInit(), SearchSysCacheCopy1, systable_beginscan(), systable_endscan(), systable_getnext(), HeapTupleData::t_self, table_close(), table_open(), TupleDescAttr, and typenameType().

Referenced by ATExecCmd().

ATExecAddStatistics()

static ObjectAddress ATExecAddStatistics ( AlteredTableInfo *  tab, Relation  rel, CreateStatsStmt *  stmt, bool  is_rebuild, LOCKMODE  lockmode  )

static

Definition at line 9499 of file tablecmds.c.

{
    ObjectAddress address;
 
    Assert(IsA(stmt, CreateStatsStmt));
 
    /* The CreateStatsStmt has already been through transformStatsStmt */
    Assert(stmt->transformed);
 
    address = CreateStatistics(stmt);
 
    return address;
}

References Assert, CreateStatistics(), IsA, and stmt.

Referenced by ATExecCmd().

ATExecAlterColumnGenericOptions()

static ObjectAddress ATExecAlterColumnGenericOptions ( Relation  rel, const char *  colName, List *  options, LOCKMODE  lockmode  )

static

Definition at line 14865 of file tablecmds.c.

{
    Relation    ftrel;
    Relation    attrel;
    ForeignServer *server;
    ForeignDataWrapper *fdw;
    HeapTuple   tuple;
    HeapTuple   newtuple;
    bool        isnull;
    Datum       repl_val[Natts_pg_attribute];
    bool        repl_null[Natts_pg_attribute];
    bool        repl_repl[Natts_pg_attribute];
    Datum       datum;
    Form_pg_foreign_table fttableform;
    Form_pg_attribute atttableform;
    AttrNumber  attnum;
    ObjectAddress address;
 
    if (options == NIL)
        return InvalidObjectAddress;
 
    /* First, determine FDW validator associated to the foreign table. */
    ftrel = table_open(ForeignTableRelationId, AccessShareLock);
    tuple = SearchSysCache1(FOREIGNTABLEREL, ObjectIdGetDatum(rel->rd_id));
    if (!HeapTupleIsValid(tuple))
        ereport(ERROR,
                (errcode(ERRCODE_UNDEFINED_OBJECT),
                 errmsg("foreign table \"%s\" does not exist",
                        RelationGetRelationName(rel))));
    fttableform = (Form_pg_foreign_table) GETSTRUCT(tuple);
    server = GetForeignServer(fttableform->ftserver);
    fdw = GetForeignDataWrapper(server->fdwid);
 
    table_close(ftrel, AccessShareLock);
    ReleaseSysCache(tuple);
 
    attrel = table_open(AttributeRelationId, RowExclusiveLock);
    tuple = SearchSysCacheAttName(RelationGetRelid(rel), colName);
    if (!HeapTupleIsValid(tuple))
        ereport(ERROR,
                (errcode(ERRCODE_UNDEFINED_COLUMN),
                 errmsg("column \"%s\" of relation \"%s\" does not exist",
                        colName, RelationGetRelationName(rel))));
 
    /* Prevent them from altering a system attribute */
    atttableform = (Form_pg_attribute) GETSTRUCT(tuple);
    attnum = atttableform->attnum;
    if (attnum <= 0)
        ereport(ERROR,
                (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                 errmsg("cannot alter system column \"%s\"", colName)));
 
 
    /* Initialize buffers for new tuple values */
    memset(repl_val, 0, sizeof(repl_val));
    memset(repl_null, false, sizeof(repl_null));
    memset(repl_repl, false, sizeof(repl_repl));
 
    /* Extract the current options */
    datum = SysCacheGetAttr(ATTNAME,
                            tuple,
                            Anum_pg_attribute_attfdwoptions,
                            &isnull);
    if (isnull)
        datum = PointerGetDatum(NULL);
 
    /* Transform the options */
    datum = transformGenericOptions(AttributeRelationId,
                                    datum,
                                    options,
                                    fdw->fdwvalidator);
 
    if (PointerIsValid(DatumGetPointer(datum)))
        repl_val[Anum_pg_attribute_attfdwoptions - 1] = datum;
    else
        repl_null[Anum_pg_attribute_attfdwoptions - 1] = true;
 
    repl_repl[Anum_pg_attribute_attfdwoptions - 1] = true;
 
    /* Everything looks good - update the tuple */
 
    newtuple = heap_modify_tuple(tuple, RelationGetDescr(attrel),
                                 repl_val, repl_null, repl_repl);
 
    CatalogTupleUpdate(attrel, &newtuple->t_self, newtuple);
 
    InvokeObjectPostAlterHook(RelationRelationId,
                              RelationGetRelid(rel),
                              atttableform->attnum);
    ObjectAddressSubSet(address, RelationRelationId,
                        RelationGetRelid(rel), attnum);
 
    ReleaseSysCache(tuple);
 
    table_close(attrel, RowExclusiveLock);
 
    heap_freetuple(newtuple);
 
    return address;
}

References AccessShareLock, attnum, CatalogTupleUpdate(), DatumGetPointer(), ereport, errcode(), errmsg(), ERROR, ForeignServer::fdwid, ForeignDataWrapper::fdwvalidator, GetForeignDataWrapper(), GetForeignServer(), GETSTRUCT, heap_freetuple(), heap_modify_tuple(), HeapTupleIsValid, InvalidObjectAddress, InvokeObjectPostAlterHook, NIL, ObjectAddressSubSet, ObjectIdGetDatum(), PointerGetDatum(), PointerIsValid, RelationData::rd_id, RelationGetDescr, RelationGetRelationName, RelationGetRelid, ReleaseSysCache(), RowExclusiveLock, SearchSysCache1(), SearchSysCacheAttName(), SysCacheGetAttr(), HeapTupleData::t_self, table_close(), table_open(), and transformGenericOptions().

Referenced by ATExecCmd().

ATExecAlterColumnType()

static ObjectAddress ATExecAlterColumnType ( AlteredTableInfo *  tab, Relation  rel, AlterTableCmd *  cmd, LOCKMODE  lockmode  )

static

Definition at line 13709 of file tablecmds.c.

{
    char       *colName = cmd->name;
    ColumnDef  *def = (ColumnDef *) cmd->def;
    TypeName   *typeName = def->typeName;
    HeapTuple   heapTup;
    Form_pg_attribute attTup,
                attOldTup;
    AttrNumber  attnum;
    HeapTuple   typeTuple;
    Form_pg_type tform;
    Oid         targettype;
    int32       targettypmod;
    Oid         targetcollid;
    Node       *defaultexpr;
    Relation    attrelation;
    Relation    depRel;
    ScanKeyData key[3];
    SysScanDesc scan;
    HeapTuple   depTup;
    ObjectAddress address;
 
    /*
     * Clear all the missing values if we're rewriting the table, since this
     * renders them pointless.
     */
    if (tab->rewrite)
    {
        Relation    newrel;
 
        newrel = table_open(RelationGetRelid(rel), NoLock);
        RelationClearMissing(newrel);
        relation_close(newrel, NoLock);
        /* make sure we don't conflict with later attribute modifications */
        CommandCounterIncrement();
    }
 
    attrelation = table_open(AttributeRelationId, RowExclusiveLock);
 
    /* Look up the target column */
    heapTup = SearchSysCacheCopyAttName(RelationGetRelid(rel), colName);
    if (!HeapTupleIsValid(heapTup)) /* shouldn't happen */
        ereport(ERROR,
                (errcode(ERRCODE_UNDEFINED_COLUMN),
                 errmsg("column \"%s\" of relation \"%s\" does not exist",
                        colName, RelationGetRelationName(rel))));
    attTup = (Form_pg_attribute) GETSTRUCT(heapTup);
    attnum = attTup->attnum;
    attOldTup = TupleDescAttr(tab->oldDesc, attnum - 1);
 
    /* Check for multiple ALTER TYPE on same column --- can't cope */
    if (attTup->atttypid != attOldTup->atttypid ||
        attTup->atttypmod != attOldTup->atttypmod)
        ereport(ERROR,
                (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                 errmsg("cannot alter type of column \"%s\" twice",
                        colName)));
 
    /* Look up the target type (should not fail, since prep found it) */
    typeTuple = typenameType(NULL, typeName, &targettypmod);
    tform = (Form_pg_type) GETSTRUCT(typeTuple);
    targettype = tform->oid;
    /* And the collation */
    targetcollid = GetColumnDefCollation(NULL, def, targettype);
 
    /*
     * If there is a default expression for the column, get it and ensure we
     * can coerce it to the new datatype.  (We must do this before changing
     * the column type, because build_column_default itself will try to
     * coerce, and will not issue the error message we want if it fails.)
     *
     * We remove any implicit coercion steps at the top level of the old
     * default expression; this has been agreed to satisfy the principle of
     * least surprise.  (The conversion to the new column type should act like
     * it started from what the user sees as the stored expression, and the
     * implicit coercions aren't going to be shown.)
     */
    if (attTup->atthasdef)
    {
        defaultexpr = build_column_default(rel, attnum);
        Assert(defaultexpr);
        defaultexpr = strip_implicit_coercions(defaultexpr);
        defaultexpr = coerce_to_target_type(NULL,   /* no UNKNOWN params */
                                            defaultexpr, exprType(defaultexpr),
                                            targettype, targettypmod,
                                            COERCION_ASSIGNMENT,
                                            COERCE_IMPLICIT_CAST,
                                            -1);
        if (defaultexpr == NULL)
        {
            if (attTup->attgenerated)
                ereport(ERROR,
                        (errcode(ERRCODE_DATATYPE_MISMATCH),
                         errmsg("generation expression for column \"%s\" cannot be cast automatically to type %s",
                                colName, format_type_be(targettype))));
            else
                ereport(ERROR,
                        (errcode(ERRCODE_DATATYPE_MISMATCH),
                         errmsg("default for column \"%s\" cannot be cast automatically to type %s",
                                colName, format_type_be(targettype))));
        }
    }
    else
        defaultexpr = NULL;
 
    /*
     * Find everything that depends on the column (constraints, indexes, etc),
     * and record enough information to let us recreate the objects.
     *
     * The actual recreation does not happen here, but only after we have
     * performed all the individual ALTER TYPE operations.  We have to save
     * the info before executing ALTER TYPE, though, else the deparser will
     * get confused.
     */
    RememberAllDependentForRebuilding(tab, AT_AlterColumnType, rel, attnum, colName);
 
    /*
     * Now scan for dependencies of this column on other things.  The only
     * things we should find are the dependency on the column datatype and
     * possibly a collation dependency.  Those can be removed.
     */
    depRel = table_open(DependRelationId, RowExclusiveLock);
 
    ScanKeyInit(&key[0],
                Anum_pg_depend_classid,
                BTEqualStrategyNumber, F_OIDEQ,
                ObjectIdGetDatum(RelationRelationId));
    ScanKeyInit(&key[1],
                Anum_pg_depend_objid,
                BTEqualStrategyNumber, F_OIDEQ,
                ObjectIdGetDatum(RelationGetRelid(rel)));
    ScanKeyInit(&key[2],
                Anum_pg_depend_objsubid,
                BTEqualStrategyNumber, F_INT4EQ,
                Int32GetDatum((int32) attnum));
 
    scan = systable_beginscan(depRel, DependDependerIndexId, true,
                              NULL, 3, key);
 
    while (HeapTupleIsValid(depTup = systable_getnext(scan)))
    {
        Form_pg_depend foundDep = (Form_pg_depend) GETSTRUCT(depTup);
        ObjectAddress foundObject;
 
        foundObject.classId = foundDep->refclassid;
        foundObject.objectId = foundDep->refobjid;
        foundObject.objectSubId = foundDep->refobjsubid;
 
        if (foundDep->deptype != DEPENDENCY_NORMAL)
            elog(ERROR, "found unexpected dependency type '%c'",
                 foundDep->deptype);
        if (!(foundDep->refclassid == TypeRelationId &&
              foundDep->refobjid == attTup->atttypid) &&
            !(foundDep->refclassid == CollationRelationId &&
              foundDep->refobjid == attTup->attcollation))
            elog(ERROR, "found unexpected dependency for column: %s",
                 getObjectDescription(&foundObject, false));
 
        CatalogTupleDelete(depRel, &depTup->t_self);
    }
 
    systable_endscan(scan);
 
    table_close(depRel, RowExclusiveLock);
 
    /*
     * Here we go --- change the recorded column type and collation.  (Note
     * heapTup is a copy of the syscache entry, so okay to scribble on.) First
     * fix up the missing value if any.
     */
    if (attTup->atthasmissing)
    {
        Datum       missingval;
        bool        missingNull;
 
        /* if rewrite is true the missing value should already be cleared */
        Assert(tab->rewrite == 0);
 
        /* Get the missing value datum */
        missingval = heap_getattr(heapTup,
                                  Anum_pg_attribute_attmissingval,
                                  attrelation->rd_att,
                                  &missingNull);
 
        /* if it's a null array there is nothing to do */
 
        if (!missingNull)
        {
            /*
             * Get the datum out of the array and repack it in a new array
             * built with the new type data. We assume that since the table
             * doesn't need rewriting, the actual Datum doesn't need to be
             * changed, only the array metadata.
             */
 
            int         one = 1;
            bool        isNull;
            Datum       valuesAtt[Natts_pg_attribute] = {0};
            bool        nullsAtt[Natts_pg_attribute] = {0};
            bool        replacesAtt[Natts_pg_attribute] = {0};
            HeapTuple   newTup;
 
            missingval = array_get_element(missingval,
                                           1,
                                           &one,
                                           0,
                                           attTup->attlen,
                                           attTup->attbyval,
                                           attTup->attalign,
                                           &isNull);
            missingval = PointerGetDatum(construct_array(&missingval,
                                                         1,
                                                         targettype,
                                                         tform->typlen,
                                                         tform->typbyval,
                                                         tform->typalign));
 
            valuesAtt[Anum_pg_attribute_attmissingval - 1] = missingval;
            replacesAtt[Anum_pg_attribute_attmissingval - 1] = true;
            nullsAtt[Anum_pg_attribute_attmissingval - 1] = false;
 
            newTup = heap_modify_tuple(heapTup, RelationGetDescr(attrelation),
                                       valuesAtt, nullsAtt, replacesAtt);
            heap_freetuple(heapTup);
            heapTup = newTup;
            attTup = (Form_pg_attribute) GETSTRUCT(heapTup);
        }
    }
 
    attTup->atttypid = targettype;
    attTup->atttypmod = targettypmod;
    attTup->attcollation = targetcollid;
    if (list_length(typeName->arrayBounds) > PG_INT16_MAX)
        ereport(ERROR,
                errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
                errmsg("too many array dimensions"));
    attTup->attndims = list_length(typeName->arrayBounds);
    attTup->attlen = tform->typlen;
    attTup->attbyval = tform->typbyval;
    attTup->attalign = tform->typalign;
    attTup->attstorage = tform->typstorage;
    attTup->attcompression = InvalidCompressionMethod;
 
    ReleaseSysCache(typeTuple);
 
    CatalogTupleUpdate(attrelation, &heapTup->t_self, heapTup);
 
    table_close(attrelation, RowExclusiveLock);
 
    /* Install dependencies on new datatype and collation */
    add_column_datatype_dependency(RelationGetRelid(rel), attnum, targettype);
    add_column_collation_dependency(RelationGetRelid(rel), attnum, targetcollid);
 
    /*
     * Drop any pg_statistic entry for the column, since it's now wrong type
     */
    RemoveStatistics(RelationGetRelid(rel), attnum);
 
    InvokeObjectPostAlterHook(RelationRelationId,
                              RelationGetRelid(rel), attnum);
 
    /*
     * Update the default, if present, by brute force --- remove and re-add
     * the default.  Probably unsafe to take shortcuts, since the new version
     * may well have additional dependencies.  (It's okay to do this now,
     * rather than after other ALTER TYPE commands, since the default won't
     * depend on other column types.)
     */
    if (defaultexpr)
    {
        /*
         * If it's a GENERATED default, drop its dependency records, in
         * particular its INTERNAL dependency on the column, which would
         * otherwise cause dependency.c to refuse to perform the deletion.
         */
        if (attTup->attgenerated)
        {
            Oid         attrdefoid = GetAttrDefaultOid(RelationGetRelid(rel), attnum);
 
            if (!OidIsValid(attrdefoid))
                elog(ERROR, "could not find attrdef tuple for relation %u attnum %d",
                     RelationGetRelid(rel), attnum);
            (void) deleteDependencyRecordsFor(AttrDefaultRelationId, attrdefoid, false);
        }
 
        /*
         * Make updates-so-far visible, particularly the new pg_attribute row
         * which will be updated again.
         */
        CommandCounterIncrement();
 
        /*
         * We use RESTRICT here for safety, but at present we do not expect
         * anything to depend on the default.
         */
        RemoveAttrDefault(RelationGetRelid(rel), attnum, DROP_RESTRICT, true,
                          true);
 
        StoreAttrDefault(rel, attnum, defaultexpr, true, false);
    }
 
    ObjectAddressSubSet(address, RelationRelationId,
                        RelationGetRelid(rel), attnum);
 
    /* Cleanup */
    heap_freetuple(heapTup);
 
    return address;
}

References add_column_collation_dependency(), add_column_datatype_dependency(), array_get_element(), Assert, AT_AlterColumnType, attnum, BTEqualStrategyNumber, build_column_default(), CatalogTupleDelete(), CatalogTupleUpdate(), ObjectAddress::classId, COERCE_IMPLICIT_CAST, coerce_to_target_type(), COERCION_ASSIGNMENT, CommandCounterIncrement(), construct_array(), AlterTableCmd::def, deleteDependencyRecordsFor(), DEPENDENCY_NORMAL, DROP_RESTRICT, elog, ereport, errcode(), errmsg(), ERROR, exprType(), format_type_be(), GetAttrDefaultOid(), GetColumnDefCollation(), getObjectDescription(), GETSTRUCT, heap_freetuple(), heap_getattr(), heap_modify_tuple(), HeapTupleIsValid, if(), Int32GetDatum(), InvalidCompressionMethod, InvokeObjectPostAlterHook, sort-test::key, list_length(), AlterTableCmd::name, NoLock, ObjectAddressSubSet, ObjectAddress::objectId, ObjectIdGetDatum(), ObjectAddress::objectSubId, OidIsValid, AlteredTableInfo::oldDesc, PG_INT16_MAX, PointerGetDatum(), relation_close(), RelationClearMissing(), RelationGetDescr, RelationGetRelationName, RelationGetRelid, ReleaseSysCache(), RememberAllDependentForRebuilding(), RemoveAttrDefault(), RemoveStatistics(), AlteredTableInfo::rewrite, RowExclusiveLock, ScanKeyInit(), SearchSysCacheCopyAttName(), StoreAttrDefault(), strip_implicit_coercions(), systable_beginscan(), systable_endscan(), systable_getnext(), table_close(), table_open(), TupleDescAttr, ColumnDef::typeName, and typenameType().

Referenced by ATExecCmd().

ATExecAlterConstraint()

static ObjectAddress ATExecAlterConstraint ( Relation  rel, AlterTableCmd *  cmd, bool  recurse, bool  recursing, LOCKMODE  lockmode  )

static

Definition at line 11712 of file tablecmds.c.

{
    Constraint *cmdcon;
    Relation    conrel;
    Relation    tgrel;
    SysScanDesc scan;
    ScanKeyData skey[3];
    HeapTuple   contuple;
    Form_pg_constraint currcon;
    ObjectAddress address;
    List       *otherrelids = NIL;
    ListCell   *lc;
 
    cmdcon = castNode(Constraint, cmd->def);
 
    conrel = table_open(ConstraintRelationId, RowExclusiveLock);
    tgrel = table_open(TriggerRelationId, RowExclusiveLock);
 
    /*
     * Find and check the target constraint
     */
    ScanKeyInit(&skey[0],
                Anum_pg_constraint_conrelid,
                BTEqualStrategyNumber, F_OIDEQ,
                ObjectIdGetDatum(RelationGetRelid(rel)));
    ScanKeyInit(&skey[1],
                Anum_pg_constraint_contypid,
                BTEqualStrategyNumber, F_OIDEQ,
                ObjectIdGetDatum(InvalidOid));
    ScanKeyInit(&skey[2],
                Anum_pg_constraint_conname,
                BTEqualStrategyNumber, F_NAMEEQ,
                CStringGetDatum(cmdcon->conname));
    scan = systable_beginscan(conrel, ConstraintRelidTypidNameIndexId,
                              true, NULL, 3, skey);
 
    /* There can be at most one matching row */
    if (!HeapTupleIsValid(contuple = systable_getnext(scan)))
        ereport(ERROR,
                (errcode(ERRCODE_UNDEFINED_OBJECT),
                 errmsg("constraint \"%s\" of relation \"%s\" does not exist",
                        cmdcon->conname, RelationGetRelationName(rel))));
 
    currcon = (Form_pg_constraint) GETSTRUCT(contuple);
    if (currcon->contype != CONSTRAINT_FOREIGN)
        ereport(ERROR,
                (errcode(ERRCODE_WRONG_OBJECT_TYPE),
                 errmsg("constraint \"%s\" of relation \"%s\" is not a foreign key constraint",
                        cmdcon->conname, RelationGetRelationName(rel))));
 
    /*
     * If it's not the topmost constraint, raise an error.
     *
     * Altering a non-topmost constraint leaves some triggers untouched, since
     * they are not directly connected to this constraint; also, pg_dump would
     * ignore the deferrability status of the individual constraint, since it
     * only dumps topmost constraints.  Avoid these problems by refusing this
     * operation and telling the user to alter the parent constraint instead.
     */
    if (OidIsValid(currcon->conparentid))
    {
        HeapTuple   tp;
        Oid         parent = currcon->conparentid;
        char       *ancestorname = NULL;
        char       *ancestortable = NULL;
 
        /* Loop to find the topmost constraint */
        while (HeapTupleIsValid(tp = SearchSysCache1(CONSTROID, ObjectIdGetDatum(parent))))
        {
            Form_pg_constraint contup = (Form_pg_constraint) GETSTRUCT(tp);
 
            /* If no parent, this is the constraint we want */
            if (!OidIsValid(contup->conparentid))
            {
                ancestorname = pstrdup(NameStr(contup->conname));
                ancestortable = get_rel_name(contup->conrelid);
                ReleaseSysCache(tp);
                break;
            }
 
            parent = contup->conparentid;
            ReleaseSysCache(tp);
        }
 
        ereport(ERROR,
                (errmsg("cannot alter constraint \"%s\" on relation \"%s\"",
                        cmdcon->conname, RelationGetRelationName(rel)),
                 ancestorname && ancestortable ?
                 errdetail("Constraint \"%s\" is derived from constraint \"%s\" of relation \"%s\".",
                           cmdcon->conname, ancestorname, ancestortable) : 0,
                 errhint("You may alter the constraint it derives from instead.")));
    }
 
    /*
     * Do the actual catalog work.  We can skip changing if already in the
     * desired state, but not if a partitioned table: partitions need to be
     * processed regardless, in case they had the constraint locally changed.
     */
    address = InvalidObjectAddress;
    if (currcon->condeferrable != cmdcon->deferrable ||
        currcon->condeferred != cmdcon->initdeferred ||
        rel->rd_rel->relkind == RELKIND_PARTITIONED_TABLE)
    {
        if (ATExecAlterConstrRecurse(cmdcon, conrel, tgrel, rel, contuple,
                                     &otherrelids, lockmode))
            ObjectAddressSet(address, ConstraintRelationId, currcon->oid);
    }
 
    /*
     * ATExecAlterConstrRecurse already invalidated relcache for the relations
     * having the constraint itself; here we also invalidate for relations
     * that have any triggers that are part of the constraint.
     */
    foreach(lc, otherrelids)
        CacheInvalidateRelcacheByRelid(lfirst_oid(lc));
 
    systable_endscan(scan);
 
    table_close(tgrel, RowExclusiveLock);
    table_close(conrel, RowExclusiveLock);
 
    return address;
}

References ATExecAlterConstrRecurse(), BTEqualStrategyNumber, CacheInvalidateRelcacheByRelid(), castNode, Constraint::conname, CStringGetDatum(), AlterTableCmd::def, Constraint::deferrable, ereport, errcode(), errdetail(), errhint(), errmsg(), ERROR, get_rel_name(), GETSTRUCT, HeapTupleIsValid, Constraint::initdeferred, InvalidObjectAddress, InvalidOid, lfirst_oid, NameStr, NIL, ObjectAddressSet, ObjectIdGetDatum(), OidIsValid, pstrdup(), RelationData::rd_rel, RelationGetRelationName, RelationGetRelid, ReleaseSysCache(), RowExclusiveLock, ScanKeyInit(), SearchSysCache1(), systable_beginscan(), systable_endscan(), systable_getnext(), table_close(), and table_open().

Referenced by ATExecCmd().

ATExecAlterConstrRecurse()

static bool ATExecAlterConstrRecurse ( Constraint *  cmdcon, Relation  conrel, Relation  tgrel, Relation  rel, HeapTuple  contuple, List **  otherrelids, LOCKMODE  lockmode  )

static

Definition at line 11849 of file tablecmds.c.

{
    Form_pg_constraint currcon;
    Oid         conoid;
    Oid         refrelid;
    bool        changed = false;
 
    /* since this function recurses, it could be driven to stack overflow */
    check_stack_depth();
 
    currcon = (Form_pg_constraint) GETSTRUCT(contuple);
    conoid = currcon->oid;
    refrelid = currcon->confrelid;
 
    /*
     * Update pg_constraint with the flags from cmdcon.
     *
     * If called to modify a constraint that's already in the desired state,
     * silently do nothing.
     */
    if (currcon->condeferrable != cmdcon->deferrable ||
        currcon->condeferred != cmdcon->initdeferred)
    {
        HeapTuple   copyTuple;
        Form_pg_constraint copy_con;
        HeapTuple   tgtuple;
        ScanKeyData tgkey;
        SysScanDesc tgscan;
 
        copyTuple = heap_copytuple(contuple);
        copy_con = (Form_pg_constraint) GETSTRUCT(copyTuple);
        copy_con->condeferrable = cmdcon->deferrable;
        copy_con->condeferred = cmdcon->initdeferred;
        CatalogTupleUpdate(conrel, &copyTuple->t_self, copyTuple);
 
        InvokeObjectPostAlterHook(ConstraintRelationId,
                                  conoid, 0);
 
        heap_freetuple(copyTuple);
        changed = true;
 
        /* Make new constraint flags visible to others */
        CacheInvalidateRelcache(rel);
 
        /*
         * Now we need to update the multiple entries in pg_trigger that
         * implement the constraint.
         */
        ScanKeyInit(&tgkey,
                    Anum_pg_trigger_tgconstraint,
                    BTEqualStrategyNumber, F_OIDEQ,
                    ObjectIdGetDatum(conoid));
        tgscan = systable_beginscan(tgrel, TriggerConstraintIndexId, true,
                                    NULL, 1, &tgkey);
        while (HeapTupleIsValid(tgtuple = systable_getnext(tgscan)))
        {
            Form_pg_trigger tgform = (Form_pg_trigger) GETSTRUCT(tgtuple);
            Form_pg_trigger copy_tg;
            HeapTuple   tgCopyTuple;
 
            /*
             * Remember OIDs of other relation(s) involved in FK constraint.
             * (Note: it's likely that we could skip forcing a relcache inval
             * for other rels that don't have a trigger whose properties
             * change, but let's be conservative.)
             */
            if (tgform->tgrelid != RelationGetRelid(rel))
                *otherrelids = list_append_unique_oid(*otherrelids,
                                                      tgform->tgrelid);
 
            /*
             * Update deferrability of RI_FKey_noaction_del,
             * RI_FKey_noaction_upd, RI_FKey_check_ins and RI_FKey_check_upd
             * triggers, but not others; see createForeignKeyActionTriggers
             * and CreateFKCheckTrigger.
             */
            if (tgform->tgfoid != F_RI_FKEY_NOACTION_DEL &&
                tgform->tgfoid != F_RI_FKEY_NOACTION_UPD &&
                tgform->tgfoid != F_RI_FKEY_CHECK_INS &&
                tgform->tgfoid != F_RI_FKEY_CHECK_UPD)
                continue;
 
            tgCopyTuple = heap_copytuple(tgtuple);
            copy_tg = (Form_pg_trigger) GETSTRUCT(tgCopyTuple);
 
            copy_tg->tgdeferrable = cmdcon->deferrable;
            copy_tg->tginitdeferred = cmdcon->initdeferred;
            CatalogTupleUpdate(tgrel, &tgCopyTuple->t_self, tgCopyTuple);
 
            InvokeObjectPostAlterHook(TriggerRelationId, tgform->oid, 0);
 
            heap_freetuple(tgCopyTuple);
        }
 
        systable_endscan(tgscan);
    }
 
    /*
     * If the table at either end of the constraint is partitioned, we need to
     * recurse and handle every constraint that is a child of this one.
     *
     * (This assumes that the recurse flag is forcibly set for partitioned
     * tables, and not set for legacy inheritance, though we don't check for
     * that here.)
     */
    if (rel->rd_rel->relkind == RELKIND_PARTITIONED_TABLE ||
        get_rel_relkind(refrelid) == RELKIND_PARTITIONED_TABLE)
    {
        ScanKeyData pkey;
        SysScanDesc pscan;
        HeapTuple   childtup;
 
        ScanKeyInit(&pkey,
                    Anum_pg_constraint_conparentid,
                    BTEqualStrategyNumber, F_OIDEQ,
                    ObjectIdGetDatum(conoid));
 
        pscan = systable_beginscan(conrel, ConstraintParentIndexId,
                                   true, NULL, 1, &pkey);
 
        while (HeapTupleIsValid(childtup = systable_getnext(pscan)))
        {
            Form_pg_constraint childcon = (Form_pg_constraint) GETSTRUCT(childtup);
            Relation    childrel;
 
            childrel = table_open(childcon->conrelid, lockmode);
            ATExecAlterConstrRecurse(cmdcon, conrel, tgrel, childrel, childtup,
                                     otherrelids, lockmode);
            table_close(childrel, NoLock);
        }
 
        systable_endscan(pscan);
    }
 
    return changed;
}

References BTEqualStrategyNumber, CacheInvalidateRelcache(), CatalogTupleUpdate(), check_stack_depth(), Constraint::deferrable, get_rel_relkind(), GETSTRUCT, heap_copytuple(), heap_freetuple(), HeapTupleIsValid, Constraint::initdeferred, InvokeObjectPostAlterHook, list_append_unique_oid(), NoLock, ObjectIdGetDatum(), RelationData::rd_rel, RelationGetRelid, ScanKeyInit(), systable_beginscan(), systable_endscan(), systable_getnext(), HeapTupleData::t_self, table_close(), and table_open().

Referenced by ATExecAlterConstraint().

ATExecAttachPartition()

static ObjectAddress ATExecAttachPartition ( List **  wqueue, Relation  rel, PartitionCmd *  cmd, AlterTableUtilityContext *  context  )

static

Definition at line 19177 of file tablecmds.c.

{
    Relation    attachrel,
                catalog;
    List       *attachrel_children;
    List       *partConstraint;
    SysScanDesc scan;
    ScanKeyData skey;
    AttrNumber  attno;
    int         natts;
    TupleDesc   tupleDesc;
    ObjectAddress address;
    const char *trigger_name;
    Oid         defaultPartOid;
    List       *partBoundConstraint;
    ParseState *pstate = make_parsestate(NULL);
 
    pstate->p_sourcetext = context->queryString;
 
    /*
     * We must lock the default partition if one exists, because attaching a
     * new partition will change its partition constraint.
     */
    defaultPartOid =
        get_default_oid_from_partdesc(RelationGetPartitionDesc(rel, true));
    if (OidIsValid(defaultPartOid))
        LockRelationOid(defaultPartOid, AccessExclusiveLock);
 
    attachrel = table_openrv(cmd->name, AccessExclusiveLock);
 
    /*
     * XXX I think it'd be a good idea to grab locks on all tables referenced
     * by FKs at this point also.
     */
 
    /*
     * Must be owner of both parent and source table -- parent was checked by
     * ATSimplePermissions call in ATPrepCmd
     */
    ATSimplePermissions(AT_AttachPartition, attachrel, ATT_TABLE | ATT_FOREIGN_TABLE);
 
    /* A partition can only have one parent */
    if (attachrel->rd_rel->relispartition)
        ereport(ERROR,
                (errcode(ERRCODE_WRONG_OBJECT_TYPE),
                 errmsg("\"%s\" is already a partition",
                        RelationGetRelationName(attachrel))));
 
    if (OidIsValid(attachrel->rd_rel->reloftype))
        ereport(ERROR,
                (errcode(ERRCODE_WRONG_OBJECT_TYPE),
                 errmsg("cannot attach a typed table as partition")));
 
    /*
     * Table being attached should not already be part of inheritance; either
     * as a child table...
     */
    catalog = table_open(InheritsRelationId, AccessShareLock);
    ScanKeyInit(&skey,
                Anum_pg_inherits_inhrelid,
                BTEqualStrategyNumber, F_OIDEQ,
                ObjectIdGetDatum(RelationGetRelid(attachrel)));
    scan = systable_beginscan(catalog, InheritsRelidSeqnoIndexId, true,
                              NULL, 1, &skey);
    if (HeapTupleIsValid(systable_getnext(scan)))
        ereport(ERROR,
                (errcode(ERRCODE_WRONG_OBJECT_TYPE),
                 errmsg("cannot attach inheritance child as partition")));
    systable_endscan(scan);
 
    /* ...or as a parent table (except the case when it is partitioned) */
    ScanKeyInit(&skey,
                Anum_pg_inherits_inhparent,
                BTEqualStrategyNumber, F_OIDEQ,
                ObjectIdGetDatum(RelationGetRelid(attachrel)));
    scan = systable_beginscan(catalog, InheritsParentIndexId, true, NULL,
                              1, &skey);
    if (HeapTupleIsValid(systable_getnext(scan)) &&
        attachrel->rd_rel->relkind == RELKIND_RELATION)
        ereport(ERROR,
                (errcode(ERRCODE_WRONG_OBJECT_TYPE),
                 errmsg("cannot attach inheritance parent as partition")));
    systable_endscan(scan);
    table_close(catalog, AccessShareLock);
 
    /*
     * Prevent circularity by seeing if rel is a partition of attachrel. (In
     * particular, this disallows making a rel a partition of itself.)
     *
     * We do that by checking if rel is a member of the list of attachrel's
     * partitions provided the latter is partitioned at all.  We want to avoid
     * having to construct this list again, so we request the strongest lock
     * on all partitions.  We need the strongest lock, because we may decide
     * to scan them if we find out that the table being attached (or its leaf
     * partitions) may contain rows that violate the partition constraint. If
     * the table has a constraint that would prevent such rows, which by
     * definition is present in all the partitions, we need not scan the
     * table, nor its partitions.  But we cannot risk a deadlock by taking a
     * weaker lock now and the stronger one only when needed.
     */
    attachrel_children = find_all_inheritors(RelationGetRelid(attachrel),
                                             AccessExclusiveLock, NULL);
    if (list_member_oid(attachrel_children, RelationGetRelid(rel)))
        ereport(ERROR,
                (errcode(ERRCODE_DUPLICATE_TABLE),
                 errmsg("circular inheritance not allowed"),
                 errdetail("\"%s\" is already a child of \"%s\".",
                           RelationGetRelationName(rel),
                           RelationGetRelationName(attachrel))));
 
    /* If the parent is permanent, so must be all of its partitions. */
    if (rel->rd_rel->relpersistence != RELPERSISTENCE_TEMP &&
        attachrel->rd_rel->relpersistence == RELPERSISTENCE_TEMP)
        ereport(ERROR,
                (errcode(ERRCODE_WRONG_OBJECT_TYPE),
                 errmsg("cannot attach a temporary relation as partition of permanent relation \"%s\"",
                        RelationGetRelationName(rel))));
 
    /* Temp parent cannot have a partition that is itself not a temp */
    if (rel->rd_rel->relpersistence == RELPERSISTENCE_TEMP &&
        attachrel->rd_rel->relpersistence != RELPERSISTENCE_TEMP)
        ereport(ERROR,
                (errcode(ERRCODE_WRONG_OBJECT_TYPE),
                 errmsg("cannot attach a permanent relation as partition of temporary relation \"%s\"",
                        RelationGetRelationName(rel))));
 
    /* If the parent is temp, it must belong to this session */
    if (rel->rd_rel->relpersistence == RELPERSISTENCE_TEMP &&
        !rel->rd_islocaltemp)
        ereport(ERROR,
                (errcode(ERRCODE_WRONG_OBJECT_TYPE),
                 errmsg("cannot attach as partition of temporary relation of another session")));
 
    /* Ditto for the partition */
    if (attachrel->rd_rel->relpersistence == RELPERSISTENCE_TEMP &&
        !attachrel->rd_islocaltemp)
        ereport(ERROR,
                (errcode(ERRCODE_WRONG_OBJECT_TYPE),
                 errmsg("cannot attach temporary relation of another session as partition")));
 
    /*
     * Check if attachrel has any identity columns or any columns that aren't
     * in the parent.
     */
    tupleDesc = RelationGetDescr(attachrel);
    natts = tupleDesc->natts;
    for (attno = 1; attno <= natts; attno++)
    {
        Form_pg_attribute attribute = TupleDescAttr(tupleDesc, attno - 1);
        char       *attributeName = NameStr(attribute->attname);
 
        /* Ignore dropped */
        if (attribute->attisdropped)
            continue;
 
        if (attribute->attidentity)
            ereport(ERROR,
                    errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
                    errmsg("table \"%s\" being attached contains an identity column \"%s\"",
                           RelationGetRelationName(attachrel), attributeName),
                    errdetail("The new partition may not contain an identity column."));
 
        /* Try to find the column in parent (matching on column name) */
        if (!SearchSysCacheExists2(ATTNAME,
                                   ObjectIdGetDatum(RelationGetRelid(rel)),
                                   CStringGetDatum(attributeName)))
            ereport(ERROR,
                    (errcode(ERRCODE_DATATYPE_MISMATCH),
                     errmsg("table \"%s\" contains column \"%s\" not found in parent \"%s\"",
                            RelationGetRelationName(attachrel), attributeName,
                            RelationGetRelationName(rel)),
                     errdetail("The new partition may contain only the columns present in parent.")));
    }
 
    /*
     * If child_rel has row-level triggers with transition tables, we
     * currently don't allow it to become a partition.  See also prohibitions
     * in ATExecAddInherit() and CreateTrigger().
     */
    trigger_name = FindTriggerIncompatibleWithInheritance(attachrel->trigdesc);
    if (trigger_name != NULL)
        ereport(ERROR,
                (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                 errmsg("trigger \"%s\" prevents table \"%s\" from becoming a partition",
                        trigger_name, RelationGetRelationName(attachrel)),
                 errdetail("ROW triggers with transition tables are not supported on partitions.")));
 
    /*
     * Check that the new partition's bound is valid and does not overlap any
     * of existing partitions of the parent - note that it does not return on
     * error.
     */
    check_new_partition_bound(RelationGetRelationName(attachrel), rel,
                              cmd->bound, pstate);
 
    /* Attach a new partition to the partitioned table. */
    attachPartitionTable(wqueue, rel, attachrel, cmd->bound);
 
    /*
     * Generate partition constraint from the partition bound specification.
     * If the parent itself is a partition, make sure to include its
     * constraint as well.
     */
    partBoundConstraint = get_qual_from_partbound(rel, cmd->bound);
    partConstraint = list_concat(partBoundConstraint,
                                 RelationGetPartitionQual(rel));
 
    /* Skip validation if there are no constraints to validate. */
    if (partConstraint)
    {
        /*
         * Run the partition quals through const-simplification similar to
         * check constraints.  We skip canonicalize_qual, though, because
         * partition quals should be in canonical form already.
         */
        partConstraint =
            (List *) eval_const_expressions(NULL,
                                            (Node *) partConstraint);
 
        /* XXX this sure looks wrong */
        partConstraint = list_make1(make_ands_explicit(partConstraint));
 
        /*
         * Adjust the generated constraint to match this partition's attribute
         * numbers.
         */
        partConstraint = map_partition_varattnos(partConstraint, 1, attachrel,
                                                 rel);
 
        /* Validate partition constraints against the table being attached. */
        QueuePartitionConstraintValidation(wqueue, attachrel, partConstraint,
                                           false);
    }
 
    /*
     * If we're attaching a partition other than the default partition and a
     * default one exists, then that partition's partition constraint changes,
     * so add an entry to the work queue to validate it, too.  (We must not do
     * this when the partition being attached is the default one; we already
     * did it above!)
     */
    if (OidIsValid(defaultPartOid))
    {
        Relation    defaultrel;
        List       *defPartConstraint;
 
        Assert(!cmd->bound->is_default);
 
        /* we already hold a lock on the default partition */
        defaultrel = table_open(defaultPartOid, NoLock);
        defPartConstraint =
            get_proposed_default_constraint(partBoundConstraint);
 
        /*
         * Map the Vars in the constraint expression from rel's attnos to
         * defaultrel's.
         */
        defPartConstraint =
            map_partition_varattnos(defPartConstraint,
                                    1, defaultrel, rel);
        QueuePartitionConstraintValidation(wqueue, defaultrel,
                                           defPartConstraint, true);
 
        /* keep our lock until commit. */
        table_close(defaultrel, NoLock);
    }
 
    ObjectAddressSet(address, RelationRelationId, RelationGetRelid(attachrel));
 
    /*
     * If the partition we just attached is partitioned itself, invalidate
     * relcache for all descendent partitions too to ensure that their
     * rd_partcheck expression trees are rebuilt; partitions already locked at
     * the beginning of this function.
     */
    if (attachrel->rd_rel->relkind == RELKIND_PARTITIONED_TABLE)
    {
        ListCell   *l;
 
        foreach(l, attachrel_children)
        {
            CacheInvalidateRelcacheByRelid(lfirst_oid(l));
        }
    }
 
    /* keep our lock until commit */
    table_close(attachrel, NoLock);
 
    return address;
}

References AccessExclusiveLock, AccessShareLock, Assert, AT_AttachPartition, ATSimplePermissions(), ATT_FOREIGN_TABLE, ATT_TABLE, attachPartitionTable(), PartitionCmd::bound, BTEqualStrategyNumber, CacheInvalidateRelcacheByRelid(), check_new_partition_bound(), context, CStringGetDatum(), ereport, errcode(), errdetail(), errmsg(), ERROR, eval_const_expressions(), find_all_inheritors(), FindTriggerIncompatibleWithInheritance(), get_default_oid_from_partdesc(), get_proposed_default_constraint(), get_qual_from_partbound(), HeapTupleIsValid, PartitionBoundSpec::is_default, lfirst_oid, list_concat(), list_make1, list_member_oid(), LockRelationOid(), make_ands_explicit(), make_parsestate(), map_partition_varattnos(), PartitionCmd::name, NameStr, TupleDescData::natts, NoLock, ObjectAddressSet, ObjectIdGetDatum(), OidIsValid, ParseState::p_sourcetext, QueuePartitionConstraintValidation(), RelationData::rd_islocaltemp, RelationData::rd_rel, RelationGetDescr, RelationGetPartitionDesc(), RelationGetPartitionQual(), RelationGetRelationName, RelationGetRelid, ScanKeyInit(), SearchSysCacheExists2, systable_beginscan(), systable_endscan(), systable_getnext(), table_close(), table_open(), table_openrv(), RelationData::trigdesc, and TupleDescAttr.

Referenced by ATExecCmd().

ATExecAttachPartitionIdx()

static ObjectAddress ATExecAttachPartitionIdx ( List **  wqueue, Relation  parentIdx, RangeVar *  name  )

static

Definition at line 20452 of file tablecmds.c.

{
    Relation    partIdx;
    Relation    partTbl;
    Relation    parentTbl;
    ObjectAddress address;
    Oid         partIdxId;
    Oid         currParent;
    struct AttachIndexCallbackState state;
 
    /*
     * We need to obtain lock on the index 'name' to modify it, but we also
     * need to read its owning table's tuple descriptor -- so we need to lock
     * both.  To avoid deadlocks, obtain lock on the table before doing so on
     * the index.  Furthermore, we need to examine the parent table of the
     * partition, so lock that one too.
     */
    state.partitionOid = InvalidOid;
    state.parentTblOid = parentIdx->rd_index->indrelid;
    state.lockedParentTbl = false;
    partIdxId =
        RangeVarGetRelidExtended(name, AccessExclusiveLock, 0,
                                 RangeVarCallbackForAttachIndex,
                                 (void *) &state);
    /* Not there? */
    if (!OidIsValid(partIdxId))
        ereport(ERROR,
                (errcode(ERRCODE_UNDEFINED_OBJECT),
                 errmsg("index \"%s\" does not exist", name->relname)));
 
    /* no deadlock risk: RangeVarGetRelidExtended already acquired the lock */
    partIdx = relation_open(partIdxId, AccessExclusiveLock);
 
    /* we already hold locks on both tables, so this is safe: */
    parentTbl = relation_open(parentIdx->rd_index->indrelid, AccessShareLock);
    partTbl = relation_open(partIdx->rd_index->indrelid, NoLock);
 
    ObjectAddressSet(address, RelationRelationId, RelationGetRelid(partIdx));
 
    /* Silently do nothing if already in the right state */
    currParent = partIdx->rd_rel->relispartition ?
        get_partition_parent(partIdxId, false) : InvalidOid;
    if (currParent != RelationGetRelid(parentIdx))
    {
        IndexInfo  *childInfo;
        IndexInfo  *parentInfo;
        AttrMap    *attmap;
        bool        found;
        int         i;
        PartitionDesc partDesc;
        Oid         constraintOid,
                    cldConstrId = InvalidOid;
 
        /*
         * If this partition already has an index attached, refuse the
         * operation.
         */
        refuseDupeIndexAttach(parentIdx, partIdx, partTbl);
 
        if (OidIsValid(currParent))
            ereport(ERROR,
                    (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
                     errmsg("cannot attach index \"%s\" as a partition of index \"%s\"",
                            RelationGetRelationName(partIdx),
                            RelationGetRelationName(parentIdx)),
                     errdetail("Index \"%s\" is already attached to another index.",
                               RelationGetRelationName(partIdx))));
 
        /* Make sure it indexes a partition of the other index's table */
        partDesc = RelationGetPartitionDesc(parentTbl, true);
        found = false;
        for (i = 0; i < partDesc->nparts; i++)
        {
            if (partDesc->oids[i] == state.partitionOid)
            {
                found = true;
                break;
            }
        }
        if (!found)
            ereport(ERROR,
                    (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
                     errmsg("cannot attach index \"%s\" as a partition of index \"%s\"",
                            RelationGetRelationName(partIdx),
                            RelationGetRelationName(parentIdx)),
                     errdetail("Index \"%s\" is not an index on any partition of table \"%s\".",
                               RelationGetRelationName(partIdx),
                               RelationGetRelationName(parentTbl))));
 
        /* Ensure the indexes are compatible */
        childInfo = BuildIndexInfo(partIdx);
        parentInfo = BuildIndexInfo(parentIdx);
        attmap = build_attrmap_by_name(RelationGetDescr(partTbl),
                                       RelationGetDescr(parentTbl),
                                       false);
        if (!CompareIndexInfo(childInfo, parentInfo,
                              partIdx->rd_indcollation,
                              parentIdx->rd_indcollation,
                              partIdx->rd_opfamily,
                              parentIdx->rd_opfamily,
                              attmap))
            ereport(ERROR,
                    (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
                     errmsg("cannot attach index \"%s\" as a partition of index \"%s\"",
                            RelationGetRelationName(partIdx),
                            RelationGetRelationName(parentIdx)),
                     errdetail("The index definitions do not match.")));
 
        /*
         * If there is a constraint in the parent, make sure there is one in
         * the child too.
         */
        constraintOid = get_relation_idx_constraint_oid(RelationGetRelid(parentTbl),
                                                        RelationGetRelid(parentIdx));
 
        if (OidIsValid(constraintOid))
        {
            cldConstrId = get_relation_idx_constraint_oid(RelationGetRelid(partTbl),
                                                          partIdxId);
            if (!OidIsValid(cldConstrId))
                ereport(ERROR,
                        (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
                         errmsg("cannot attach index \"%s\" as a partition of index \"%s\"",
                                RelationGetRelationName(partIdx),
                                RelationGetRelationName(parentIdx)),
                         errdetail("The index \"%s\" belongs to a constraint in table \"%s\" but no constraint exists for index \"%s\".",
                                   RelationGetRelationName(parentIdx),
                                   RelationGetRelationName(parentTbl),
                                   RelationGetRelationName(partIdx))));
        }
 
        /*
         * If it's a primary key, make sure the columns in the partition are
         * NOT NULL.
         */
        if (parentIdx->rd_index->indisprimary)
            verifyPartitionIndexNotNull(childInfo, partTbl);
 
        /* All good -- do it */
        IndexSetParentIndex(partIdx, RelationGetRelid(parentIdx));
        if (OidIsValid(constraintOid))
            ConstraintSetParentConstraint(cldConstrId, constraintOid,
                                          RelationGetRelid(partTbl));
 
        free_attrmap(attmap);
 
        validatePartitionedIndex(parentIdx, parentTbl);
    }
 
    relation_close(parentTbl, AccessShareLock);
    /* keep these locks till commit */
    relation_close(partTbl, NoLock);
    relation_close(partIdx, NoLock);
 
    return address;
}

References AccessExclusiveLock, AccessShareLock, build_attrmap_by_name(), BuildIndexInfo(), CompareIndexInfo(), ConstraintSetParentConstraint(), ereport, errcode(), errdetail(), errmsg(), ERROR, free_attrmap(), get_partition_parent(), get_relation_idx_constraint_oid(), i, IndexSetParentIndex(), InvalidOid, name, NoLock, PartitionDescData::nparts, ObjectAddressSet, OidIsValid, PartitionDescData::oids, RangeVarCallbackForAttachIndex(), RangeVarGetRelidExtended(), RelationData::rd_indcollation, RelationData::rd_index, RelationData::rd_opfamily, RelationData::rd_rel, refuseDupeIndexAttach(), relation_close(), relation_open(), RelationGetDescr, RelationGetPartitionDesc(), RelationGetRelationName, RelationGetRelid, validatePartitionedIndex(), and verifyPartitionIndexNotNull().

Referenced by ATExecCmd().

ATExecChangeOwner()

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

Definition at line 14982 of file tablecmds.c.

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

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

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

ATExecClusterOn()

static ObjectAddress ATExecClusterOn ( Relation  rel, const char *  indexName, LOCKMODE  lockmode  )

static

Definition at line 15357 of file tablecmds.c.

{
    Oid         indexOid;
    ObjectAddress address;
 
    indexOid = get_relname_relid(indexName, rel->rd_rel->relnamespace);
 
    if (!OidIsValid(indexOid))
        ereport(ERROR,
                (errcode(ERRCODE_UNDEFINED_OBJECT),
                 errmsg("index \"%s\" for table \"%s\" does not exist",
                        indexName, RelationGetRelationName(rel))));
 
    /* Check index is valid to cluster on */
    check_index_is_clusterable(rel, indexOid, lockmode);
 
    /* And do the work */
    mark_index_clustered(rel, indexOid, false);
 
    ObjectAddressSet(address,
                     RelationRelationId, indexOid);
 
    return address;
}

References check_index_is_clusterable(), ereport, errcode(), errmsg(), ERROR, get_relname_relid(), mark_index_clustered(), ObjectAddressSet, OidIsValid, RelationData::rd_rel, and RelationGetRelationName.

Referenced by ATExecCmd().

ATExecCmd()

static void ATExecCmd ( List **  wqueue, AlteredTableInfo *  tab, AlterTableCmd *  cmd, LOCKMODE  lockmode, AlterTablePass  cur_pass, AlterTableUtilityContext *  context  )

static

Definition at line 5278 of file tablecmds.c.

{
    ObjectAddress address = InvalidObjectAddress;
    Relation    rel = tab->rel;
 
    switch (cmd->subtype)
    {
        case AT_AddColumn:      /* ADD COLUMN */
        case AT_AddColumnToView:    /* add column via CREATE OR REPLACE VIEW */
            address = ATExecAddColumn(wqueue, tab, rel, &cmd,
                                      cmd->recurse, false,
                                      lockmode, cur_pass, context);
            break;
        case AT_ColumnDefault:  /* ALTER COLUMN DEFAULT */
            address = ATExecColumnDefault(rel, cmd->name, cmd->def, lockmode);
            break;
        case AT_CookedColumnDefault:    /* add a pre-cooked default */
            address = ATExecCookedColumnDefault(rel, cmd->num, cmd->def);
            break;
        case AT_AddIdentity:
            cmd = ATParseTransformCmd(wqueue, tab, rel, cmd, false, lockmode,
                                      cur_pass, context);
            Assert(cmd != NULL);
            address = ATExecAddIdentity(rel, cmd->name, cmd->def, lockmode, cmd->recurse, false);
            break;
        case AT_SetIdentity:
            cmd = ATParseTransformCmd(wqueue, tab, rel, cmd, false, lockmode,
                                      cur_pass, context);
            Assert(cmd != NULL);
            address = ATExecSetIdentity(rel, cmd->name, cmd->def, lockmode, cmd->recurse, false);
            break;
        case AT_DropIdentity:
            address = ATExecDropIdentity(rel, cmd->name, cmd->missing_ok, lockmode, cmd->recurse, false);
            break;
        case AT_DropNotNull:    /* ALTER COLUMN DROP NOT NULL */
            address = ATExecDropNotNull(rel, cmd->name, cmd->recurse, lockmode);
            break;
        case AT_SetNotNull:     /* ALTER COLUMN SET NOT NULL */
            address = ATExecSetNotNull(wqueue, rel, NULL, cmd->name,
                                       cmd->recurse, false, NULL, lockmode);
            break;
        case AT_SetAttNotNull:  /* set pg_attribute.attnotnull */
            address = ATExecSetAttNotNull(wqueue, rel, cmd->name, lockmode);
            break;
        case AT_SetExpression:
            address = ATExecSetExpression(tab, rel, cmd->name, cmd->def, lockmode);
            break;
        case AT_DropExpression:
            address = ATExecDropExpression(rel, cmd->name, cmd->missing_ok, lockmode);
            break;
        case AT_SetStatistics:  /* ALTER COLUMN SET STATISTICS */
            address = ATExecSetStatistics(rel, cmd->name, cmd->num, cmd->def, lockmode);
            break;
        case AT_SetOptions:     /* ALTER COLUMN SET ( options ) */
            address = ATExecSetOptions(rel, cmd->name, cmd->def, false, lockmode);
            break;
        case AT_ResetOptions:   /* ALTER COLUMN RESET ( options ) */
            address = ATExecSetOptions(rel, cmd->name, cmd->def, true, lockmode);
            break;
        case AT_SetStorage:     /* ALTER COLUMN SET STORAGE */
            address = ATExecSetStorage(rel, cmd->name, cmd->def, lockmode);
            break;
        case AT_SetCompression: /* ALTER COLUMN SET COMPRESSION */
            address = ATExecSetCompression(rel, cmd->name, cmd->def,
                                           lockmode);
            break;
        case AT_DropColumn:     /* DROP COLUMN */
            address = ATExecDropColumn(wqueue, rel, cmd->name,
                                       cmd->behavior, cmd->recurse, false,
                                       cmd->missing_ok, lockmode,
                                       NULL);
            break;
        case AT_AddIndex:       /* ADD INDEX */
            address = ATExecAddIndex(tab, rel, (IndexStmt *) cmd->def, false,
                                     lockmode);
            break;
        case AT_ReAddIndex:     /* ADD INDEX */
            address = ATExecAddIndex(tab, rel, (IndexStmt *) cmd->def, true,
                                     lockmode);
            break;
        case AT_ReAddStatistics:    /* ADD STATISTICS */
            address = ATExecAddStatistics(tab, rel, (CreateStatsStmt *) cmd->def,
                                          true, lockmode);
            break;
        case AT_AddConstraint:  /* ADD CONSTRAINT */
            /* Transform the command only during initial examination */
            if (cur_pass == AT_PASS_ADD_CONSTR)
                cmd = ATParseTransformCmd(wqueue, tab, rel, cmd,
                                          cmd->recurse, lockmode,
                                          cur_pass, context);
            /* Depending on constraint type, might be no more work to do now */
            if (cmd != NULL)
                address =
                    ATExecAddConstraint(wqueue, tab, rel,
                                        (Constraint *) cmd->def,
                                        cmd->recurse, false, lockmode);
            break;
        case AT_ReAddConstraint:    /* Re-add pre-existing check constraint */
            address =
                ATExecAddConstraint(wqueue, tab, rel, (Constraint *) cmd->def,
                                    true, true, lockmode);
            break;
        case AT_ReAddDomainConstraint:  /* Re-add pre-existing domain check
                                         * constraint */
            address =
                AlterDomainAddConstraint(((AlterDomainStmt *) cmd->def)->typeName,
                                         ((AlterDomainStmt *) cmd->def)->def,
                                         NULL);
            break;
        case AT_ReAddComment:   /* Re-add existing comment */
            address = CommentObject((CommentStmt *) cmd->def);
            break;
        case AT_AddIndexConstraint: /* ADD CONSTRAINT USING INDEX */
            address = ATExecAddIndexConstraint(tab, rel, (IndexStmt *) cmd->def,
                                               lockmode);
            break;
        case AT_AlterConstraint:    /* ALTER CONSTRAINT */
            address = ATExecAlterConstraint(rel, cmd, false, false, lockmode);
            break;
        case AT_ValidateConstraint: /* VALIDATE CONSTRAINT */
            address = ATExecValidateConstraint(wqueue, rel, cmd->name, cmd->recurse,
                                               false, lockmode);
            break;
        case AT_DropConstraint: /* DROP CONSTRAINT */
            ATExecDropConstraint(rel, cmd->name, cmd->behavior,
                                 cmd->recurse,
                                 cmd->missing_ok, lockmode);
            break;
        case AT_AlterColumnType:    /* ALTER COLUMN TYPE */
            /* parse transformation was done earlier */
            address = ATExecAlterColumnType(tab, rel, cmd, lockmode);
            break;
        case AT_AlterColumnGenericOptions:  /* ALTER COLUMN OPTIONS */
            address =
                ATExecAlterColumnGenericOptions(rel, cmd->name,
                                                (List *) cmd->def, lockmode);
            break;
        case AT_ChangeOwner:    /* ALTER OWNER */
            ATExecChangeOwner(RelationGetRelid(rel),
                              get_rolespec_oid(cmd->newowner, false),
                              false, lockmode);
            break;
        case AT_ClusterOn:      /* CLUSTER ON */
            address = ATExecClusterOn(rel, cmd->name, lockmode);
            break;
        case AT_DropCluster:    /* SET WITHOUT CLUSTER */
            ATExecDropCluster(rel, lockmode);
            break;
        case AT_SetLogged:      /* SET LOGGED */
        case AT_SetUnLogged:    /* SET UNLOGGED */
            break;
        case AT_DropOids:       /* SET WITHOUT OIDS */
            /* nothing to do here, oid columns don't exist anymore */
            break;
        case AT_SetAccessMethod:    /* SET ACCESS METHOD */
 
            /*
             * Only do this for partitioned tables, for which this is just a
             * catalog change.  Tables with storage are handled by Phase 3.
             */
            if (rel->rd_rel->relkind == RELKIND_PARTITIONED_TABLE &&
                tab->chgAccessMethod)
                ATExecSetAccessMethodNoStorage(rel, tab->newAccessMethod);
            break;
        case AT_SetTableSpace:  /* SET TABLESPACE */
 
            /*
             * Only do this for partitioned tables and indexes, for which this
             * is just a catalog change.  Other relation types which have
             * storage are handled by Phase 3.
             */
            if (rel->rd_rel->relkind == RELKIND_PARTITIONED_TABLE ||
                rel->rd_rel->relkind == RELKIND_PARTITIONED_INDEX)
                ATExecSetTableSpaceNoStorage(rel, tab->newTableSpace);
 
            break;
        case AT_SetRelOptions:  /* SET (...) */
        case AT_ResetRelOptions:    /* RESET (...) */
        case AT_ReplaceRelOptions:  /* replace entire option list */
            ATExecSetRelOptions(rel, (List *) cmd->def, cmd->subtype, lockmode);
            break;
        case AT_EnableTrig:     /* ENABLE TRIGGER name */
            ATExecEnableDisableTrigger(rel, cmd->name,
                                       TRIGGER_FIRES_ON_ORIGIN, false,
                                       cmd->recurse,
                                       lockmode);
            break;
        case AT_EnableAlwaysTrig:   /* ENABLE ALWAYS TRIGGER name */
            ATExecEnableDisableTrigger(rel, cmd->name,
                                       TRIGGER_FIRES_ALWAYS, false,
                                       cmd->recurse,
                                       lockmode);
            break;
        case AT_EnableReplicaTrig:  /* ENABLE REPLICA TRIGGER name */
            ATExecEnableDisableTrigger(rel, cmd->name,
                                       TRIGGER_FIRES_ON_REPLICA, false,
                                       cmd->recurse,
                                       lockmode);
            break;
        case AT_DisableTrig:    /* DISABLE TRIGGER name */
            ATExecEnableDisableTrigger(rel, cmd->name,
                                       TRIGGER_DISABLED, false,
                                       cmd->recurse,
                                       lockmode);
            break;
        case AT_EnableTrigAll:  /* ENABLE TRIGGER ALL */
            ATExecEnableDisableTrigger(rel, NULL,
                                       TRIGGER_FIRES_ON_ORIGIN, false,
                                       cmd->recurse,
                                       lockmode);
            break;
        case AT_DisableTrigAll: /* DISABLE TRIGGER ALL */
            ATExecEnableDisableTrigger(rel, NULL,
                                       TRIGGER_DISABLED, false,
                                       cmd->recurse,
                                       lockmode);
            break;
        case AT_EnableTrigUser: /* ENABLE TRIGGER USER */
            ATExecEnableDisableTrigger(rel, NULL,
                                       TRIGGER_FIRES_ON_ORIGIN, true,
                                       cmd->recurse,
                                       lockmode);
            break;
        case AT_DisableTrigUser:    /* DISABLE TRIGGER USER */
            ATExecEnableDisableTrigger(rel, NULL,
                                       TRIGGER_DISABLED, true,
                                       cmd->recurse,
                                       lockmode);
            break;
 
        case AT_EnableRule:     /* ENABLE RULE name */
            ATExecEnableDisableRule(rel, cmd->name,
                                    RULE_FIRES_ON_ORIGIN, lockmode);
            break;
        case AT_EnableAlwaysRule:   /* ENABLE ALWAYS RULE name */
            ATExecEnableDisableRule(rel, cmd->name,
                                    RULE_FIRES_ALWAYS, lockmode);
            break;
        case AT_EnableReplicaRule:  /* ENABLE REPLICA RULE name */
            ATExecEnableDisableRule(rel, cmd->name,
                                    RULE_FIRES_ON_REPLICA, lockmode);
            break;
        case AT_DisableRule:    /* DISABLE RULE name */
            ATExecEnableDisableRule(rel, cmd->name,
                                    RULE_DISABLED, lockmode);
            break;
 
        case AT_AddInherit:
            address = ATExecAddInherit(rel, (RangeVar *) cmd->def, lockmode);
            break;
        case AT_DropInherit:
            address = ATExecDropInherit(rel, (RangeVar *) cmd->def, lockmode);
            break;
        case AT_AddOf:
            address = ATExecAddOf(rel, (TypeName *) cmd->def, lockmode);
            break;
        case AT_DropOf:
            ATExecDropOf(rel, lockmode);
            break;
        case AT_ReplicaIdentity:
            ATExecReplicaIdentity(rel, (ReplicaIdentityStmt *) cmd->def, lockmode);
            break;
        case AT_EnableRowSecurity:
            ATExecSetRowSecurity(rel, true);
            break;
        case AT_DisableRowSecurity:
            ATExecSetRowSecurity(rel, false);
            break;
        case AT_ForceRowSecurity:
            ATExecForceNoForceRowSecurity(rel, true);
            break;
        case AT_NoForceRowSecurity:
            ATExecForceNoForceRowSecurity(rel, false);
            break;
        case AT_GenericOptions:
            ATExecGenericOptions(rel, (List *) cmd->def);
            break;
        case AT_AttachPartition:
            cmd = ATParseTransformCmd(wqueue, tab, rel, cmd, false, lockmode,
                                      cur_pass, context);
            Assert(cmd != NULL);
            if (rel->rd_rel->relkind == RELKIND_PARTITIONED_TABLE)
                address = ATExecAttachPartition(wqueue, rel, (PartitionCmd *) cmd->def,
                                                context);
            else
                address = ATExecAttachPartitionIdx(wqueue, rel,
                                                   ((PartitionCmd *) cmd->def)->name);
            break;
        case AT_DetachPartition:
            cmd = ATParseTransformCmd(wqueue, tab, rel, cmd, false, lockmode,
                                      cur_pass, context);
            Assert(cmd != NULL);
            /* ATPrepCmd ensures it must be a table */
            Assert(rel->rd_rel->relkind == RELKIND_PARTITIONED_TABLE);
            address = ATExecDetachPartition(wqueue, tab, rel,
                                            ((PartitionCmd *) cmd->def)->name,
                                            ((PartitionCmd *) cmd->def)->concurrent);
            break;
        case AT_DetachPartitionFinalize:
            address = ATExecDetachPartitionFinalize(rel, ((PartitionCmd *) cmd->def)->name);
            break;
        case AT_SplitPartition:
            cmd = ATParseTransformCmd(wqueue, tab, rel, cmd, false, lockmode,
                                      cur_pass, context);
            Assert(cmd != NULL);
            Assert(rel->rd_rel->relkind == RELKIND_PARTITIONED_TABLE);
            ATExecSplitPartition(wqueue, tab, rel, (PartitionCmd *) cmd->def,
                                 context);
            break;
        case AT_MergePartitions:
            cmd = ATParseTransformCmd(wqueue, tab, rel, cmd, false, lockmode,
                                      cur_pass, context);
            Assert(cmd != NULL);
            Assert(rel->rd_rel->relkind == RELKIND_PARTITIONED_TABLE);
            ATExecMergePartitions(wqueue, tab, rel, (PartitionCmd *) cmd->def,
                                  context);
            break;
        default:                /* oops */
            elog(ERROR, "unrecognized alter table type: %d",
                 (int) cmd->subtype);
            break;
    }
 
    /*
     * Report the subcommand to interested event triggers.
     */
    if (cmd)
        EventTriggerCollectAlterTableSubcmd((Node *) cmd, address);
 
    /*
     * Bump the command counter to ensure the next subcommand in the sequence
     * can see the changes so far
     */
    CommandCounterIncrement();
}

References AlterDomainAddConstraint(), Assert, AT_AddColumn, AT_AddColumnToView, AT_AddConstraint, AT_AddIdentity, AT_AddIndex, AT_AddIndexConstraint, AT_AddInherit, AT_AddOf, AT_AlterColumnGenericOptions, AT_AlterColumnType, AT_AlterConstraint, AT_AttachPartition, AT_ChangeOwner, AT_ClusterOn, AT_ColumnDefault, AT_CookedColumnDefault, AT_DetachPartition, AT_DetachPartitionFinalize, AT_DisableRowSecurity, AT_DisableRule, AT_DisableTrig, AT_DisableTrigAll, AT_DisableTrigUser, AT_DropCluster, AT_DropColumn, AT_DropConstraint, AT_DropExpression, AT_DropIdentity, AT_DropInherit, AT_DropNotNull, AT_DropOf, AT_DropOids, AT_EnableAlwaysRule, AT_EnableAlwaysTrig, AT_EnableReplicaRule, AT_EnableReplicaTrig, AT_EnableRowSecurity, AT_EnableRule, AT_EnableTrig, AT_EnableTrigAll, AT_EnableTrigUser, AT_ForceRowSecurity, AT_GenericOptions, AT_MergePartitions, AT_NoForceRowSecurity, AT_PASS_ADD_CONSTR, AT_ReAddComment, AT_ReAddConstraint, AT_ReAddDomainConstraint, AT_ReAddIndex, AT_ReAddStatistics, AT_ReplaceRelOptions, AT_ReplicaIdentity, AT_ResetOptions, AT_ResetRelOptions, AT_SetAccessMethod, AT_SetAttNotNull, AT_SetCompression, AT_SetExpression, AT_SetIdentity, AT_SetLogged, AT_SetNotNull, AT_SetOptions, AT_SetRelOptions, AT_SetStatistics, AT_SetStorage, AT_SetTableSpace, AT_SetUnLogged, AT_SplitPartition, AT_ValidateConstraint, ATExecAddColumn(), ATExecAddConstraint(), ATExecAddIdentity(), ATExecAddIndex(), ATExecAddIndexConstraint(), ATExecAddInherit(), ATExecAddOf(), ATExecAddStatistics(), ATExecAlterColumnGenericOptions(), ATExecAlterColumnType(), ATExecAlterConstraint(), ATExecAttachPartition(), ATExecAttachPartitionIdx(), ATExecChangeOwner(), ATExecClusterOn(), ATExecColumnDefault(), ATExecCookedColumnDefault(), ATExecDetachPartition(), ATExecDetachPartitionFinalize(), ATExecDropCluster(), ATExecDropColumn(), ATExecDropConstraint(), ATExecDropExpression(), ATExecDropIdentity(), ATExecDropInherit(), ATExecDropNotNull(), ATExecDropOf(), ATExecEnableDisableRule(), ATExecEnableDisableTrigger(), ATExecForceNoForceRowSecurity(), ATExecGenericOptions(), ATExecMergePartitions(), ATExecReplicaIdentity(), ATExecSetAccessMethodNoStorage(), ATExecSetAttNotNull(), ATExecSetCompression(), ATExecSetExpression(), ATExecSetIdentity(), ATExecSetNotNull(), ATExecSetOptions(), ATExecSetRelOptions(), ATExecSetRowSecurity(), ATExecSetStatistics(), ATExecSetStorage(), ATExecSetTableSpaceNoStorage(), ATExecSplitPartition(), ATExecValidateConstraint(), ATParseTransformCmd(), AlterTableCmd::behavior, AlteredTableInfo::chgAccessMethod, CommandCounterIncrement(), CommentObject(), context, AlterTableCmd::def, elog, ERROR, EventTriggerCollectAlterTableSubcmd(), get_rolespec_oid(), InvalidObjectAddress, AlterTableCmd::missing_ok, AlterTableCmd::name, AlteredTableInfo::newAccessMethod, AlterTableCmd::newowner, AlteredTableInfo::newTableSpace, AlterTableCmd::num, RelationData::rd_rel, AlterTableCmd::recurse, AlteredTableInfo::rel, RelationGetRelid, RULE_DISABLED, RULE_FIRES_ALWAYS, RULE_FIRES_ON_ORIGIN, RULE_FIRES_ON_REPLICA, AlterTableCmd::subtype, TRIGGER_DISABLED, TRIGGER_FIRES_ALWAYS, TRIGGER_FIRES_ON_ORIGIN, and TRIGGER_FIRES_ON_REPLICA.

Referenced by ATRewriteCatalogs().

ATExecColumnDefault()

static ObjectAddress ATExecColumnDefault ( Relation  rel, const char *  colName, Node *  newDefault, LOCKMODE  lockmode  )

static

Definition at line 8086 of file tablecmds.c.

{
    TupleDesc   tupdesc = RelationGetDescr(rel);
    AttrNumber  attnum;
    ObjectAddress address;
 
    /*
     * get the number of the attribute
     */
    attnum = get_attnum(RelationGetRelid(rel), colName);
    if (attnum == InvalidAttrNumber)
        ereport(ERROR,
                (errcode(ERRCODE_UNDEFINED_COLUMN),
                 errmsg("column \"%s\" of relation \"%s\" does not exist",
                        colName, RelationGetRelationName(rel))));
 
    /* Prevent them from altering a system attribute */
    if (attnum <= 0)
        ereport(ERROR,
                (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                 errmsg("cannot alter system column \"%s\"",
                        colName)));
 
    if (TupleDescAttr(tupdesc, attnum - 1)->attidentity)
        ereport(ERROR,
                (errcode(ERRCODE_SYNTAX_ERROR),
                 errmsg("column \"%s\" of relation \"%s\" is an identity column",
                        colName, RelationGetRelationName(rel)),
        /* translator: %s is an SQL ALTER command */
                 newDefault ? 0 : errhint("Use %s instead.",
                                          "ALTER TABLE ... ALTER COLUMN ... DROP IDENTITY")));
 
    if (TupleDescAttr(tupdesc, attnum - 1)->attgenerated)
        ereport(ERROR,
                (errcode(ERRCODE_SYNTAX_ERROR),
                 errmsg("column \"%s\" of relation \"%s\" is a generated column",
                        colName, RelationGetRelationName(rel)),
                 newDefault ?
        /* translator: %s is an SQL ALTER command */
                 errhint("Use %s instead.", "ALTER TABLE ... ALTER COLUMN ... SET EXPRESSION") :
                 (TupleDescAttr(tupdesc, attnum - 1)->attgenerated == ATTRIBUTE_GENERATED_STORED ?
                  errhint("Use %s instead.", "ALTER TABLE ... ALTER COLUMN ... DROP EXPRESSION") : 0)));
 
    /*
     * Remove any old default for the column.  We use RESTRICT here for
     * safety, but at present we do not expect anything to depend on the
     * default.
     *
     * We treat removing the existing default as an internal operation when it
     * is preparatory to adding a new default, but as a user-initiated
     * operation when the user asked for a drop.
     */
    RemoveAttrDefault(RelationGetRelid(rel), attnum, DROP_RESTRICT, false,
                      newDefault != NULL);
 
    if (newDefault)
    {
        /* SET DEFAULT */
        RawColumnDefault *rawEnt;
 
        rawEnt = (RawColumnDefault *) palloc(sizeof(RawColumnDefault));
        rawEnt->attnum = attnum;
        rawEnt->raw_default = newDefault;
        rawEnt->missingMode = false;
        rawEnt->generated = '\0';
 
        /*
         * 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);
    }
 
    ObjectAddressSubSet(address, RelationRelationId,
                        RelationGetRelid(rel), attnum);
    return address;
}

References AddRelationNewConstraints(), RawColumnDefault::attnum, attnum, DROP_RESTRICT, ereport, errcode(), errhint(), errmsg(), ERROR, RawColumnDefault::generated, get_attnum(), InvalidAttrNumber, list_make1, RawColumnDefault::missingMode, NIL, ObjectAddressSubSet, palloc(), RawColumnDefault::raw_default, RelationGetDescr, RelationGetRelationName, RelationGetRelid, RemoveAttrDefault(), and TupleDescAttr.

Referenced by ATExecCmd().

ATExecCookedColumnDefault()

static ObjectAddress ATExecCookedColumnDefault ( Relation  rel, AttrNumber  attnum, Node *  newDefault  )

static

Definition at line 8172 of file tablecmds.c.

{
    ObjectAddress address;
 
    /* We assume no checking is required */
 
    /*
     * Remove any old default for the column.  We use RESTRICT here for
     * safety, but at present we do not expect anything to depend on the
     * default.  (In ordinary cases, there could not be a default in place
     * anyway, but it's possible when combining LIKE with inheritance.)
     */
    RemoveAttrDefault(RelationGetRelid(rel), attnum, DROP_RESTRICT, false,
                      true);
 
    (void) StoreAttrDefault(rel, attnum, newDefault, true, false);
 
    ObjectAddressSubSet(address, RelationRelationId,
                        RelationGetRelid(rel), attnum);
    return address;
}

References attnum, DROP_RESTRICT, ObjectAddressSubSet, RelationGetRelid, RemoveAttrDefault(), and StoreAttrDefault().

Referenced by ATExecCmd().

ATExecDetachPartition()

static ObjectAddress ATExecDetachPartition ( List **  wqueue, AlteredTableInfo *  tab, Relation  rel, RangeVar *  name, bool  concurrent  )

static

Definition at line 19839 of file tablecmds.c.

{
    Relation    partRel;
    ObjectAddress address;
    Oid         defaultPartOid;
 
    /*
     * We must lock the default partition, because detaching this partition
     * will change its partition constraint.
     */
    defaultPartOid =
        get_default_oid_from_partdesc(RelationGetPartitionDesc(rel, true));
    if (OidIsValid(defaultPartOid))
    {
        /*
         * Concurrent detaching when a default partition exists is not
         * supported. The main problem is that the default partition
         * constraint would change.  And there's a definitional problem: what
         * should happen to the tuples that are being inserted that belong to
         * the partition being detached?  Putting them on the partition being
         * detached would be wrong, since they'd become "lost" after the
         * detaching completes but we cannot put them in the default partition
         * either until we alter its partition constraint.
         *
         * I think we could solve this problem if we effected the constraint
         * change before committing the first transaction.  But the lock would
         * have to remain AEL and it would cause concurrent query planning to
         * be blocked, so changing it that way would be even worse.
         */
        if (concurrent)
            ereport(ERROR,
                    (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
                     errmsg("cannot detach partitions concurrently when a default partition exists")));
        LockRelationOid(defaultPartOid, AccessExclusiveLock);
    }
 
    /*
     * In concurrent mode, the partition is locked with share-update-exclusive
     * in the first transaction.  This allows concurrent transactions to be
     * doing DML to the partition.
     */
    partRel = table_openrv(name, concurrent ? ShareUpdateExclusiveLock :
                           AccessExclusiveLock);
 
    /*
     * Check inheritance conditions and either delete the pg_inherits row (in
     * non-concurrent mode) or just set the inhdetachpending flag.
     */
    if (!concurrent)
        RemoveInheritance(partRel, rel, false);
    else
        MarkInheritDetached(partRel, rel);
 
    /*
     * Ensure that foreign keys still hold after this detach.  This keeps
     * locks on the referencing tables, which prevents concurrent transactions
     * from adding rows that we wouldn't see.  For this to work in concurrent
     * mode, it is critical that the partition appears as no longer attached
     * for the RI queries as soon as the first transaction commits.
     */
    ATDetachCheckNoForeignKeyRefs(partRel);
 
    /*
     * Concurrent mode has to work harder; first we add a new constraint to
     * the partition that matches the partition constraint.  Then we close our
     * existing transaction, and in a new one wait for all processes to catch
     * up on the catalog updates we've done so far; at that point we can
     * complete the operation.
     */
    if (concurrent)
    {
        Oid         partrelid,
                    parentrelid;
        LOCKTAG     tag;
        char       *parentrelname;
        char       *partrelname;
 
        /*
         * Add a new constraint to the partition being detached, which
         * supplants the partition constraint (unless there is one already).
         */
        DetachAddConstraintIfNeeded(wqueue, partRel);
 
        /*
         * We're almost done now; the only traces that remain are the
         * pg_inherits tuple and the partition's relpartbounds.  Before we can
         * remove those, we need to wait until all transactions that know that
         * this is a partition are gone.
         */
 
        /*
         * Remember relation OIDs to re-acquire them later; and relation names
         * too, for error messages if something is dropped in between.
         */
        partrelid = RelationGetRelid(partRel);
        parentrelid = RelationGetRelid(rel);
        parentrelname = MemoryContextStrdup(PortalContext,
                                            RelationGetRelationName(rel));
        partrelname = MemoryContextStrdup(PortalContext,
                                          RelationGetRelationName(partRel));
 
        /* Invalidate relcache entries for the parent -- must be before close */
        CacheInvalidateRelcache(rel);
 
        table_close(partRel, NoLock);
        table_close(rel, NoLock);
        tab->rel = NULL;
 
        /* Make updated catalog entry visible */
        PopActiveSnapshot();
        CommitTransactionCommand();
 
        StartTransactionCommand();
 
        /*
         * Now wait.  This ensures that all queries that were planned
         * including the partition are finished before we remove the rest of
         * catalog entries.  We don't need or indeed want to acquire this
         * lock, though -- that would block later queries.
         *
         * We don't need to concern ourselves with waiting for a lock on the
         * partition itself, since we will acquire AccessExclusiveLock below.
         */
        SET_LOCKTAG_RELATION(tag, MyDatabaseId, parentrelid);
        WaitForLockersMultiple(list_make1(&tag), AccessExclusiveLock, false);
 
        /*
         * Now acquire locks in both relations again.  Note they may have been
         * removed in the meantime, so care is required.
         */
        rel = try_relation_open(parentrelid, ShareUpdateExclusiveLock);
        partRel = try_relation_open(partrelid, AccessExclusiveLock);
 
        /* If the relations aren't there, something bad happened; bail out */
        if (rel == NULL)
        {
            if (partRel != NULL)    /* shouldn't happen */
                elog(WARNING, "dangling partition \"%s\" remains, can't fix",
                     partrelname);
            ereport(ERROR,
                    (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
                     errmsg("partitioned table \"%s\" was removed concurrently",
                            parentrelname)));
        }
        if (partRel == NULL)
            ereport(ERROR,
                    (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
                     errmsg("partition \"%s\" was removed concurrently", partrelname)));
 
        tab->rel = rel;
    }
 
    /* Do the final part of detaching */
    DetachPartitionFinalize(rel, partRel, concurrent, defaultPartOid);
 
    ObjectAddressSet(address, RelationRelationId, RelationGetRelid(partRel));
 
    /* keep our lock until commit */
    table_close(partRel, NoLock);
 
    return address;
}

References AccessExclusiveLock, ATDetachCheckNoForeignKeyRefs(), CacheInvalidateRelcache(), CommitTransactionCommand(), DetachAddConstraintIfNeeded(), DetachPartitionFinalize(), elog, ereport, errcode(), errmsg(), ERROR, get_default_oid_from_partdesc(), list_make1, LockRelationOid(), MarkInheritDetached(), MemoryContextStrdup(), MyDatabaseId, name, NoLock, ObjectAddressSet, OidIsValid, PopActiveSnapshot(), PortalContext, AlteredTableInfo::rel, RelationGetPartitionDesc(), RelationGetRelationName, RelationGetRelid, RemoveInheritance(), SET_LOCKTAG_RELATION, ShareUpdateExclusiveLock, StartTransactionCommand(), table_close(), table_openrv(), try_relation_open(), WaitForLockersMultiple(), and WARNING.

Referenced by ATExecCmd().

ATExecDetachPartitionFinalize()

static ObjectAddress ATExecDetachPartitionFinalize ( Relation  rel, RangeVar *  name  )

static

Definition at line 20249 of file tablecmds.c.

{
    Relation    partRel;
    ObjectAddress address;
    Snapshot    snap = GetActiveSnapshot();
 
    partRel = table_openrv(name, AccessExclusiveLock);
 
    /*
     * Wait until existing snapshots are gone.  This is important if the
     * second transaction of DETACH PARTITION CONCURRENTLY is canceled: the
     * user could immediately run DETACH FINALIZE without actually waiting for
     * existing transactions.  We must not complete the detach action until
     * all such queries are complete (otherwise we would present them with an
     * inconsistent view of catalogs).
     */
    WaitForOlderSnapshots(snap->xmin, false);
 
    DetachPartitionFinalize(rel, partRel, true, InvalidOid);
 
    ObjectAddressSet(address, RelationRelationId, RelationGetRelid(partRel));
 
    table_close(partRel, NoLock);
 
    return address;
}

References AccessExclusiveLock, DetachPartitionFinalize(), GetActiveSnapshot(), InvalidOid, name, NoLock, ObjectAddressSet, RelationGetRelid, table_close(), table_openrv(), WaitForOlderSnapshots(), and SnapshotData::xmin.

Referenced by ATExecCmd().

ATExecDropCluster()

static void ATExecDropCluster ( Relation  rel, LOCKMODE  lockmode  )

static

Definition at line 15389 of file tablecmds.c.

{
    mark_index_clustered(rel, InvalidOid, false);
}

References InvalidOid, and mark_index_clustered().

Referenced by ATExecCmd().

ATExecDropColumn()

static ObjectAddress ATExecDropColumn ( List **  wqueue, Relation  rel, const char *  colName, DropBehavior  behavior, bool  recurse, bool  recursing, bool  missing_ok, LOCKMODE  lockmode, ObjectAddresses *  addrs  )

static

Definition at line 9156 of file tablecmds.c.

{
    HeapTuple   tuple;
    Form_pg_attribute targetatt;
    AttrNumber  attnum;
    List       *children;
    ObjectAddress object;
    bool        is_expr;
 
    /* At top level, permission check was done in ATPrepCmd, else do it */
    if (recursing)
        ATSimplePermissions(AT_DropColumn, rel, ATT_TABLE | ATT_FOREIGN_TABLE);
 
    /* Initialize addrs on the first invocation */
    Assert(!recursing || addrs != NULL);
 
    /* since this function recurses, it could be driven to stack overflow */
    check_stack_depth();
 
    if (!recursing)
        addrs = new_object_addresses();
 
    /*
     * get the number of the attribute
     */
    tuple = SearchSysCacheAttName(RelationGetRelid(rel), colName);
    if (!HeapTupleIsValid(tuple))
    {
        if (!missing_ok)
        {
            ereport(ERROR,
                    (errcode(ERRCODE_UNDEFINED_COLUMN),
                     errmsg("column \"%s\" of relation \"%s\" does not exist",
                            colName, RelationGetRelationName(rel))));
        }
        else
        {
            ereport(NOTICE,
                    (errmsg("column \"%s\" of relation \"%s\" does not exist, skipping",
                            colName, RelationGetRelationName(rel))));
            return InvalidObjectAddress;
        }
    }
    targetatt = (Form_pg_attribute) GETSTRUCT(tuple);
 
    attnum = targetatt->attnum;
 
    /* Can't drop a system attribute */
    if (attnum <= 0)
        ereport(ERROR,
                (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                 errmsg("cannot drop system column \"%s\"",
                        colName)));
 
    /*
     * Don't drop inherited columns, unless recursing (presumably from a drop
     * of the parent column)
     */
    if (targetatt->attinhcount > 0 && !recursing)
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_TABLE_DEFINITION),
                 errmsg("cannot drop inherited column \"%s\"",
                        colName)));
 
    /*
     * Don't drop columns used in the partition key, either.  (If we let this
     * go through, the key column's dependencies would cause a cascaded drop
     * of the whole table, which is surely not what the user expected.)
     */
    if (has_partition_attrs(rel,
                            bms_make_singleton(attnum - FirstLowInvalidHeapAttributeNumber),
                            &is_expr))
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_TABLE_DEFINITION),
                 errmsg("cannot drop column \"%s\" because it is part of the partition key of relation \"%s\"",
                        colName, RelationGetRelationName(rel))));
 
    ReleaseSysCache(tuple);
 
    /*
     * 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 (children)
    {
        Relation    attr_rel;
        ListCell   *child;
 
        /*
         * In case of a partitioned table, the column must be dropped from the
         * partitions as well.
         */
        if (rel->rd_rel->relkind == RELKIND_PARTITIONED_TABLE && !recurse)
            ereport(ERROR,
                    (errcode(ERRCODE_INVALID_TABLE_DEFINITION),
                     errmsg("cannot drop column from only the partitioned table when partitions exist"),
                     errhint("Do not specify the ONLY keyword.")));
 
        attr_rel = table_open(AttributeRelationId, RowExclusiveLock);
        foreach(child, children)
        {
            Oid         childrelid = lfirst_oid(child);
            Relation    childrel;
            Form_pg_attribute childatt;
 
            /* find_inheritance_children already got lock */
            childrel = table_open(childrelid, NoLock);
            CheckTableNotInUse(childrel, "ALTER TABLE");
 
            tuple = SearchSysCacheCopyAttName(childrelid, colName);
            if (!HeapTupleIsValid(tuple))   /* shouldn't happen */
                elog(ERROR, "cache lookup failed for attribute \"%s\" of relation %u",
                     colName, childrelid);
            childatt = (Form_pg_attribute) GETSTRUCT(tuple);
 
            if (childatt->attinhcount <= 0) /* shouldn't happen */
                elog(ERROR, "relation %u has non-inherited attribute \"%s\"",
                     childrelid, colName);
 
            if (recurse)
            {
                /*
                 * If the child column has other definition sources, just
                 * decrement its inheritance count; if not, recurse to delete
                 * it.
                 */
                if (childatt->attinhcount == 1 && !childatt->attislocal)
                {
                    /* Time to delete this child column, too */
                    ATExecDropColumn(wqueue, childrel, colName,
                                     behavior, true, true,
                                     false, lockmode, addrs);
                }
                else
                {
                    /* Child column must survive my deletion */
                    childatt->attinhcount--;
 
                    CatalogTupleUpdate(attr_rel, &tuple->t_self, tuple);
 
                    /* Make update visible */
                    CommandCounterIncrement();
                }
            }
            else
            {
                /*
                 * If we were told to drop ONLY in this table (no recursion),
                 * we need to mark the inheritors' attributes as locally
                 * defined rather than inherited.
                 */
                childatt->attinhcount--;
                childatt->attislocal = true;
 
                CatalogTupleUpdate(attr_rel, &tuple->t_self, tuple);
 
                /* Make update visible */
                CommandCounterIncrement();
            }
 
            heap_freetuple(tuple);
 
            table_close(childrel, NoLock);
        }
        table_close(attr_rel, RowExclusiveLock);
    }
 
    /* Add object to delete */
    object.classId = RelationRelationId;
    object.objectId = RelationGetRelid(rel);
    object.objectSubId = attnum;
    add_exact_object_address(&object, addrs);
 
    if (!recursing)
    {
        /* Recursion has ended, drop everything that was collected */
        performMultipleDeletions(addrs, behavior, 0);
        free_object_addresses(addrs);
    }
 
    return object;
}

References add_exact_object_address(), Assert, AT_DropColumn, ATSimplePermissions(), ATT_FOREIGN_TABLE, ATT_TABLE, attnum, bms_make_singleton(), CatalogTupleUpdate(), check_stack_depth(), CheckTableNotInUse(), CommandCounterIncrement(), elog, ereport, errcode(), errhint(), errmsg(), ERROR, find_inheritance_children(), FirstLowInvalidHeapAttributeNumber, free_object_addresses(), GETSTRUCT, has_partition_attrs(), heap_freetuple(), HeapTupleIsValid, InvalidObjectAddress, lfirst_oid, new_object_addresses(), NoLock, NOTICE, performMultipleDeletions(), RelationData::rd_rel, RelationGetRelationName, RelationGetRelid, ReleaseSysCache(), RowExclusiveLock, SearchSysCacheAttName(), SearchSysCacheCopyAttName(), HeapTupleData::t_self, table_close(), and table_open().

Referenced by ATExecCmd().

ATExecDropConstraint()

static void ATExecDropConstraint ( Relation  rel, const char *  constrName, DropBehavior  behavior, bool  recurse, bool  missing_ok, LOCKMODE  lockmode  )

static

Definition at line 12873 of file tablecmds.c.

{
    Relation    conrel;
    SysScanDesc scan;
    ScanKeyData skey[3];
    HeapTuple   tuple;
    bool        found = false;
 
    conrel = table_open(ConstraintRelationId, RowExclusiveLock);
 
    /*
     * Find and drop the target constraint
     */
    ScanKeyInit(&skey[0],
                Anum_pg_constraint_conrelid,
                BTEqualStrategyNumber, F_OIDEQ,
                ObjectIdGetDatum(RelationGetRelid(rel)));
    ScanKeyInit(&skey[1],
                Anum_pg_constraint_contypid,
                BTEqualStrategyNumber, F_OIDEQ,
                ObjectIdGetDatum(InvalidOid));
    ScanKeyInit(&skey[2],
                Anum_pg_constraint_conname,
                BTEqualStrategyNumber, F_NAMEEQ,
                CStringGetDatum(constrName));
    scan = systable_beginscan(conrel, ConstraintRelidTypidNameIndexId,
                              true, NULL, 3, skey);
 
    /* There can be at most one matching row */
    if (HeapTupleIsValid(tuple = systable_getnext(scan)))
    {
        List       *readyRels = NIL;
 
        dropconstraint_internal(rel, tuple, behavior, recurse, false,
                                missing_ok, &readyRels, lockmode);
        found = true;
    }
 
    systable_endscan(scan);
 
    if (!found)
    {
        if (!missing_ok)
            ereport(ERROR,
                    errcode(ERRCODE_UNDEFINED_OBJECT),
                    errmsg("constraint \"%s\" of relation \"%s\" does not exist",
                           constrName, RelationGetRelationName(rel)));
        else
            ereport(NOTICE,
                    errmsg("constraint \"%s\" of relation \"%s\" does not exist, skipping",
                           constrName, RelationGetRelationName(rel)));
    }
 
    table_close(conrel, RowExclusiveLock);
}

References BTEqualStrategyNumber, CStringGetDatum(), dropconstraint_internal(), ereport, errcode(), errmsg(), ERROR, HeapTupleIsValid, InvalidOid, NIL, NOTICE, ObjectIdGetDatum(), RelationGetRelationName, RelationGetRelid, RowExclusiveLock, ScanKeyInit(), systable_beginscan(), systable_endscan(), systable_getnext(), table_close(), and table_open().

Referenced by ATExecCmd().

ATExecDropExpression()

static ObjectAddress ATExecDropExpression ( Relation  rel, const char *  colName, bool  missing_ok, LOCKMODE  lockmode  )

static

Definition at line 8697 of file tablecmds.c.

{
    HeapTuple   tuple;
    Form_pg_attribute attTup;
    AttrNumber  attnum;
    Relation    attrelation;
    Oid         attrdefoid;
    ObjectAddress address;
 
    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;
 
    if (attnum <= 0)
        ereport(ERROR,
                (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                 errmsg("cannot alter system column \"%s\"",
                        colName)));
 
    if (attTup->attgenerated != ATTRIBUTE_GENERATED_STORED)
    {
        if (!missing_ok)
            ereport(ERROR,
                    (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
                     errmsg("column \"%s\" of relation \"%s\" is not a stored generated column",
                            colName, RelationGetRelationName(rel))));
        else
        {
            ereport(NOTICE,
                    (errmsg("column \"%s\" of relation \"%s\" is not a stored generated column, skipping",
                            colName, RelationGetRelationName(rel))));
            heap_freetuple(tuple);
            table_close(attrelation, RowExclusiveLock);
            return InvalidObjectAddress;
        }
    }
 
    /*
     * Mark the column as no longer generated.  (The atthasdef flag needs to
     * get cleared too, but RemoveAttrDefault will handle that.)
     */
    attTup->attgenerated = '\0';
    CatalogTupleUpdate(attrelation, &tuple->t_self, tuple);
 
    InvokeObjectPostAlterHook(RelationRelationId,
                              RelationGetRelid(rel),
                              attnum);
    heap_freetuple(tuple);
 
    table_close(attrelation, RowExclusiveLock);
 
    /*
     * Drop the dependency records of the GENERATED expression, in particular
     * its INTERNAL dependency on the column, which would otherwise cause
     * dependency.c to refuse to perform the deletion.
     */
    attrdefoid = GetAttrDefaultOid(RelationGetRelid(rel), attnum);
    if (!OidIsValid(attrdefoid))
        elog(ERROR, "could not find attrdef tuple for relation %u attnum %d",
             RelationGetRelid(rel), attnum);
    (void) deleteDependencyRecordsFor(AttrDefaultRelationId, attrdefoid, false);
 
    /* Make above changes visible */
    CommandCounterIncrement();
 
    /*
     * Get rid of the GENERATED expression itself.  We use RESTRICT here for
     * safety, but at present we do not expect anything to depend on the
     * default.
     */
    RemoveAttrDefault(RelationGetRelid(rel), attnum, DROP_RESTRICT,
                      false, false);
 
    ObjectAddressSubSet(address, RelationRelationId,
                        RelationGetRelid(rel), attnum);
    return address;
}

References attnum, CatalogTupleUpdate(), CommandCounterIncrement(), deleteDependencyRecordsFor(), DROP_RESTRICT, elog, ereport, errcode(), errmsg(), ERROR, GetAttrDefaultOid(), GETSTRUCT, heap_freetuple(), HeapTupleIsValid, InvalidObjectAddress, InvokeObjectPostAlterHook, NOTICE, ObjectAddressSubSet, OidIsValid, RelationGetRelationName, RelationGetRelid, RemoveAttrDefault(), RowExclusiveLock, SearchSysCacheCopyAttName(), HeapTupleData::t_self, table_close(), and table_open().

Referenced by ATExecCmd().

ATExecDropIdentity()

static ObjectAddress ATExecDropIdentity ( Relation  rel, const char *  colName, bool  missing_ok, LOCKMODE  lockmode, bool  recurse, bool  recursing  )

static

Definition at line 8424 of file tablecmds.c.

{
    HeapTuple   tuple;
    Form_pg_attribute attTup;
    AttrNumber  attnum;
    Relation    attrelation;
    ObjectAddress address;
    Oid         seqid;
    ObjectAddress seqaddress;
    bool        ispartitioned;
 
    ispartitioned = (rel->rd_rel->relkind == RELKIND_PARTITIONED_TABLE);
    if (ispartitioned && !recurse)
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_TABLE_DEFINITION),
                 errmsg("cannot drop identity from a column of only the partitioned table"),
                 errhint("Do not specify the ONLY keyword.")));
 
    if (rel->rd_rel->relispartition && !recursing)
        ereport(ERROR,
                errcode(ERRCODE_INVALID_TABLE_DEFINITION),
                errmsg("cannot drop identity from a column of a partition"));
 
    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;
 
    if (attnum <= 0)
        ereport(ERROR,
                (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                 errmsg("cannot alter system column \"%s\"",
                        colName)));
 
    if (!attTup->attidentity)
    {
        if (!missing_ok)
            ereport(ERROR,
                    (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
                     errmsg("column \"%s\" of relation \"%s\" is not an identity column",
                            colName, RelationGetRelationName(rel))));
        else
        {
            ereport(NOTICE,
                    (errmsg("column \"%s\" of relation \"%s\" is not an identity column, skipping",
                            colName, RelationGetRelationName(rel))));
            heap_freetuple(tuple);
            table_close(attrelation, RowExclusiveLock);
            return InvalidObjectAddress;
        }
    }
 
    attTup->attidentity = '\0';
    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);
 
    /*
     * Recurse to drop the identity from column in partitions.  Identity is
     * not inherited in regular inheritance children so ignore them.
     */
    if (recurse && ispartitioned)
    {
        List       *children;
        ListCell   *lc;
 
        children = find_inheritance_children(RelationGetRelid(rel), lockmode);
 
        foreach(lc, children)
        {
            Relation    childrel;
 
            childrel = table_open(lfirst_oid(lc), NoLock);
            ATExecDropIdentity(childrel, colName, false, lockmode, recurse, true);
            table_close(childrel, NoLock);
        }
    }
 
    if (!recursing)
    {
        /* drop the internal sequence */
        seqid = getIdentitySequence(RelationGetRelid(rel), attnum, false);
        deleteDependencyRecordsForClass(RelationRelationId, seqid,
                                        RelationRelationId, DEPENDENCY_INTERNAL);
        CommandCounterIncrement();
        seqaddress.classId = RelationRelationId;
        seqaddress.objectId = seqid;
        seqaddress.objectSubId = 0;
        performDeletion(&seqaddress, DROP_RESTRICT, PERFORM_DELETION_INTERNAL);
    }
 
    return address;
}

References attnum, CatalogTupleUpdate(), ObjectAddress::classId, CommandCounterIncrement(), deleteDependencyRecordsForClass(), DEPENDENCY_INTERNAL, DROP_RESTRICT, ereport, errcode(), errhint(), errmsg(), ERROR, find_inheritance_children(), getIdentitySequence(), GETSTRUCT, heap_freetuple(), HeapTupleIsValid, InvalidObjectAddress, InvokeObjectPostAlterHook, lfirst_oid, NoLock, NOTICE, ObjectAddressSubSet, ObjectAddress::objectId, ObjectAddress::objectSubId, PERFORM_DELETION_INTERNAL, performDeletion(), RelationData::rd_rel, RelationGetRelationName, RelationGetRelid, RowExclusiveLock, SearchSysCacheCopyAttName(), HeapTupleData::t_self, table_close(), and table_open().

Referenced by ATExecCmd(), and DetachPartitionFinalize().

ATExecDropInherit()

static ObjectAddress ATExecDropInherit ( Relation  rel, RangeVar *  parent, LOCKMODE  lockmode  )

static

Definition at line 16724 of file tablecmds.c.

{
    ObjectAddress address;
    Relation    parent_rel;
 
    if (rel->rd_rel->relispartition)
        ereport(ERROR,
                (errcode(ERRCODE_WRONG_OBJECT_TYPE),
                 errmsg("cannot change inheritance of a partition")));
 
    /*
     * AccessShareLock on the parent is probably enough, seeing that DROP
     * TABLE doesn't lock parent tables at all.  We need some lock since we'll
     * be inspecting the parent's schema.
     */
    parent_rel = table_openrv(parent, AccessShareLock);
 
    /*
     * We don't bother to check ownership of the parent table --- ownership of
     * the child is presumed enough rights.
     */
 
    /* Off to RemoveInheritance() where most of the work happens */
    RemoveInheritance(rel, parent_rel, false);
 
    /*
     * If parent_rel has a primary key, then child_rel has not-null
     * constraints that make these columns as non nullable.  Mark those
     * constraints as no longer inherited by this parent.
     */
    ATInheritAdjustNotNulls(parent_rel, rel, -1);
 
    /*
     * If the parent has a primary key, then we decrement counts for all NOT
     * NULL constraints
     */
 
    ObjectAddressSet(address, RelationRelationId,
                     RelationGetRelid(parent_rel));
 
    /* keep our lock on the parent relation until commit */
    table_close(parent_rel, NoLock);
 
    return address;
}

References AccessShareLock, ATInheritAdjustNotNulls(), ereport, errcode(), errmsg(), ERROR, NoLock, ObjectAddressSet, RelationData::rd_rel, RelationGetRelid, RemoveInheritance(), table_close(), and table_openrv().

Referenced by ATExecCmd().

ATExecDropNotNull()

static ObjectAddress ATExecDropNotNull ( Relation  rel, const char *  colName, bool  recurse, LOCKMODE  lockmode  )

static

Definition at line 7570 of file tablecmds.c.

{
    HeapTuple   tuple;
    HeapTuple   conTup;
    Form_pg_attribute attTup;
    AttrNumber  attnum;
    Relation    attr_rel;
    ObjectAddress address;
    List       *readyRels;
 
    /*
     * lookup the attribute
     */
    attr_rel = 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;
    ObjectAddressSubSet(address, RelationRelationId,
                        RelationGetRelid(rel), attnum);
 
    /* If the column is already nullable there's nothing to do. */
    if (!attTup->attnotnull)
    {
        table_close(attr_rel, RowExclusiveLock);
        return InvalidObjectAddress;
    }
 
    /* Prevent them from altering a system attribute */
    if (attnum <= 0)
        ereport(ERROR,
                (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                 errmsg("cannot alter system column \"%s\"",
                        colName)));
 
    if (attTup->attidentity)
        ereport(ERROR,
                (errcode(ERRCODE_SYNTAX_ERROR),
                 errmsg("column \"%s\" of relation \"%s\" is an identity column",
                        colName, RelationGetRelationName(rel))));
 
    /*
     * It's not OK to remove a constraint only for the parent and leave it in
     * the children, so disallow that.
     */
    if (!recurse)
    {
        if (rel->rd_rel->relkind == RELKIND_PARTITIONED_TABLE)
        {
            PartitionDesc partdesc;
 
            partdesc = RelationGetPartitionDesc(rel, true);
 
            if (partdesc->nparts > 0)
                ereport(ERROR,
                        errcode(ERRCODE_INVALID_TABLE_DEFINITION),
                        errmsg("cannot remove constraint from only the partitioned table when partitions exist"),
                        errhint("Do not specify the ONLY keyword."));
        }
        else if (rel->rd_rel->relhassubclass &&
                 find_inheritance_children(RelationGetRelid(rel), NoLock) != NIL)
        {
            ereport(ERROR,
                    errcode(ERRCODE_INVALID_TABLE_DEFINITION),
                    errmsg("not-null constraint on column \"%s\" must be removed in child tables too",
                           colName),
                    errhint("Do not specify the ONLY keyword."));
        }
    }
 
    /*
     * If rel is partition, shouldn't drop NOT NULL if parent has the same.
     */
    if (rel->rd_rel->relispartition)
    {
        Oid         parentId = get_partition_parent(RelationGetRelid(rel), false);
        Relation    parent = table_open(parentId, AccessShareLock);
        TupleDesc   tupDesc = RelationGetDescr(parent);
        AttrNumber  parent_attnum;
 
        parent_attnum = get_attnum(parentId, colName);
        if (TupleDescAttr(tupDesc, parent_attnum - 1)->attnotnull)
            ereport(ERROR,
                    (errcode(ERRCODE_INVALID_TABLE_DEFINITION),
                     errmsg("column \"%s\" is marked NOT NULL in parent table",
                            colName)));
        table_close(parent, AccessShareLock);
    }
 
    /*
     * Find the constraint that makes this column NOT NULL, and drop it if we
     * see one.  dropconstraint_internal() will do necessary consistency
     * checking.  If there isn't one, there are two possibilities: either the
     * column is marked attnotnull because it's part of the primary key, and
     * then we just throw an appropriate error; or it's a leftover marking
     * that we can remove.  However, before doing the latter, to avoid
     * breaking consistency any further, prevent this if the column is part of
     * the replica identity.
     */
    conTup = findNotNullConstraint(RelationGetRelid(rel), colName);
    if (conTup == NULL)
    {
        Bitmapset  *pkcols;
        Bitmapset  *ircols;
 
        /*
         * If the column is in a primary key, throw a specific error message.
         */
        pkcols = RelationGetIndexAttrBitmap(rel, INDEX_ATTR_BITMAP_PRIMARY_KEY);
        if (bms_is_member(attnum - FirstLowInvalidHeapAttributeNumber,
                          pkcols))
            ereport(ERROR,
                    errcode(ERRCODE_INVALID_TABLE_DEFINITION),
                    errmsg("column \"%s\" is in a primary key", colName));
 
        /* Also throw an error if the column is in the replica identity */
        ircols = RelationGetIndexAttrBitmap(rel, INDEX_ATTR_BITMAP_IDENTITY_KEY);
        if (bms_is_member(attnum - FirstLowInvalidHeapAttributeNumber, ircols))
            ereport(ERROR,
                    errcode(ERRCODE_INVALID_TABLE_DEFINITION),
                    errmsg("column \"%s\" is in index used as replica identity",
                           get_attname(RelationGetRelid(rel), attnum, false)));
 
        /* Otherwise, just remove the attnotnull marking and do nothing else. */
        attTup->attnotnull = false;
        CatalogTupleUpdate(attr_rel, &tuple->t_self, tuple);
    }
    else
    {
        /* The normal case: we have a pg_constraint row, remove it */
        readyRels = NIL;
        dropconstraint_internal(rel, conTup, DROP_RESTRICT, recurse, false,
                                false, &readyRels, lockmode);
 
        heap_freetuple(conTup);
    }
 
    InvokeObjectPostAlterHook(RelationRelationId,
                              RelationGetRelid(rel), attnum);
 
    table_close(attr_rel, RowExclusiveLock);
 
    return address;
}

References AccessShareLock, attnotnull, attnum, bms_is_member(), CatalogTupleUpdate(), DROP_RESTRICT, dropconstraint_internal(), ereport, errcode(), errhint(), errmsg(), ERROR, find_inheritance_children(), findNotNullConstraint(), FirstLowInvalidHeapAttributeNumber, get_attname(), get_attnum(), get_partition_parent(), GETSTRUCT, heap_freetuple(), HeapTupleIsValid, INDEX_ATTR_BITMAP_IDENTITY_KEY, INDEX_ATTR_BITMAP_PRIMARY_KEY, InvalidObjectAddress, InvokeObjectPostAlterHook, NIL, NoLock, PartitionDescData::nparts, ObjectAddressSubSet, RelationData::rd_rel, RelationGetDescr, RelationGetIndexAttrBitmap(), RelationGetPartitionDesc(), RelationGetRelationName, RelationGetRelid, RowExclusiveLock, SearchSysCacheCopyAttName(), HeapTupleData::t_self, table_close(), table_open(), and TupleDescAttr.

Referenced by ATExecCmd().

ATExecDropOf()

static void ATExecDropOf ( Relation  rel, LOCKMODE  lockmode  )

static

Definition at line 17297 of file tablecmds.c.

{
    Oid         relid = RelationGetRelid(rel);
    Relation    relationRelation;
    HeapTuple   tuple;
 
    if (!OidIsValid(rel->rd_rel->reloftype))
        ereport(ERROR,
                (errcode(ERRCODE_WRONG_OBJECT_TYPE),
                 errmsg("\"%s\" is not a typed table",
                        RelationGetRelationName(rel))));
 
    /*
     * We don't bother to check ownership of the type --- ownership of the
     * table is presumed enough rights.  No lock required on the type, either.
     */
 
    drop_parent_dependency(relid, TypeRelationId, rel->rd_rel->reloftype,
                           DEPENDENCY_NORMAL);
 
    /* Clear pg_class.reloftype */
    relationRelation = table_open(RelationRelationId, RowExclusiveLock);
    tuple = SearchSysCacheCopy1(RELOID, ObjectIdGetDatum(relid));
    if (!HeapTupleIsValid(tuple))
        elog(ERROR, "cache lookup failed for relation %u", relid);
    ((Form_pg_class) GETSTRUCT(tuple))->reloftype = InvalidOid;
    CatalogTupleUpdate(relationRelation, &tuple->t_self, tuple);
 
    InvokeObjectPostAlterHook(RelationRelationId, relid, 0);
 
    heap_freetuple(tuple);
    table_close(relationRelation, RowExclusiveLock);
}

References CatalogTupleUpdate(), DEPENDENCY_NORMAL, drop_parent_dependency(), elog, ereport, errcode(), errmsg(), ERROR, GETSTRUCT, heap_freetuple(), HeapTupleIsValid, InvalidOid, InvokeObjectPostAlterHook, ObjectIdGetDatum(), OidIsValid, RelationData::rd_rel, RelationGetRelationName, RelationGetRelid, RowExclusiveLock, SearchSysCacheCopy1, HeapTupleData::t_self, table_close(), and table_open().

Referenced by ATExecCmd().

ATExecEnableDisableRule()

static void ATExecEnableDisableRule ( Relation  rel, const char *  rulename, char  fires_when, LOCKMODE  lockmode  )

static

Definition at line 16127 of file tablecmds.c.

{
    EnableDisableRule(rel, rulename, fires_when);
 
    InvokeObjectPostAlterHook(RelationRelationId,
                              RelationGetRelid(rel), 0);
}

References EnableDisableRule(), InvokeObjectPostAlterHook, and RelationGetRelid.

Referenced by ATExecCmd().

ATExecEnableDisableTrigger()

static void ATExecEnableDisableTrigger ( Relation  rel, const char *  trigname, char  fires_when, bool  skip_system, bool  recurse, LOCKMODE  lockmode  )

static

Definition at line 16109 of file tablecmds.c.

{
    EnableDisableTrigger(rel, trigname, InvalidOid,
                         fires_when, skip_system, recurse,
                         lockmode);
 
    InvokeObjectPostAlterHook(RelationRelationId,
                              RelationGetRelid(rel), 0);
}

References EnableDisableTrigger(), InvalidOid, InvokeObjectPostAlterHook, and RelationGetRelid.

Referenced by ATExecCmd().

ATExecForceNoForceRowSecurity()

static void ATExecForceNoForceRowSecurity ( Relation  rel, bool  force_rls  )

static

Definition at line 17567 of file tablecmds.c.

{
    Relation    pg_class;
    Oid         relid;
    HeapTuple   tuple;
 
    relid = RelationGetRelid(rel);
 
    pg_class = table_open(RelationRelationId, RowExclusiveLock);
 
    tuple = SearchSysCacheCopy1(RELOID, ObjectIdGetDatum(relid));
 
    if (!HeapTupleIsValid(tuple))
        elog(ERROR, "cache lookup failed for relation %u", relid);
 
    ((Form_pg_class) GETSTRUCT(tuple))->relforcerowsecurity = force_rls;
    CatalogTupleUpdate(pg_class, &tuple->t_self, tuple);
 
    InvokeObjectPostAlterHook(RelationRelationId,
                              RelationGetRelid(rel), 0);
 
    table_close(pg_class, RowExclusiveLock);
    heap_freetuple(tuple);
}

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

Referenced by ATExecCmd().

ATExecGenericOptions()

static void ATExecGenericOptions ( Relation  rel, List *  options  )

static

Definition at line 17596 of file tablecmds.c.

{
    Relation    ftrel;
    ForeignServer *server;
    ForeignDataWrapper *fdw;
    HeapTuple   tuple;
    bool        isnull;
    Datum       repl_val[Natts_pg_foreign_table];
    bool        repl_null[Natts_pg_foreign_table];
    bool        repl_repl[Natts_pg_foreign_table];
    Datum       datum;
    Form_pg_foreign_table tableform;
 
    if (options == NIL)
        return;
 
    ftrel = table_open(ForeignTableRelationId, RowExclusiveLock);
 
    tuple = SearchSysCacheCopy1(FOREIGNTABLEREL,
                                ObjectIdGetDatum(rel->rd_id));
    if (!HeapTupleIsValid(tuple))
        ereport(ERROR,
                (errcode(ERRCODE_UNDEFINED_OBJECT),
                 errmsg("foreign table \"%s\" does not exist",
                        RelationGetRelationName(rel))));
    tableform = (Form_pg_foreign_table) GETSTRUCT(tuple);
    server = GetForeignServer(tableform->ftserver);
    fdw = GetForeignDataWrapper(server->fdwid);
 
    memset(repl_val, 0, sizeof(repl_val));
    memset(repl_null, false, sizeof(repl_null));
    memset(repl_repl, false, sizeof(repl_repl));
 
    /* Extract the current options */
    datum = SysCacheGetAttr(FOREIGNTABLEREL,
                            tuple,
                            Anum_pg_foreign_table_ftoptions,
                            &isnull);
    if (isnull)
        datum = PointerGetDatum(NULL);
 
    /* Transform the options */
    datum = transformGenericOptions(ForeignTableRelationId,
                                    datum,
                                    options,
                                    fdw->fdwvalidator);
 
    if (PointerIsValid(DatumGetPointer(datum)))
        repl_val[Anum_pg_foreign_table_ftoptions - 1] = datum;
    else
        repl_null[Anum_pg_foreign_table_ftoptions - 1] = true;
 
    repl_repl[Anum_pg_foreign_table_ftoptions - 1] = true;
 
    /* Everything looks good - update the tuple */
 
    tuple = heap_modify_tuple(tuple, RelationGetDescr(ftrel),
                              repl_val, repl_null, repl_repl);
 
    CatalogTupleUpdate(ftrel, &tuple->t_self, tuple);
 
    /*
     * Invalidate relcache so that all sessions will refresh any cached plans
     * that might depend on the old options.
     */
    CacheInvalidateRelcache(rel);
 
    InvokeObjectPostAlterHook(ForeignTableRelationId,
                              RelationGetRelid(rel), 0);
 
    table_close(ftrel, RowExclusiveLock);
 
    heap_freetuple(tuple);
}

References CacheInvalidateRelcache(), CatalogTupleUpdate(), DatumGetPointer(), ereport, errcode(), errmsg(), ERROR, ForeignServer::fdwid, ForeignDataWrapper::fdwvalidator, GetForeignDataWrapper(), GetForeignServer(), GETSTRUCT, heap_freetuple(), heap_modify_tuple(), HeapTupleIsValid, InvokeObjectPostAlterHook, NIL, ObjectIdGetDatum(), PointerGetDatum(), PointerIsValid, RelationData::rd_id, RelationGetDescr, RelationGetRelationName, RelationGetRelid, RowExclusiveLock, SearchSysCacheCopy1, SysCacheGetAttr(), HeapTupleData::t_self, table_close(), table_open(), and transformGenericOptions().

Referenced by ATExecCmd().

ATExecMergePartitions()

static void ATExecMergePartitions ( List **  wqueue, AlteredTableInfo *  tab, Relation  rel, PartitionCmd *  cmd, AlterTableUtilityContext *  context  )

static

Definition at line 21473 of file tablecmds.c.

{
    Relation    newPartRel;
    ListCell   *listptr;
    List       *mergingPartitionsList = NIL;
    Oid         defaultPartOid;
    char        tmpRelName[NAMEDATALEN];
    RangeVar   *mergePartName = cmd->name;
    bool        isSameName = false;
 
    /*
     * Lock all merged partitions, check them and create list with partitions
     * contexts.
     */
    foreach(listptr, cmd->partlist)
    {
        RangeVar   *name = (RangeVar *) lfirst(listptr);
        Relation    mergingPartition;
 
        /*
         * We are going to detach and remove this partition: need to use
         * exclusive lock for preventing DML-queries to the partition.
         */
        mergingPartition = table_openrv(name, AccessExclusiveLock);
 
        /*
         * Checking that two partitions have the same name was before, in
         * function transformPartitionCmdForMerge().
         */
        if (equal(name, cmd->name))
            /* One new partition can have the same name as merged partition. */
            isSameName = true;
 
        /* Store a next merging partition into the list. */
        mergingPartitionsList = lappend(mergingPartitionsList,
                                        mergingPartition);
    }
 
    /* Detach all merged partitions. */
    defaultPartOid =
        get_default_oid_from_partdesc(RelationGetPartitionDesc(rel, true));
    foreach(listptr, mergingPartitionsList)
    {
        Relation    mergingPartition = (Relation) lfirst(listptr);
 
        /* Remove the pg_inherits row first. */
        RemoveInheritance(mergingPartition, rel, false);
        /* Do the final part of detaching. */
        DetachPartitionFinalize(rel, mergingPartition, false, defaultPartOid);
    }
 
    /* Create table for new partition, use partitioned table as model. */
    if (isSameName)
    {
        /* Create partition table with generated temporary name. */
        sprintf(tmpRelName, "merge-%u-%X-tmp", RelationGetRelid(rel), MyProcPid);
        mergePartName = makeRangeVar(get_namespace_name(RelationGetNamespace(rel)),
                                     tmpRelName, -1);
    }
    createPartitionTable(mergePartName,
                         makeRangeVar(get_namespace_name(RelationGetNamespace(rel)),
                                      RelationGetRelationName(rel), -1),
                         context);
 
    /*
     * Open the new partition and acquire exclusive lock on it.  This will
     * stop all the operations with partitioned table.  This might seem
     * excessive, but this is the way we make sure nobody is planning queries
     * involving merging partitions.
     */
    newPartRel = table_openrv(mergePartName, AccessExclusiveLock);
 
    /* Copy data from merged partitions to new partition. */
    moveMergedTablesRows(rel, mergingPartitionsList, newPartRel);
 
    /*
     * Attach a new partition to the partitioned table. wqueue = NULL:
     * verification for each cloned constraint is not need.
     */
    attachPartitionTable(NULL, rel, newPartRel, cmd->bound);
 
    /* Unlock and drop merged partitions. */
    foreach(listptr, mergingPartitionsList)
    {
        ObjectAddress object;
        Relation    mergingPartition = (Relation) lfirst(listptr);
 
        /* Get relation id before table_close() call. */
        object.objectId = RelationGetRelid(mergingPartition);
        object.classId = RelationRelationId;
        object.objectSubId = 0;
 
        /* Keep the lock until commit. */
        table_close(mergingPartition, NoLock);
 
        performDeletion(&object, DROP_RESTRICT, 0);
    }
    list_free(mergingPartitionsList);
 
    /* Rename new partition if it is needed. */
    if (isSameName)
    {
        /*
         * We must bump the command counter to make the new partition tuple
         * visible for rename.
         */
        CommandCounterIncrement();
        /* Rename partition. */
        RenameRelationInternal(RelationGetRelid(newPartRel),
                               cmd->name->relname, false, false);
    }
    /* Keep the lock until commit. */
    table_close(newPartRel, NoLock);
}

References AccessExclusiveLock, attachPartitionTable(), PartitionCmd::bound, CommandCounterIncrement(), context, createPartitionTable(), DetachPartitionFinalize(), DROP_RESTRICT, equal(), get_default_oid_from_partdesc(), get_namespace_name(), lappend(), lfirst, list_free(), makeRangeVar(), moveMergedTablesRows(), MyProcPid, name, PartitionCmd::name, NAMEDATALEN, NIL, NoLock, PartitionCmd::partlist, performDeletion(), RelationGetNamespace, RelationGetPartitionDesc(), RelationGetRelationName, RelationGetRelid, RangeVar::relname, RemoveInheritance(), RenameRelationInternal(), sprintf, table_close(), and table_openrv().

Referenced by ATExecCmd().

ATExecReplicaIdentity()

static void ATExecReplicaIdentity ( Relation  rel, ReplicaIdentityStmt *  stmt, LOCKMODE  lockmode  )

static

Definition at line 17429 of file tablecmds.c.

{
    Oid         indexOid;
    Relation    indexRel;
    int         key;
 
    if (stmt->identity_type == REPLICA_IDENTITY_DEFAULT)
    {
        relation_mark_replica_identity(rel, stmt->identity_type, InvalidOid, true);
        return;
    }
    else if (stmt->identity_type == REPLICA_IDENTITY_FULL)
    {
        relation_mark_replica_identity(rel, stmt->identity_type, InvalidOid, true);
        return;
    }
    else if (stmt->identity_type == REPLICA_IDENTITY_NOTHING)
    {
        relation_mark_replica_identity(rel, stmt->identity_type, InvalidOid, true);
        return;
    }
    else if (stmt->identity_type == REPLICA_IDENTITY_INDEX)
    {
         /* fallthrough */ ;
    }
    else
        elog(ERROR, "unexpected identity type %u", stmt->identity_type);
 
    /* Check that the index exists */
    indexOid = get_relname_relid(stmt->name, rel->rd_rel->relnamespace);
    if (!OidIsValid(indexOid))
        ereport(ERROR,
                (errcode(ERRCODE_UNDEFINED_OBJECT),
                 errmsg("index \"%s\" for table \"%s\" does not exist",
                        stmt->name, RelationGetRelationName(rel))));
 
    indexRel = index_open(indexOid, ShareLock);
 
    /* Check that the index is on the relation we're altering. */
    if (indexRel->rd_index == NULL ||
        indexRel->rd_index->indrelid != RelationGetRelid(rel))
        ereport(ERROR,
                (errcode(ERRCODE_WRONG_OBJECT_TYPE),
                 errmsg("\"%s\" is not an index for table \"%s\"",
                        RelationGetRelationName(indexRel),
                        RelationGetRelationName(rel))));
    /* The AM must support uniqueness, and the index must in fact be unique. */
    if (!indexRel->rd_indam->amcanunique ||
        !indexRel->rd_index->indisunique)
        ereport(ERROR,
                (errcode(ERRCODE_WRONG_OBJECT_TYPE),
                 errmsg("cannot use non-unique index \"%s\" as replica identity",
                        RelationGetRelationName(indexRel))));
    /* Deferred indexes are not guaranteed to be always unique. */
    if (!indexRel->rd_index->indimmediate)
        ereport(ERROR,
                (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                 errmsg("cannot use non-immediate index \"%s\" as replica identity",
                        RelationGetRelationName(indexRel))));
    /* Expression indexes aren't supported. */
    if (RelationGetIndexExpressions(indexRel) != NIL)
        ereport(ERROR,
                (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                 errmsg("cannot use expression index \"%s\" as replica identity",
                        RelationGetRelationName(indexRel))));
    /* Predicate indexes aren't supported. */
    if (RelationGetIndexPredicate(indexRel) != NIL)
        ereport(ERROR,
                (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                 errmsg("cannot use partial index \"%s\" as replica identity",
                        RelationGetRelationName(indexRel))));
 
    /* Check index for nullable columns. */
    for (key = 0; key < IndexRelationGetNumberOfKeyAttributes(indexRel); key++)
    {
        int16       attno = indexRel->rd_index->indkey.values[key];
        Form_pg_attribute attr;
 
        /*
         * Reject any other system columns.  (Going forward, we'll disallow
         * indexes containing such columns in the first place, but they might
         * exist in older branches.)
         */
        if (attno <= 0)
            ereport(ERROR,
                    (errcode(ERRCODE_INVALID_COLUMN_REFERENCE),
                     errmsg("index \"%s\" cannot be used as replica identity because column %d is a system column",
                            RelationGetRelationName(indexRel), attno)));
 
        attr = TupleDescAttr(rel->rd_att, attno - 1);
        if (!attr->attnotnull)
            ereport(ERROR,
                    (errcode(ERRCODE_WRONG_OBJECT_TYPE),
                     errmsg("index \"%s\" cannot be used as replica identity because column \"%s\" is nullable",
                            RelationGetRelationName(indexRel),
                            NameStr(attr->attname))));
    }
 
    /* This index is suitable for use as a replica identity. Mark it. */
    relation_mark_replica_identity(rel, stmt->identity_type, indexOid, true);
 
    index_close(indexRel, NoLock);
}

References IndexAmRoutine::amcanunique, elog, ereport, errcode(), errmsg(), ERROR, get_relname_relid(), index_close(), index_open(), IndexRelationGetNumberOfKeyAttributes, InvalidOid, sort-test::key, NameStr, NIL, NoLock, OidIsValid, RelationData::rd_att, RelationData::rd_indam, RelationData::rd_index, RelationData::rd_rel, relation_mark_replica_identity(), RelationGetIndexExpressions(), RelationGetIndexPredicate(), RelationGetRelationName, RelationGetRelid, ShareLock, stmt, and TupleDescAttr.

Referenced by ATExecCmd().

ATExecSetAccessMethodNoStorage()

static void ATExecSetAccessMethodNoStorage ( Relation  rel, Oid  newAccessMethod  )

static

Definition at line 15435 of file tablecmds.c.

{
    Relation    pg_class;
    Oid         oldAccessMethodId;
    HeapTuple   tuple;
    Form_pg_class rd_rel;
    Oid         reloid = RelationGetRelid(rel);
 
    /*
     * Shouldn't be called on relations having storage; these are processed in
     * phase 3.
     */
    Assert(!RELKIND_HAS_STORAGE(rel->rd_rel->relkind));
 
    /* Get a modifiable copy of the relation's pg_class row. */
    pg_class = table_open(RelationRelationId, RowExclusiveLock);
 
    tuple = SearchSysCacheCopy1(RELOID, ObjectIdGetDatum(reloid));
    if (!HeapTupleIsValid(tuple))
        elog(ERROR, "cache lookup failed for relation %u", reloid);
    rd_rel = (Form_pg_class) GETSTRUCT(tuple);
 
    /* Update the pg_class row. */
    oldAccessMethodId = rd_rel->relam;
    rd_rel->relam = newAccessMethodId;
 
    /* Leave if no update required */
    if (rd_rel->relam == oldAccessMethodId)
    {
        heap_freetuple(tuple);
        table_close(pg_class, RowExclusiveLock);
        return;
    }
 
    CatalogTupleUpdate(pg_class, &tuple->t_self, tuple);
 
    /*
     * Update the dependency on the new access method.  No dependency is added
     * if the new access method is InvalidOid (default case).  Be very careful
     * that this has to compare the previous value stored in pg_class with the
     * new one.
     */
    if (!OidIsValid(oldAccessMethodId) && OidIsValid(rd_rel->relam))
    {
        ObjectAddress relobj,
                    referenced;
 
        /*
         * New access method is defined and there was no dependency
         * previously, so record a new one.
         */
        ObjectAddressSet(relobj, RelationRelationId, reloid);
        ObjectAddressSet(referenced, AccessMethodRelationId, rd_rel->relam);
        recordDependencyOn(&relobj, &referenced, DEPENDENCY_NORMAL);
    }
    else if (OidIsValid(oldAccessMethodId) &&
             !OidIsValid(rd_rel->relam))
    {
        /*
         * There was an access method defined, and no new one, so just remove
         * the existing dependency.
         */
        deleteDependencyRecordsForClass(RelationRelationId, reloid,
                                        AccessMethodRelationId,
                                        DEPENDENCY_NORMAL);
    }
    else
    {
        Assert(OidIsValid(oldAccessMethodId) &&
               OidIsValid(rd_rel->relam));
 
        /* Both are valid, so update the dependency */
        changeDependencyFor(RelationRelationId, reloid,
                            AccessMethodRelationId,
                            oldAccessMethodId, rd_rel->relam);
    }
 
    /* make the relam and dependency changes visible */
    CommandCounterIncrement();
 
    InvokeObjectPostAlterHook(RelationRelationId, RelationGetRelid(rel), 0);
 
    heap_freetuple(tuple);
    table_close(pg_class, RowExclusiveLock);
}

References Assert, CatalogTupleUpdate(), changeDependencyFor(), CommandCounterIncrement(), deleteDependencyRecordsForClass(), DEPENDENCY_NORMAL, elog, ERROR, GETSTRUCT, heap_freetuple(), HeapTupleIsValid, InvokeObjectPostAlterHook, ObjectAddressSet, ObjectIdGetDatum(), OidIsValid, RelationData::rd_rel, recordDependencyOn(), RelationGetRelid, RowExclusiveLock, SearchSysCacheCopy1, HeapTupleData::t_self, table_close(), and table_open().

Referenced by ATExecCmd().

ATExecSetAttNotNull()

static ObjectAddress ATExecSetAttNotNull ( List **  wqueue, Relation  rel, const char *  colName, LOCKMODE  lockmode  )

static

Definition at line 8020 of file tablecmds.c.

{
    AttrNumber  attnum;
    ObjectAddress address = InvalidObjectAddress;
 
    attnum = get_attnum(RelationGetRelid(rel), colName);
    if (attnum == InvalidAttrNumber)
        ereport(ERROR,
                errcode(ERRCODE_UNDEFINED_COLUMN),
                errmsg("column \"%s\" of relation \"%s\" does not exist",
                       colName, RelationGetRelationName(rel)));
 
    /*
     * Make the change, if necessary, and only if so report the column as
     * changed
     */
    if (set_attnotnull(wqueue, rel, attnum, false, lockmode))
        ObjectAddressSubSet(address, RelationRelationId,
                            RelationGetRelid(rel), attnum);
 
    return address;
}

References attnum, ereport, errcode(), errmsg(), ERROR, get_attnum(), InvalidAttrNumber, InvalidObjectAddress, ObjectAddressSubSet, RelationGetRelationName, RelationGetRelid, and set_attnotnull().

Referenced by ATExecCmd().

ATExecSetCompression()

static ObjectAddress ATExecSetCompression ( Relation  rel, const char *  column, Node *  newValue, LOCKMODE  lockmode  )

static

Definition at line 17677 of file tablecmds.c.

{
    Relation    attrel;
    HeapTuple   tuple;
    Form_pg_attribute atttableform;
    AttrNumber  attnum;
    char       *compression;
    char        cmethod;
    ObjectAddress address;
 
    compression = strVal(newValue);
 
    attrel = table_open(AttributeRelationId, RowExclusiveLock);
 
    /* copy the cache entry so we can scribble on it below */
    tuple = SearchSysCacheCopyAttName(RelationGetRelid(rel), column);
    if (!HeapTupleIsValid(tuple))
        ereport(ERROR,
                (errcode(ERRCODE_UNDEFINED_COLUMN),
                 errmsg("column \"%s\" of relation \"%s\" does not exist",
                        column, RelationGetRelationName(rel))));
 
    /* prevent them from altering a system attribute */
    atttableform = (Form_pg_attribute) GETSTRUCT(tuple);
    attnum = atttableform->attnum;
    if (attnum <= 0)
        ereport(ERROR,
                (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                 errmsg("cannot alter system column \"%s\"", column)));
 
    /*
     * Check that column type is compressible, then get the attribute
     * compression method code
     */
    cmethod = GetAttributeCompression(atttableform->atttypid, compression);
 
    /* update pg_attribute entry */
    atttableform->attcompression = cmethod;
    CatalogTupleUpdate(attrel, &tuple->t_self, tuple);
 
    InvokeObjectPostAlterHook(RelationRelationId,
                              RelationGetRelid(rel),
                              attnum);
 
    /*
     * Apply the change to indexes as well (only for simple index columns,
     * matching behavior of index.c ConstructTupleDescriptor()).
     */
    SetIndexStorageProperties(rel, attrel, attnum,
                              false, 0,
                              true, cmethod,
                              lockmode);
 
    heap_freetuple(tuple);
 
    table_close(attrel, RowExclusiveLock);
 
    /* make changes visible */
    CommandCounterIncrement();
 
    ObjectAddressSubSet(address, RelationRelationId,
                        RelationGetRelid(rel), attnum);
    return address;
}

References attnum, CatalogTupleUpdate(), CommandCounterIncrement(), ereport, errcode(), errmsg(), ERROR, GetAttributeCompression(), GETSTRUCT, heap_freetuple(), HeapTupleIsValid, InvokeObjectPostAlterHook, ObjectAddressSubSet, RelationGetRelationName, RelationGetRelid, RowExclusiveLock, SearchSysCacheCopyAttName(), SetIndexStorageProperties(), strVal, HeapTupleData::t_self, table_close(), and table_open().

Referenced by ATExecCmd().

ATExecSetExpression()

static ObjectAddress ATExecSetExpression ( AlteredTableInfo *  tab, Relation  rel, const char *  colName, Node *  newExpr, LOCKMODE  lockmode  )

static

Definition at line 8538 of file tablecmds.c.

{
    HeapTuple   tuple;
    Form_pg_attribute attTup;
    AttrNumber  attnum;
    Oid         attrdefoid;
    ObjectAddress address;
    Expr       *defval;
    NewColumnValue *newval;
    RawColumnDefault *rawEnt;
 
    tuple = SearchSysCacheAttName(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;
 
    if (attnum <= 0)
        ereport(ERROR,
                (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                 errmsg("cannot alter system column \"%s\"",
                        colName)));
 
    if (attTup->attgenerated != ATTRIBUTE_GENERATED_STORED)
        ereport(ERROR,
                (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
                 errmsg("column \"%s\" of relation \"%s\" is not a generated column",
                        colName, RelationGetRelationName(rel))));
    ReleaseSysCache(tuple);
 
    /*
     * Clear all the missing values if we're rewriting the table, since this
     * renders them pointless.
     */
    RelationClearMissing(rel);
 
    /* make sure we don't conflict with later attribute modifications */
    CommandCounterIncrement();
 
    /*
     * Find everything that depends on the column (constraints, indexes, etc),
     * and record enough information to let us recreate the objects after
     * rewrite.
     */
    RememberAllDependentForRebuilding(tab, AT_SetExpression, rel, attnum, colName);
 
    /*
     * Drop the dependency records of the GENERATED expression, in particular
     * its INTERNAL dependency on the column, which would otherwise cause
     * dependency.c to refuse to perform the deletion.
     */
    attrdefoid = GetAttrDefaultOid(RelationGetRelid(rel), attnum);
    if (!OidIsValid(attrdefoid))
        elog(ERROR, "could not find attrdef tuple for relation %u attnum %d",
             RelationGetRelid(rel), attnum);
    (void) deleteDependencyRecordsFor(AttrDefaultRelationId, attrdefoid, false);
 
    /* Make above changes visible */
    CommandCounterIncrement();
 
    /*
     * Get rid of the GENERATED expression itself.  We use RESTRICT here for
     * safety, but at present we do not expect anything to depend on the
     * expression.
     */
    RemoveAttrDefault(RelationGetRelid(rel), attnum, DROP_RESTRICT,
                      false, false);
 
    /* Prepare to store the new expression, in the catalogs */
    rawEnt = (RawColumnDefault *) palloc(sizeof(RawColumnDefault));
    rawEnt->attnum = attnum;
    rawEnt->raw_default = newExpr;
    rawEnt->missingMode = false;
    rawEnt->generated = ATTRIBUTE_GENERATED_STORED;
 
    /* Store the generated expression */
    AddRelationNewConstraints(rel, list_make1(rawEnt), NIL,
                              false, true, false, NULL);
 
    /* Make above new expression visible */
    CommandCounterIncrement();
 
    /* Prepare for table rewrite */
    defval = (Expr *) build_column_default(rel, attnum);
 
    newval = (NewColumnValue *) palloc0(sizeof(NewColumnValue));
    newval->attnum = attnum;
    newval->expr = expression_planner(defval);
    newval->is_generated = true;
 
    tab->newvals = lappend(tab->newvals, newval);
    tab->rewrite |= AT_REWRITE_DEFAULT_VAL;
 
    /* Drop any pg_statistic entry for the column */
    RemoveStatistics(RelationGetRelid(rel), attnum);
 
    InvokeObjectPostAlterHook(RelationRelationId,
                              RelationGetRelid(rel), attnum);
 
    ObjectAddressSubSet(address, RelationRelationId,
                        RelationGetRelid(rel), attnum);
    return address;
}

References AddRelationNewConstraints(), AT_REWRITE_DEFAULT_VAL, AT_SetExpression, RawColumnDefault::attnum, attnum, build_column_default(), CommandCounterIncrement(), deleteDependencyRecordsFor(), DROP_RESTRICT, elog, ereport, errcode(), errmsg(), ERROR, expression_planner(), RawColumnDefault::generated, GetAttrDefaultOid(), GETSTRUCT, HeapTupleIsValid, InvokeObjectPostAlterHook, lappend(), list_make1, RawColumnDefault::missingMode, newval, AlteredTableInfo::newvals, NIL, ObjectAddressSubSet, OidIsValid, palloc(), palloc0(), RawColumnDefault::raw_default, RelationClearMissing(), RelationGetRelationName, RelationGetRelid, ReleaseSysCache(), RememberAllDependentForRebuilding(), RemoveAttrDefault(), RemoveStatistics(), AlteredTableInfo::rewrite, and SearchSysCacheAttName().

Referenced by ATExecCmd().

ATExecSetIdentity()

static ObjectAddress ATExecSetIdentity ( Relation  rel, const char *  colName, Node *  def, LOCKMODE  lockmode, bool  recurse, bool  recursing  )

static

Definition at line 8307 of file tablecmds.c.

{
    ListCell   *option;
    DefElem    *generatedEl = NULL;
    HeapTuple   tuple;
    Form_pg_attribute attTup;
    AttrNumber  attnum;
    Relation    attrelation;
    ObjectAddress address;
    bool        ispartitioned;
 
    ispartitioned = (rel->rd_rel->relkind == RELKIND_PARTITIONED_TABLE);
    if (ispartitioned && !recurse)
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_TABLE_DEFINITION),
                 errmsg("cannot change identity column of only the partitioned table"),
                 errhint("Do not specify the ONLY keyword.")));
 
    if (rel->rd_rel->relispartition && !recursing)
        ereport(ERROR,
                errcode(ERRCODE_INVALID_TABLE_DEFINITION),
                errmsg("cannot change identity column of a partition"));
 
    foreach(option, castNode(List, def))
    {
        DefElem    *defel = lfirst_node(DefElem, option);
 
        if (strcmp(defel->defname, "generated") == 0)
        {
            if (generatedEl)
                ereport(ERROR,
                        (errcode(ERRCODE_SYNTAX_ERROR),
                         errmsg("conflicting or redundant options")));
            generatedEl = defel;
        }
        else
            elog(ERROR, "option \"%s\" not recognized",
                 defel->defname);
    }
 
    /*
     * Even if there is nothing to change here, we run all the checks.  There
     * will be a subsequent ALTER SEQUENCE that relies on everything being
     * there.
     */
 
    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;
 
    if (attnum <= 0)
        ereport(ERROR,
                (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                 errmsg("cannot alter system column \"%s\"",
                        colName)));
 
    if (!attTup->attidentity)
        ereport(ERROR,
                (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
                 errmsg("column \"%s\" of relation \"%s\" is not an identity column",
                        colName, RelationGetRelationName(rel))));
 
    if (generatedEl)
    {
        attTup->attidentity = defGetInt32(generatedEl);
        CatalogTupleUpdate(attrelation, &tuple->t_self, tuple);
 
        InvokeObjectPostAlterHook(RelationRelationId,
                                  RelationGetRelid(rel),
                                  attTup->attnum);
        ObjectAddressSubSet(address, RelationRelationId,
                            RelationGetRelid(rel), attnum);
    }
    else
        address = InvalidObjectAddress;
 
    heap_freetuple(tuple);
    table_close(attrelation, RowExclusiveLock);
 
    /*
     * Recurse to propagate the identity change to partitions. Identity is not
     * inherited in regular inheritance children.
     */
    if (generatedEl && recurse && ispartitioned)
    {
        List       *children;
        ListCell   *lc;
 
        children = find_inheritance_children(RelationGetRelid(rel), lockmode);
 
        foreach(lc, children)
        {
            Relation    childrel;
 
            childrel = table_open(lfirst_oid(lc), NoLock);
            ATExecSetIdentity(childrel, colName, def, lockmode, recurse, true);
            table_close(childrel, NoLock);
        }
    }
 
    return address;
}

References attnum, castNode, CatalogTupleUpdate(), defGetInt32(), DefElem::defname, elog, ereport, errcode(), errhint(), errmsg(), ERROR, find_inheritance_children(), GETSTRUCT, heap_freetuple(), HeapTupleIsValid, InvalidObjectAddress, InvokeObjectPostAlterHook, lfirst_node, lfirst_oid, NoLock, ObjectAddressSubSet, RelationData::rd_rel, RelationGetRelationName, RelationGetRelid, RowExclusiveLock, SearchSysCacheCopyAttName(), HeapTupleData::t_self, table_close(), and table_open().

Referenced by ATExecCmd().

ATExecSetNotNull()

static ObjectAddress ATExecSetNotNull ( List **  wqueue, Relation  rel, char *  constrname, char *  colName, bool  recurse, bool  recursing, List **  readyRels, LOCKMODE  lockmode  )

static

Definition at line 7816 of file tablecmds.c.

{
    HeapTuple   tuple;
    Relation    constr_rel;
    ScanKeyData skey;
    SysScanDesc conscan;
    AttrNumber  attnum;
    ObjectAddress address;
    Constraint *constraint;
    CookedConstraint *ccon;
    List       *cooked;
    bool        is_no_inherit = false;
    List       *ready = NIL;
 
    /* Guard against stack overflow due to overly deep inheritance tree. */
    check_stack_depth();
 
    /*
     * In cases of multiple inheritance, we might visit the same child more
     * than once.  In the topmost call, set up a list that we fill with all
     * visited relations, to skip those.
     */
    if (readyRels == NULL)
    {
        Assert(!recursing);
        readyRels = &ready;
    }
    if (list_member_oid(*readyRels, RelationGetRelid(rel)))
        return InvalidObjectAddress;
    *readyRels = lappend_oid(*readyRels, RelationGetRelid(rel));
 
    /* At top level, permission check was done in ATPrepCmd, else do it */
    if (recursing)
    {
        ATSimplePermissions(AT_AddConstraint, rel, ATT_TABLE | ATT_FOREIGN_TABLE);
        Assert(conName != NULL);
    }
 
    attnum = get_attnum(RelationGetRelid(rel), colName);
    if (attnum == InvalidAttrNumber)
        ereport(ERROR,
                (errcode(ERRCODE_UNDEFINED_COLUMN),
                 errmsg("column \"%s\" of relation \"%s\" does not exist",
                        colName, RelationGetRelationName(rel))));
 
    /* Prevent them from altering a system attribute */
    if (attnum <= 0)
        ereport(ERROR,
                (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                 errmsg("cannot alter system column \"%s\"",
                        colName)));
 
    /* See if there's already a constraint */
    constr_rel = table_open(ConstraintRelationId, RowExclusiveLock);
    ScanKeyInit(&skey,
                Anum_pg_constraint_conrelid,
                BTEqualStrategyNumber, F_OIDEQ,
                ObjectIdGetDatum(RelationGetRelid(rel)));
    conscan = systable_beginscan(constr_rel, ConstraintRelidTypidNameIndexId, true,
                                 NULL, 1, &skey);
 
    while (HeapTupleIsValid(tuple = systable_getnext(conscan)))
    {
        Form_pg_constraint conForm = (Form_pg_constraint) GETSTRUCT(tuple);
        bool        changed = false;
        HeapTuple   copytup;
 
        if (conForm->contype != CONSTRAINT_NOTNULL)
            continue;
 
        if (extractNotNullColumn(tuple) != attnum)
            continue;
 
        copytup = heap_copytuple(tuple);
        conForm = (Form_pg_constraint) GETSTRUCT(copytup);
 
        /*
         * If we find an appropriate constraint, we're almost done, but just
         * need to change some properties on it: if we're recursing, increment
         * coninhcount; if not, set conislocal if not already set.
         */
        if (recursing)
        {
            conForm->coninhcount++;
            changed = true;
        }
        else if (!conForm->conislocal)
        {
            conForm->conislocal = true;
            changed = true;
        }
 
        if (changed)
        {
            CatalogTupleUpdate(constr_rel, &copytup->t_self, copytup);
            ObjectAddressSet(address, ConstraintRelationId, conForm->oid);
        }
 
        systable_endscan(conscan);
        table_close(constr_rel, RowExclusiveLock);
 
        if (changed)
            return address;
        else
            return InvalidObjectAddress;
    }
 
    systable_endscan(conscan);
    table_close(constr_rel, RowExclusiveLock);
 
    /*
     * If we're asked not to recurse, and children exist, raise an error for
     * partitioned tables.  For inheritance, we act as if NO INHERIT had been
     * specified.
     */
    if (!recurse &&
        find_inheritance_children(RelationGetRelid(rel),
                                  NoLock) != NIL)
    {
        if (rel->rd_rel->relkind == RELKIND_PARTITIONED_TABLE)
            ereport(ERROR,
                    errcode(ERRCODE_INVALID_TABLE_DEFINITION),
                    errmsg("constraint must be added to child tables too"),
                    errhint("Do not specify the ONLY keyword."));
        else
            is_no_inherit = true;
    }
 
    /*
     * No constraint exists; we must add one.  First determine a name to use,
     * if we haven't already.
     */
    if (!recursing)
    {
        Assert(conName == NULL);
        conName = ChooseConstraintName(RelationGetRelationName(rel),
                                       colName, "not_null",
                                       RelationGetNamespace(rel),
                                       NIL);
    }
    constraint = makeNode(Constraint);
    constraint->contype = CONSTR_NOTNULL;
    constraint->conname = conName;
    constraint->deferrable = false;
    constraint->initdeferred = false;
    constraint->location = -1;
    constraint->keys = list_make1(makeString(colName));
    constraint->is_no_inherit = is_no_inherit;
    constraint->inhcount = recursing ? 1 : 0;
    constraint->skip_validation = false;
    constraint->initially_valid = true;
 
    /* and do it */
    cooked = AddRelationNewConstraints(rel, NIL, list_make1(constraint),
                                       false, !recursing, false, NULL);
    ccon = linitial(cooked);
    ObjectAddressSet(address, ConstraintRelationId, ccon->conoid);
 
    InvokeObjectPostAlterHook(RelationRelationId,
                              RelationGetRelid(rel), attnum);
 
    /*
     * Mark pg_attribute.attnotnull for the column. Tell that function not to
     * recurse, because we're going to do it here.
     */
    set_attnotnull(wqueue, rel, attnum, false, lockmode);
 
    /*
     * Recurse to propagate the constraint to children that don't have one.
     */
    if (recurse)
    {
        List       *children;
        ListCell   *lc;
 
        children = find_inheritance_children(RelationGetRelid(rel),
                                             lockmode);
 
        foreach(lc, children)
        {
            Relation    childrel;
 
            childrel = table_open(lfirst_oid(lc), NoLock);
 
            ATExecSetNotNull(wqueue, childrel,
                             conName, colName, recurse, true,
                             readyRels, lockmode);
 
            table_close(childrel, NoLock);
        }
    }
 
    return address;
}

References AddRelationNewConstraints(), Assert, AT_AddConstraint, ATSimplePermissions(), ATT_FOREIGN_TABLE, ATT_TABLE, attnum, BTEqualStrategyNumber, CatalogTupleUpdate(), check_stack_depth(), ChooseConstraintName(), Constraint::conname, CookedConstraint::conoid, CONSTR_NOTNULL, Constraint::contype, Constraint::deferrable, ereport, errcode(), errhint(), errmsg(), ERROR, extractNotNullColumn(), find_inheritance_children(), get_attnum(), GETSTRUCT, heap_copytuple(), HeapTupleIsValid, Constraint::inhcount, Constraint::initdeferred, Constraint::initially_valid, InvalidAttrNumber, InvalidObjectAddress, InvokeObjectPostAlterHook, Constraint::is_no_inherit, Constraint::keys, lappend_oid(), lfirst_oid, linitial, list_make1, list_member_oid(), Constraint::location, makeNode, makeString(), NIL, NoLock, ObjectAddressSet, ObjectIdGetDatum(), RelationData::rd_rel, RelationGetNamespace, RelationGetRelationName, RelationGetRelid, RowExclusiveLock, ScanKeyInit(), set_attnotnull(), Constraint::skip_validation, systable_beginscan(), systable_endscan(), systable_getnext(), HeapTupleData::t_self, table_close(), and table_open().

Referenced by ATExecCmd().

ATExecSetOptions()

static ObjectAddress ATExecSetOptions ( Relation  rel, const char *  colName, Node *  options, bool  isReset, LOCKMODE  lockmode  )

static

Definition at line 8923 of file tablecmds.c.

{
    Relation    attrelation;
    HeapTuple   tuple,
                newtuple;
    Form_pg_attribute attrtuple;
    AttrNumber  attnum;
    Datum       datum,
                newOptions;
    bool        isnull;
    ObjectAddress address;
    Datum       repl_val[Natts_pg_attribute];
    bool        repl_null[Natts_pg_attribute];
    bool        repl_repl[Natts_pg_attribute];
 
    attrelation = table_open(AttributeRelationId, RowExclusiveLock);
 
    tuple = SearchSysCacheAttName(RelationGetRelid(rel), colName);
 
    if (!HeapTupleIsValid(tuple))
        ereport(ERROR,
                (errcode(ERRCODE_UNDEFINED_COLUMN),
                 errmsg("column \"%s\" of relation \"%s\" does not exist",
                        colName, RelationGetRelationName(rel))));
    attrtuple = (Form_pg_attribute) GETSTRUCT(tuple);
 
    attnum = attrtuple->attnum;
    if (attnum <= 0)
        ereport(ERROR,
                (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                 errmsg("cannot alter system column \"%s\"",
                        colName)));
 
    /* Generate new proposed attoptions (text array) */
    datum = SysCacheGetAttr(ATTNAME, tuple, Anum_pg_attribute_attoptions,
                            &isnull);
    newOptions = transformRelOptions(isnull ? (Datum) 0 : datum,
                                     castNode(List, options), NULL, NULL,
                                     false, isReset);
    /* Validate new options */
    (void) attribute_reloptions(newOptions, true);
 
    /* Build new tuple. */
    memset(repl_null, false, sizeof(repl_null));
    memset(repl_repl, false, sizeof(repl_repl));
    if (newOptions != (Datum) 0)
        repl_val[Anum_pg_attribute_attoptions - 1] = newOptions;
    else
        repl_null[Anum_pg_attribute_attoptions - 1] = true;
    repl_repl[Anum_pg_attribute_attoptions - 1] = true;
    newtuple = heap_modify_tuple(tuple, RelationGetDescr(attrelation),
                                 repl_val, repl_null, repl_repl);
 
    /* Update system catalog. */
    CatalogTupleUpdate(attrelation, &newtuple->t_self, newtuple);
 
    InvokeObjectPostAlterHook(RelationRelationId,
                              RelationGetRelid(rel),
                              attrtuple->attnum);
    ObjectAddressSubSet(address, RelationRelationId,
                        RelationGetRelid(rel), attnum);
 
    heap_freetuple(newtuple);
 
    ReleaseSysCache(tuple);
 
    table_close(attrelation, RowExclusiveLock);
 
    return address;
}

References attnum, attribute_reloptions(), castNode, CatalogTupleUpdate(), ereport, errcode(), errmsg(), ERROR, GETSTRUCT, heap_freetuple(), heap_modify_tuple(), HeapTupleIsValid, InvokeObjectPostAlterHook, ObjectAddressSubSet, RelationGetDescr, RelationGetRelationName, RelationGetRelid, ReleaseSysCache(), RowExclusiveLock, SearchSysCacheAttName(), SysCacheGetAttr(), HeapTupleData::t_self, table_close(), table_open(), and transformRelOptions().

Referenced by ATExecCmd().

ATExecSetRelOptions()

static void ATExecSetRelOptions ( Relation  rel, List *  defList, AlterTableType  operation, LOCKMODE  lockmode  )

static

Definition at line 15555 of file tablecmds.c.

{
    Oid         relid;
    Relation    pgclass;
    HeapTuple   tuple;
    HeapTuple   newtuple;
    Datum       datum;
    bool        isnull;
    Datum       newOptions;
    Datum       repl_val[Natts_pg_class];
    bool        repl_null[Natts_pg_class];
    bool        repl_repl[Natts_pg_class];
    static char *validnsps[] = HEAP_RELOPT_NAMESPACES;
 
    if (defList == NIL && operation != AT_ReplaceRelOptions)
        return;                 /* nothing to do */
 
    pgclass = table_open(RelationRelationId, RowExclusiveLock);
 
    /* Fetch heap tuple */
    relid = RelationGetRelid(rel);
    tuple = SearchSysCache1(RELOID, ObjectIdGetDatum(relid));
    if (!HeapTupleIsValid(tuple))
        elog(ERROR, "cache lookup failed for relation %u", relid);
 
    if (operation == AT_ReplaceRelOptions)
    {
        /*
         * If we're supposed to replace the reloptions list, we just pretend
         * there were none before.
         */
        datum = (Datum) 0;
        isnull = true;
    }
    else
    {
        /* Get the old reloptions */
        datum = SysCacheGetAttr(RELOID, tuple, Anum_pg_class_reloptions,
                                &isnull);
    }
 
    /* Generate new proposed reloptions (text array) */
    newOptions = transformRelOptions(isnull ? (Datum) 0 : datum,
                                     defList, NULL, validnsps, false,
                                     operation == AT_ResetRelOptions);
 
    /* Validate */
    switch (rel->rd_rel->relkind)
    {
        case RELKIND_RELATION:
        case RELKIND_TOASTVALUE:
        case RELKIND_MATVIEW:
            (void) heap_reloptions(rel->rd_rel->relkind, newOptions, true);
            break;
        case RELKIND_PARTITIONED_TABLE:
            (void) partitioned_table_reloptions(newOptions, true);
            break;
        case RELKIND_VIEW:
            (void) view_reloptions(newOptions, true);
            break;
        case RELKIND_INDEX:
        case RELKIND_PARTITIONED_INDEX:
            (void) index_reloptions(rel->rd_indam->amoptions, newOptions, true);
            break;
        default:
            ereport(ERROR,
                    (errcode(ERRCODE_WRONG_OBJECT_TYPE),
                     errmsg("cannot set options for relation \"%s\"",
                            RelationGetRelationName(rel)),
                     errdetail_relkind_not_supported(rel->rd_rel->relkind)));
            break;
    }
 
    /* Special-case validation of view options */
    if (rel->rd_rel->relkind == RELKIND_VIEW)
    {
        Query      *view_query = get_view_query(rel);
        List       *view_options = untransformRelOptions(newOptions);
        ListCell   *cell;
        bool        check_option = false;
 
        foreach(cell, view_options)
        {
            DefElem    *defel = (DefElem *) lfirst(cell);
 
            if (strcmp(defel->defname, "check_option") == 0)
                check_option = true;
        }
 
        /*
         * If the check option is specified, look to see if the view is
         * actually auto-updatable or not.
         */
        if (check_option)
        {
            const char *view_updatable_error =
                view_query_is_auto_updatable(view_query, true);
 
            if (view_updatable_error)
                ereport(ERROR,
                        (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                         errmsg("WITH CHECK OPTION is supported only on automatically updatable views"),
                         errhint("%s", _(view_updatable_error))));
        }
    }
 
    /*
     * All we need do here is update the pg_class row; the new options will be
     * propagated into relcaches during post-commit cache inval.
     */
    memset(repl_val, 0, sizeof(repl_val));
    memset(repl_null, false, sizeof(repl_null));
    memset(repl_repl, false, sizeof(repl_repl));
 
    if (newOptions != (Datum) 0)
        repl_val[Anum_pg_class_reloptions - 1] = newOptions;
    else
        repl_null[Anum_pg_class_reloptions - 1] = true;
 
    repl_repl[Anum_pg_class_reloptions - 1] = true;
 
    newtuple = heap_modify_tuple(tuple, RelationGetDescr(pgclass),
                                 repl_val, repl_null, repl_repl);
 
    CatalogTupleUpdate(pgclass, &newtuple->t_self, newtuple);
 
    InvokeObjectPostAlterHook(RelationRelationId, RelationGetRelid(rel), 0);
 
    heap_freetuple(newtuple);
 
    ReleaseSysCache(tuple);
 
    /* repeat the whole exercise for the toast table, if there's one */
    if (OidIsValid(rel->rd_rel->reltoastrelid))
    {
        Relation    toastrel;
        Oid         toastid = rel->rd_rel->reltoastrelid;
 
        toastrel = table_open(toastid, lockmode);
 
        /* Fetch heap tuple */
        tuple = SearchSysCache1(RELOID, ObjectIdGetDatum(toastid));
        if (!HeapTupleIsValid(tuple))
            elog(ERROR, "cache lookup failed for relation %u", toastid);
 
        if (operation == AT_ReplaceRelOptions)
        {
            /*
             * If we're supposed to replace the reloptions list, we just
             * pretend there were none before.
             */
            datum = (Datum) 0;
            isnull = true;
        }
        else
        {
            /* Get the old reloptions */
            datum = SysCacheGetAttr(RELOID, tuple, Anum_pg_class_reloptions,
                                    &isnull);
        }
 
        newOptions = transformRelOptions(isnull ? (Datum) 0 : datum,
                                         defList, "toast", validnsps, false,
                                         operation == AT_ResetRelOptions);
 
        (void) heap_reloptions(RELKIND_TOASTVALUE, newOptions, true);
 
        memset(repl_val, 0, sizeof(repl_val));
        memset(repl_null, false, sizeof(repl_null));
        memset(repl_repl, false, sizeof(repl_repl));
 
        if (newOptions != (Datum) 0)
            repl_val[Anum_pg_class_reloptions - 1] = newOptions;
        else
            repl_null[Anum_pg_class_reloptions - 1] = true;
 
        repl_repl[Anum_pg_class_reloptions - 1] = true;
 
        newtuple = heap_modify_tuple(tuple, RelationGetDescr(pgclass),
                                     repl_val, repl_null, repl_repl);
 
        CatalogTupleUpdate(pgclass, &newtuple->t_self, newtuple);
 
        InvokeObjectPostAlterHookArg(RelationRelationId,
                                     RelationGetRelid(toastrel), 0,
                                     InvalidOid, true);
 
        heap_freetuple(newtuple);
 
        ReleaseSysCache(tuple);
 
        table_close(toastrel, NoLock);
    }
 
    table_close(pgclass, RowExclusiveLock);
}

References _, IndexAmRoutine::amoptions, AT_ReplaceRelOptions, AT_ResetRelOptions, CatalogTupleUpdate(), DefElem::defname, elog, ereport, errcode(), errdetail_relkind_not_supported(), errhint(), errmsg(), ERROR, get_view_query(), heap_freetuple(), heap_modify_tuple(), HEAP_RELOPT_NAMESPACES, heap_reloptions(), HeapTupleIsValid, index_reloptions(), InvalidOid, InvokeObjectPostAlterHook, InvokeObjectPostAlterHookArg, lfirst, NIL, NoLock, ObjectIdGetDatum(), OidIsValid, partitioned_table_reloptions(), RelationData::rd_indam, RelationData::rd_rel, RelationGetDescr, RelationGetRelationName, RelationGetRelid, ReleaseSysCache(), RowExclusiveLock, SearchSysCache1(), SysCacheGetAttr(), HeapTupleData::t_self, table_close(), table_open(), transformRelOptions(), untransformRelOptions(), view_query_is_auto_updatable(), and view_reloptions().

Referenced by ATExecCmd().

ATExecSetRowSecurity()

static void ATExecSetRowSecurity ( Relation  rel, bool  rls  )

static

Definition at line 17537 of file tablecmds.c.

{
    Relation    pg_class;
    Oid         relid;
    HeapTuple   tuple;
 
    relid = RelationGetRelid(rel);
 
    /* Pull the record for this relation and update it */
    pg_class = table_open(RelationRelationId, RowExclusiveLock);
 
    tuple = SearchSysCacheCopy1(RELOID, ObjectIdGetDatum(relid));
 
    if (!HeapTupleIsValid(tuple))
        elog(ERROR, "cache lookup failed for relation %u", relid);
 
    ((Form_pg_class) GETSTRUCT(tuple))->relrowsecurity = rls;
    CatalogTupleUpdate(pg_class, &tuple->t_self, tuple);
 
    InvokeObjectPostAlterHook(RelationRelationId,
                              RelationGetRelid(rel), 0);
 
    table_close(pg_class, RowExclusiveLock);
    heap_freetuple(tuple);
}

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

Referenced by ATExecCmd().

ATExecSetStatistics()

static ObjectAddress ATExecSetStatistics ( Relation  rel, const char *  colName, int16  colNum, Node *  newValue, LOCKMODE  lockmode  )

static

Definition at line 8788 of file tablecmds.c.

{
    int         newtarget = 0;
    bool        newtarget_default;
    Relation    attrelation;
    HeapTuple   tuple,
                newtuple;
    Form_pg_attribute attrtuple;
    AttrNumber  attnum;
    ObjectAddress address;
    Datum       repl_val[Natts_pg_attribute];
    bool        repl_null[Natts_pg_attribute];
    bool        repl_repl[Natts_pg_attribute];
 
    /*
     * We allow referencing columns by numbers only for indexes, since table
     * column numbers could contain gaps if columns are later dropped.
     */
    if (rel->rd_rel->relkind != RELKIND_INDEX &&
        rel->rd_rel->relkind != RELKIND_PARTITIONED_INDEX &&
        !colName)
        ereport(ERROR,
                (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                 errmsg("cannot refer to non-index column by number")));
 
    /* -1 was used in previous versions for the default setting */
    if (newValue && intVal(newValue) != -1)
    {
        newtarget = intVal(newValue);
        newtarget_default = false;
    }
    else
        newtarget_default = true;
 
    if (!newtarget_default)
    {
        /*
         * Limit target to a sane range
         */
        if (newtarget < 0)
        {
            ereport(ERROR,
                    (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                     errmsg("statistics target %d is too low",
                            newtarget)));
        }
        else if (newtarget > MAX_STATISTICS_TARGET)
        {
            newtarget = MAX_STATISTICS_TARGET;
            ereport(WARNING,
                    (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                     errmsg("lowering statistics target to %d",
                            newtarget)));
        }
    }
 
    attrelation = table_open(AttributeRelationId, RowExclusiveLock);
 
    if (colName)
    {
        tuple = SearchSysCacheAttName(RelationGetRelid(rel), colName);
 
        if (!HeapTupleIsValid(tuple))
            ereport(ERROR,
                    (errcode(ERRCODE_UNDEFINED_COLUMN),
                     errmsg("column \"%s\" of relation \"%s\" does not exist",
                            colName, RelationGetRelationName(rel))));
    }
    else
    {
        tuple = SearchSysCacheAttNum(RelationGetRelid(rel), colNum);
 
        if (!HeapTupleIsValid(tuple))
            ereport(ERROR,
                    (errcode(ERRCODE_UNDEFINED_COLUMN),
                     errmsg("column number %d of relation \"%s\" does not exist",
                            colNum, RelationGetRelationName(rel))));
    }
 
    attrtuple = (Form_pg_attribute) GETSTRUCT(tuple);
 
    attnum = attrtuple->attnum;
    if (attnum <= 0)
        ereport(ERROR,
                (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                 errmsg("cannot alter system column \"%s\"",
                        colName)));
 
    if (rel->rd_rel->relkind == RELKIND_INDEX ||
        rel->rd_rel->relkind == RELKIND_PARTITIONED_INDEX)
    {
        if (attnum > rel->rd_index->indnkeyatts)
            ereport(ERROR,
                    (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                     errmsg("cannot alter statistics on included column \"%s\" of index \"%s\"",
                            NameStr(attrtuple->attname), RelationGetRelationName(rel))));
        else if (rel->rd_index->indkey.values[attnum - 1] != 0)
            ereport(ERROR,
                    (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                     errmsg("cannot alter statistics on non-expression column \"%s\" of index \"%s\"",
                            NameStr(attrtuple->attname), RelationGetRelationName(rel)),
                     errhint("Alter statistics on table column instead.")));
    }
 
    /* Build new tuple. */
    memset(repl_null, false, sizeof(repl_null));
    memset(repl_repl, false, sizeof(repl_repl));
    if (!newtarget_default)
        repl_val[Anum_pg_attribute_attstattarget - 1] = newtarget;
    else
        repl_null[Anum_pg_attribute_attstattarget - 1] = true;
    repl_repl[Anum_pg_attribute_attstattarget - 1] = true;
    newtuple = heap_modify_tuple(tuple, RelationGetDescr(attrelation),
                                 repl_val, repl_null, repl_repl);
    CatalogTupleUpdate(attrelation, &tuple->t_self, newtuple);
 
    InvokeObjectPostAlterHook(RelationRelationId,
                              RelationGetRelid(rel),
                              attrtuple->attnum);
    ObjectAddressSubSet(address, RelationRelationId,
                        RelationGetRelid(rel), attnum);
 
    heap_freetuple(newtuple);
 
    ReleaseSysCache(tuple);
 
    table_close(attrelation, RowExclusiveLock);
 
    return address;
}

References attnum, CatalogTupleUpdate(), ereport, errcode(), errhint(), errmsg(), ERROR, GETSTRUCT, heap_freetuple(), heap_modify_tuple(), HeapTupleIsValid, intVal, InvokeObjectPostAlterHook, MAX_STATISTICS_TARGET, NameStr, ObjectAddressSubSet, RelationData::rd_index, RelationData::rd_rel, RelationGetDescr, RelationGetRelationName, RelationGetRelid, ReleaseSysCache(), RowExclusiveLock, SearchSysCacheAttName(), SearchSysCacheAttNum(), HeapTupleData::t_self, table_close(), table_open(), and WARNING.

Referenced by ATExecCmd().

ATExecSetStorage()

static ObjectAddress ATExecSetStorage ( Relation  rel, const char *  colName, Node *  newValue, LOCKMODE  lockmode  )

static

Definition at line 9065 of file tablecmds.c.

{
    Relation    attrelation;
    HeapTuple   tuple;
    Form_pg_attribute attrtuple;
    AttrNumber  attnum;
    ObjectAddress address;
 
    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))));
    attrtuple = (Form_pg_attribute) GETSTRUCT(tuple);
 
    attnum = attrtuple->attnum;
    if (attnum <= 0)
        ereport(ERROR,
                (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                 errmsg("cannot alter system column \"%s\"",
                        colName)));
 
    attrtuple->attstorage = GetAttributeStorage(attrtuple->atttypid, strVal(newValue));
 
    CatalogTupleUpdate(attrelation, &tuple->t_self, tuple);
 
    InvokeObjectPostAlterHook(RelationRelationId,
                              RelationGetRelid(rel),
                              attrtuple->attnum);
 
    /*
     * Apply the change to indexes as well (only for simple index columns,
     * matching behavior of index.c ConstructTupleDescriptor()).
     */
    SetIndexStorageProperties(rel, attrelation, attnum,
                              true, attrtuple->attstorage,
                              false, 0,
                              lockmode);
 
    heap_freetuple(tuple);
 
    table_close(attrelation, RowExclusiveLock);
 
    ObjectAddressSubSet(address, RelationRelationId,
                        RelationGetRelid(rel), attnum);
    return address;
}

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

Referenced by ATExecCmd().

ATExecSetTableSpace()

static void ATExecSetTableSpace ( Oid  tableOid, Oid  newTableSpace, LOCKMODE  lockmode  )

static

Definition at line 15758 of file tablecmds.c.

{
    Relation    rel;
    Oid         reltoastrelid;
    RelFileNumber newrelfilenumber;
    RelFileLocator newrlocator;
    List       *reltoastidxids = NIL;
    ListCell   *lc;
 
    /*
     * Need lock here in case we are recursing to toast table or index
     */
    rel = relation_open(tableOid, lockmode);
 
    /* Check first if relation can be moved to new tablespace */
    if (!CheckRelationTableSpaceMove(rel, newTableSpace))
    {
        InvokeObjectPostAlterHook(RelationRelationId,
                                  RelationGetRelid(rel), 0);
        relation_close(rel, NoLock);
        return;
    }
 
    reltoastrelid = rel->rd_rel->reltoastrelid;
    /* Fetch the list of indexes on toast relation if necessary */
    if (OidIsValid(reltoastrelid))
    {
        Relation    toastRel = relation_open(reltoastrelid, lockmode);
 
        reltoastidxids = RelationGetIndexList(toastRel);
        relation_close(toastRel, lockmode);
    }
 
    /*
     * Relfilenumbers are not unique in databases across tablespaces, so we
     * need to allocate a new one in the new tablespace.
     */
    newrelfilenumber = GetNewRelFileNumber(newTableSpace, NULL,
                                           rel->rd_rel->relpersistence);
 
    /* Open old and new relation */
    newrlocator = rel->rd_locator;
    newrlocator.relNumber = newrelfilenumber;
    newrlocator.spcOid = newTableSpace;
 
    /* hand off to AM to actually create new rel storage and copy the data */
    if (rel->rd_rel->relkind == RELKIND_INDEX)
    {
        index_copy_data(rel, newrlocator);
    }
    else
    {
        Assert(RELKIND_HAS_TABLE_AM(rel->rd_rel->relkind));
        table_relation_copy_data(rel, &newrlocator);
    }
 
    /*
     * Update the pg_class row.
     *
     * NB: This wouldn't work if ATExecSetTableSpace() were allowed to be
     * executed on pg_class or its indexes (the above copy wouldn't contain
     * the updated pg_class entry), but that's forbidden with
     * CheckRelationTableSpaceMove().
     */
    SetRelationTableSpace(rel, newTableSpace, newrelfilenumber);
 
    InvokeObjectPostAlterHook(RelationRelationId, RelationGetRelid(rel), 0);
 
    RelationAssumeNewRelfilelocator(rel);
 
    relation_close(rel, NoLock);
 
    /* Make sure the reltablespace change is visible */
    CommandCounterIncrement();
 
    /* Move associated toast relation and/or indexes, too */
    if (OidIsValid(reltoastrelid))
        ATExecSetTableSpace(reltoastrelid, newTableSpace, lockmode);
    foreach(lc, reltoastidxids)
        ATExecSetTableSpace(lfirst_oid(lc), newTableSpace, lockmode);
 
    /* Clean up */
    list_free(reltoastidxids);
}

References Assert, CheckRelationTableSpaceMove(), CommandCounterIncrement(), GetNewRelFileNumber(), index_copy_data(), InvokeObjectPostAlterHook, lfirst_oid, list_free(), NIL, NoLock, OidIsValid, RelationData::rd_locator, RelationData::rd_rel, relation_close(), relation_open(), RelationAssumeNewRelfilelocator(), RelationGetIndexList(), RelationGetRelid, RelFileLocator::relNumber, SetRelationTableSpace(), RelFileLocator::spcOid, and table_relation_copy_data().

Referenced by ATRewriteTables().

ATExecSetTableSpaceNoStorage()

static void ATExecSetTableSpaceNoStorage ( Relation  rel, Oid  newTableSpace  )

static

Definition at line 15851 of file tablecmds.c.

{
    /*
     * Shouldn't be called on relations having storage; these are processed in
     * phase 3.
     */
    Assert(!RELKIND_HAS_STORAGE(rel->rd_rel->relkind));
 
    /* check if relation can be moved to its new tablespace */
    if (!CheckRelationTableSpaceMove(rel, newTableSpace))
    {
        InvokeObjectPostAlterHook(RelationRelationId,
                                  RelationGetRelid(rel),
                                  0);
        return;
    }
 
    /* Update can be done, so change reltablespace */
    SetRelationTableSpace(rel, newTableSpace, InvalidOid);
 
    InvokeObjectPostAlterHook(RelationRelationId, RelationGetRelid(rel), 0);
 
    /* Make sure the reltablespace change is visible */
    CommandCounterIncrement();
}

References Assert, CheckRelationTableSpaceMove(), CommandCounterIncrement(), InvalidOid, InvokeObjectPostAlterHook, RelationData::rd_rel, RelationGetRelid, and SetRelationTableSpace().

Referenced by ATExecCmd().

ATExecSplitPartition()

static void ATExecSplitPartition ( List **  wqueue, AlteredTableInfo *  tab, Relation  rel, PartitionCmd *  cmd, AlterTableUtilityContext *  context  )

static

Definition at line 21242 of file tablecmds.c.

{
    Relation    splitRel;
    Oid         splitRelOid;
    char        relname[NAMEDATALEN];
    Oid         namespaceId;
    ListCell   *listptr,
               *listptr2;
    bool        isSameName = false;
    char        tmpRelName[NAMEDATALEN];
    List       *newPartRels = NIL;
    ObjectAddress object;
    RangeVar   *parentName;
    Oid         defaultPartOid;
 
    defaultPartOid = get_default_oid_from_partdesc(RelationGetPartitionDesc(rel, true));
 
    /*
     * We are going to detach and remove this partition: need to use exclusive
     * lock for preventing DML-queries to the partition.
     */
    splitRel = table_openrv(cmd->name, AccessExclusiveLock);
 
    splitRelOid = RelationGetRelid(splitRel);
 
    /* Check descriptions of new partitions. */
    foreach(listptr, cmd->partlist)
    {
        Oid         existing_relid;
        SinglePartitionSpec *sps = (SinglePartitionSpec *) lfirst(listptr);
 
        strlcpy(relname, sps->name->relname, NAMEDATALEN);
 
        /*
         * Look up the namespace in which we are supposed to create the
         * partition, check we have permission to create there, lock it
         * against concurrent drop, and mark stmt->relation as
         * RELPERSISTENCE_TEMP if a temporary namespace is selected.
         */
        namespaceId =
            RangeVarGetAndCheckCreationNamespace(sps->name, NoLock, NULL);
 
        /*
         * This would fail later on anyway if the relation already exists. But
         * by catching it here we can emit a nicer error message.
         */
        existing_relid = get_relname_relid(relname, namespaceId);
        if (existing_relid == splitRelOid && !isSameName)
            /* One new partition can have the same name as split partition. */
            isSameName = true;
        else if (existing_relid != InvalidOid)
            ereport(ERROR,
                    (errcode(ERRCODE_DUPLICATE_TABLE),
                     errmsg("relation \"%s\" already exists", relname)));
    }
 
    /* Detach split partition. */
    RemoveInheritance(splitRel, rel, false);
    /* Do the final part of detaching. */
    DetachPartitionFinalize(rel, splitRel, false, defaultPartOid);
 
    /*
     * If new partition has the same name as split partition then we should
     * rename split partition for reusing name.
     */
    if (isSameName)
    {
        /*
         * We must bump the command counter to make the split partition tuple
         * visible for renaming.
         */
        CommandCounterIncrement();
        /* Rename partition. */
        sprintf(tmpRelName, "split-%u-%X-tmp", RelationGetRelid(rel), MyProcPid);
        RenameRelationInternal(splitRelOid, tmpRelName, false, false);
 
        /*
         * We must bump the command counter to make the split partition tuple
         * visible after renaming.
         */
        CommandCounterIncrement();
    }
 
    /* Create new partitions (like split partition), without indexes. */
    parentName = makeRangeVar(get_namespace_name(RelationGetNamespace(rel)),
                              RelationGetRelationName(rel), -1);
    foreach(listptr, cmd->partlist)
    {
        SinglePartitionSpec *sps = (SinglePartitionSpec *) lfirst(listptr);
        Relation    newPartRel;
 
        createPartitionTable(sps->name, parentName, context);
 
        /* Open the new partition and acquire exclusive lock on it. */
        newPartRel = table_openrv(sps->name, AccessExclusiveLock);
 
        newPartRels = lappend(newPartRels, newPartRel);
    }
 
    /* Copy data from split partition to new partitions. */
    moveSplitTableRows(rel, splitRel, cmd->partlist, newPartRels, defaultPartOid);
    /* Keep the lock until commit. */
    table_close(splitRel, NoLock);
 
    /* Attach new partitions to partitioned table. */
    forboth(listptr, cmd->partlist, listptr2, newPartRels)
    {
        SinglePartitionSpec *sps = (SinglePartitionSpec *) lfirst(listptr);
        Relation    newPartRel = (Relation) lfirst(listptr2);
 
        /*
         * wqueue = NULL: verification for each cloned constraint is not
         * needed.
         */
        attachPartitionTable(NULL, rel, newPartRel, sps->bound);
        /* Keep the lock until commit. */
        table_close(newPartRel, NoLock);
    }
 
    /* Drop split partition. */
    object.classId = RelationRelationId;
    object.objectId = splitRelOid;
    object.objectSubId = 0;
    /* Probably DROP_CASCADE is not needed. */
    performDeletion(&object, DROP_RESTRICT, 0);
}

References AccessExclusiveLock, attachPartitionTable(), SinglePartitionSpec::bound, CommandCounterIncrement(), context, createPartitionTable(), DetachPartitionFinalize(), DROP_RESTRICT, ereport, errcode(), errmsg(), ERROR, forboth, get_default_oid_from_partdesc(), get_namespace_name(), get_relname_relid(), InvalidOid, lappend(), lfirst, makeRangeVar(), moveSplitTableRows(), MyProcPid, SinglePartitionSpec::name, PartitionCmd::name, NAMEDATALEN, NIL, NoLock, PartitionCmd::partlist, performDeletion(), RangeVarGetAndCheckCreationNamespace(), RelationGetNamespace, RelationGetPartitionDesc(), RelationGetRelationName, RelationGetRelid, relname, RangeVar::relname, RemoveInheritance(), RenameRelationInternal(), sprintf, strlcpy(), table_close(), and table_openrv().

Referenced by ATExecCmd().

ATExecValidateConstraint()

static ObjectAddress ATExecValidateConstraint ( List **  wqueue, Relation  rel, char *  constrName, bool  recurse, bool  recursing, LOCKMODE  lockmode  )

static

Definition at line 12000 of file tablecmds.c.

{
    Relation    conrel;
    SysScanDesc scan;
    ScanKeyData skey[3];
    HeapTuple   tuple;
    Form_pg_constraint con;
    ObjectAddress address;
 
    conrel = table_open(ConstraintRelationId, RowExclusiveLock);
 
    /*
     * Find and check the target constraint
     */
    ScanKeyInit(&skey[0],
                Anum_pg_constraint_conrelid,
                BTEqualStrategyNumber, F_OIDEQ,
                ObjectIdGetDatum(RelationGetRelid(rel)));
    ScanKeyInit(&skey[1],
                Anum_pg_constraint_contypid,
                BTEqualStrategyNumber, F_OIDEQ,
                ObjectIdGetDatum(InvalidOid));
    ScanKeyInit(&skey[2],
                Anum_pg_constraint_conname,
                BTEqualStrategyNumber, F_NAMEEQ,
                CStringGetDatum(constrName));
    scan = systable_beginscan(conrel, ConstraintRelidTypidNameIndexId,
                              true, NULL, 3, skey);
 
    /* There can be at most one matching row */
    if (!HeapTupleIsValid(tuple = systable_getnext(scan)))
        ereport(ERROR,
                (errcode(ERRCODE_UNDEFINED_OBJECT),
                 errmsg("constraint \"%s\" of relation \"%s\" does not exist",
                        constrName, RelationGetRelationName(rel))));
 
    con = (Form_pg_constraint) GETSTRUCT(tuple);
    if (con->contype != CONSTRAINT_FOREIGN &&
        con->contype != CONSTRAINT_CHECK)
        ereport(ERROR,
                (errcode(ERRCODE_WRONG_OBJECT_TYPE),
                 errmsg("constraint \"%s\" of relation \"%s\" is not a foreign key or check constraint",
                        constrName, RelationGetRelationName(rel))));
 
    if (!con->convalidated)
    {
        AlteredTableInfo *tab;
        HeapTuple   copyTuple;
        Form_pg_constraint copy_con;
 
        if (con->contype == CONSTRAINT_FOREIGN)
        {
            NewConstraint *newcon;
            Constraint *fkconstraint;
 
            /* Queue validation for phase 3 */
            fkconstraint = makeNode(Constraint);
            /* for now this is all we need */
            fkconstraint->conname = constrName;
 
            newcon = (NewConstraint *) palloc0(sizeof(NewConstraint));
            newcon->name = constrName;
            newcon->contype = CONSTR_FOREIGN;
            newcon->refrelid = con->confrelid;
            newcon->refindid = con->conindid;
            newcon->conid = con->oid;
            newcon->qual = (Node *) fkconstraint;
 
            /* Find or create work queue entry for this table */
            tab = ATGetQueueEntry(wqueue, rel);
            tab->constraints = lappend(tab->constraints, newcon);
 
            /*
             * We disallow creating invalid foreign keys to or from
             * partitioned tables, so ignoring the recursion bit is okay.
             */
        }
        else if (con->contype == CONSTRAINT_CHECK)
        {
            List       *children = NIL;
            ListCell   *child;
            NewConstraint *newcon;
            Datum       val;
            char       *conbin;
 
            /*
             * If we're recursing, the parent has already done this, so skip
             * it.  Also, if the constraint is a NO INHERIT constraint, we
             * shouldn't try to look for it in the children.
             */
            if (!recursing && !con->connoinherit)
                children = find_all_inheritors(RelationGetRelid(rel),
                                               lockmode, NULL);
 
            /*
             * For CHECK constraints, we must ensure that we only mark the
             * constraint as validated on the parent if it's already validated
             * on the children.
             *
             * We recurse before validating on the parent, to reduce risk of
             * deadlocks.
             */
            foreach(child, children)
            {
                Oid         childoid = lfirst_oid(child);
                Relation    childrel;
 
                if (childoid == RelationGetRelid(rel))
                    continue;
 
                /*
                 * If we are told not to recurse, there had better not be any
                 * child tables, because we can't mark the constraint on the
                 * parent valid unless it is valid for all child tables.
                 */
                if (!recurse)
                    ereport(ERROR,
                            (errcode(ERRCODE_INVALID_TABLE_DEFINITION),
                             errmsg("constraint must be validated on child tables too")));
 
                /* find_all_inheritors already got lock */
                childrel = table_open(childoid, NoLock);
 
                ATExecValidateConstraint(wqueue, childrel, constrName, false,
                                         true, lockmode);
                table_close(childrel, NoLock);
            }
 
            /* Queue validation for phase 3 */
            newcon = (NewConstraint *) palloc0(sizeof(NewConstraint));
            newcon->name = constrName;
            newcon->contype = CONSTR_CHECK;
            newcon->refrelid = InvalidOid;
            newcon->refindid = InvalidOid;
            newcon->conid = con->oid;
 
            val = SysCacheGetAttrNotNull(CONSTROID, tuple,
                                         Anum_pg_constraint_conbin);
            conbin = TextDatumGetCString(val);
            newcon->qual = (Node *) stringToNode(conbin);
 
            /* Find or create work queue entry for this table */
            tab = ATGetQueueEntry(wqueue, rel);
            tab->constraints = lappend(tab->constraints, newcon);
 
            /*
             * Invalidate relcache so that others see the new validated
             * constraint.
             */
            CacheInvalidateRelcache(rel);
        }
 
        /*
         * Now update the catalog, while we have the door open.
         */
        copyTuple = heap_copytuple(tuple);
        copy_con = (Form_pg_constraint) GETSTRUCT(copyTuple);
        copy_con->convalidated = true;
        CatalogTupleUpdate(conrel, &copyTuple->t_self, copyTuple);
 
        InvokeObjectPostAlterHook(ConstraintRelationId, con->oid, 0);
 
        heap_freetuple(copyTuple);
 
        ObjectAddressSet(address, ConstraintRelationId, con->oid);
    }
    else
        address = InvalidObjectAddress; /* already validated */
 
    systable_endscan(scan);
 
    table_close(conrel, RowExclusiveLock);
 
    return address;
}

References ATGetQueueEntry(), BTEqualStrategyNumber, CacheInvalidateRelcache(), CatalogTupleUpdate(), NewConstraint::conid, Constraint::conname, CONSTR_CHECK, CONSTR_FOREIGN, AlteredTableInfo::constraints, NewConstraint::contype, CStringGetDatum(), ereport, errcode(), errmsg(), ERROR, find_all_inheritors(), GETSTRUCT, heap_copytuple(), heap_freetuple(), HeapTupleIsValid, InvalidObjectAddress, InvalidOid, InvokeObjectPostAlterHook, lappend(), lfirst_oid, makeNode, NewConstraint::name, NIL, NoLock, ObjectAddressSet, ObjectIdGetDatum(), palloc0(), NewConstraint::qual, NewConstraint::refindid, NewConstraint::refrelid, RelationGetRelationName, RelationGetRelid, RowExclusiveLock, ScanKeyInit(), stringToNode(), SysCacheGetAttrNotNull(), systable_beginscan(), systable_endscan(), systable_getnext(), HeapTupleData::t_self, table_close(), table_open(), TextDatumGetCString, and val.

Referenced by ATExecCmd().

ATGetQueueEntry()

static AlteredTableInfo * ATGetQueueEntry ( List **  wqueue, Relation  rel  )

static

Definition at line 6429 of file tablecmds.c.

{
    Oid         relid = RelationGetRelid(rel);
    AlteredTableInfo *tab;
    ListCell   *ltab;
 
    foreach(ltab, *wqueue)
    {
        tab = (AlteredTableInfo *) lfirst(ltab);
        if (tab->relid == relid)
            return tab;
    }
 
    /*
     * Not there, so add it.  Note that we make a copy of the relation's
     * existing descriptor before anything interesting can happen to it.
     */
    tab = (AlteredTableInfo *) palloc0(sizeof(AlteredTableInfo));
    tab->relid = relid;
    tab->rel = NULL;            /* set later */
    tab->relkind = rel->rd_rel->relkind;
    tab->oldDesc = CreateTupleDescCopyConstr(RelationGetDescr(rel));
    tab->newAccessMethod = InvalidOid;
    tab->chgAccessMethod = false;
    tab->newTableSpace = InvalidOid;
    tab->newrelpersistence = RELPERSISTENCE_PERMANENT;
    tab->chgPersistence = false;
 
    *wqueue = lappend(*wqueue, tab);
 
    return tab;
}

References AlteredTableInfo::chgAccessMethod, AlteredTableInfo::chgPersistence, CreateTupleDescCopyConstr(), InvalidOid, lappend(), lfirst, AlteredTableInfo::newAccessMethod, AlteredTableInfo::newrelpersistence, AlteredTableInfo::newTableSpace, AlteredTableInfo::oldDesc, palloc0(), RelationData::rd_rel, AlteredTableInfo::rel, RelationGetDescr, RelationGetRelid, AlteredTableInfo::relid, and AlteredTableInfo::relkind.

Referenced by addFkRecurseReferencing(), ATAddCheckNNConstraint(), ATExecAddColumn(), ATExecValidateConstraint(), ATPostAlterTypeParse(), ATPrepCmd(), DetachAddConstraintIfNeeded(), QueuePartitionConstraintValidation(), and set_attnotnull().

ATInheritAdjustNotNulls()

static void ATInheritAdjustNotNulls ( Relation  parent_rel, Relation  child_rel, int  inhcount  )

static

Definition at line 17058 of file tablecmds.c.

{
    Bitmapset  *pkattnos;
 
    /* Quick exit when parent has no PK */
    if (!parent_rel->rd_rel->relhasindex)
        return;
 
    pkattnos = RelationGetIndexAttrBitmap(parent_rel,
                                          INDEX_ATTR_BITMAP_PRIMARY_KEY);
    if (pkattnos != NULL)
    {
        Bitmapset  *childattnums = NULL;
        AttrMap    *attmap;
        int         i;
 
        attmap = build_attrmap_by_name(RelationGetDescr(parent_rel),
                                       RelationGetDescr(child_rel), true);
 
        i = -1;
        while ((i = bms_next_member(pkattnos, i)) >= 0)
        {
            childattnums = bms_add_member(childattnums,
                                          attmap->attnums[i + FirstLowInvalidHeapAttributeNumber - 1]);
        }
 
        /*
         * CCI is needed in case there's a NOT NULL PRIMARY KEY column in the
         * parent: the relevant not-null constraint in the child already had
         * its inhcount modified earlier.
         */
        CommandCounterIncrement();
        AdjustNotNullInheritance(RelationGetRelid(child_rel), childattnums,
                                 inhcount);
    }
}

References AdjustNotNullInheritance(), AttrMap::attnums, bms_add_member(), bms_next_member(), build_attrmap_by_name(), CommandCounterIncrement(), FirstLowInvalidHeapAttributeNumber, i, INDEX_ATTR_BITMAP_PRIMARY_KEY, RelationData::rd_rel, RelationGetDescr, RelationGetIndexAttrBitmap(), and RelationGetRelid.

Referenced by ATExecAddInherit(), and ATExecDropInherit().

ATParseTransformCmd()

static AlterTableCmd * ATParseTransformCmd ( List **  wqueue, AlteredTableInfo *  tab, Relation  rel, AlterTableCmd *  cmd, bool  recurse, LOCKMODE  lockmode, AlterTablePass  cur_pass, AlterTableUtilityContext *  context  )

static

Definition at line 5630 of file tablecmds.c.

{
    AlterTableCmd *newcmd = NULL;
    AlterTableStmt *atstmt = makeNode(AlterTableStmt);
    List       *beforeStmts;
    List       *afterStmts;
    ListCell   *lc;
 
    /* Gin up an AlterTableStmt with just this subcommand and this table */
    atstmt->relation =
        makeRangeVar(get_namespace_name(RelationGetNamespace(rel)),
                     pstrdup(RelationGetRelationName(rel)),
                     -1);
    atstmt->relation->inh = recurse;
    atstmt->cmds = list_make1(cmd);
    atstmt->objtype = OBJECT_TABLE; /* needn't be picky here */
    atstmt->missing_ok = false;
 
    /* Transform the AlterTableStmt */
    atstmt = transformAlterTableStmt(RelationGetRelid(rel),
                                     atstmt,
                                     context->queryString,
                                     &beforeStmts,
                                     &afterStmts);
 
    /* Execute any statements that should happen before these subcommand(s) */
    foreach(lc, beforeStmts)
    {
        Node       *stmt = (Node *) lfirst(lc);
 
        ProcessUtilityForAlterTable(stmt, context);
        CommandCounterIncrement();
    }
 
    /* Examine the transformed subcommands and schedule them appropriately */
    foreach(lc, atstmt->cmds)
    {
        AlterTableCmd *cmd2 = lfirst_node(AlterTableCmd, lc);
        AlterTablePass pass;
 
        /*
         * This switch need only cover the subcommand types that can be added
         * by parse_utilcmd.c; otherwise, we'll use the default strategy of
         * executing the subcommand immediately, as a substitute for the
         * original subcommand.  (Note, however, that this does cause
         * AT_AddConstraint subcommands to be rescheduled into later passes,
         * which is important for index and foreign key constraints.)
         *
         * We assume we needn't do any phase-1 checks for added subcommands.
         */
        switch (cmd2->subtype)
        {
            case AT_SetAttNotNull:
                ATSimpleRecursion(wqueue, rel, cmd2, recurse, lockmode, context);
                pass = AT_PASS_COL_ATTRS;
                break;
            case AT_AddIndex:
 
                /*
                 * A primary key on an inheritance parent needs supporting NOT
                 * NULL constraint on its children; enqueue commands to create
                 * those or mark them inherited if they already exist.
                 */
                ATPrepAddPrimaryKey(wqueue, rel, cmd2, lockmode, context);
                pass = AT_PASS_ADD_INDEX;
                break;
            case AT_AddIndexConstraint:
                /* as above */
                ATPrepAddPrimaryKey(wqueue, rel, cmd2, lockmode, context);
                pass = AT_PASS_ADD_INDEXCONSTR;
                break;
            case AT_AddConstraint:
                /* Recursion occurs during execution phase */
                if (recurse)
                    cmd2->recurse = true;
                switch (castNode(Constraint, cmd2->def)->contype)
                {
                    case CONSTR_PRIMARY:
                    case CONSTR_UNIQUE:
                    case CONSTR_EXCLUSION:
                        pass = AT_PASS_ADD_INDEXCONSTR;
                        break;
                    default:
                        pass = AT_PASS_ADD_OTHERCONSTR;
                        break;
                }
                break;
            case AT_AlterColumnGenericOptions:
                /* This command never recurses */
                /* No command-specific prep needed */
                pass = AT_PASS_MISC;
                break;
            default:
                pass = cur_pass;
                break;
        }
 
        if (pass < cur_pass)
        {
            /* Cannot schedule into a pass we already finished */
            elog(ERROR, "ALTER TABLE scheduling failure: too late for pass %d",
                 pass);
        }
        else if (pass > cur_pass)
        {
            /* OK, queue it up for later */
            tab->subcmds[pass] = lappend(tab->subcmds[pass], cmd2);
        }
        else
        {
            /*
             * We should see at most one subcommand for the current pass,
             * which is the transformed version of the original subcommand.
             */
            if (newcmd == NULL && cmd->subtype == cmd2->subtype)
            {
                /* Found the transformed version of our subcommand */
                newcmd = cmd2;
            }
            else
                elog(ERROR, "ALTER TABLE scheduling failure: bogus item for pass %d",
                     pass);
        }
    }
 
    /* Queue up any after-statements to happen at the end */
    tab->afterStmts = list_concat(tab->afterStmts, afterStmts);
 
    return newcmd;
}

References AlteredTableInfo::afterStmts, AT_AddConstraint, AT_AddIndex, AT_AddIndexConstraint, AT_AlterColumnGenericOptions, AT_PASS_ADD_INDEX, AT_PASS_ADD_INDEXCONSTR, AT_PASS_ADD_OTHERCONSTR, AT_PASS_COL_ATTRS, AT_PASS_MISC, AT_SetAttNotNull, ATPrepAddPrimaryKey(), ATSimpleRecursion(), castNode, AlterTableStmt::cmds, CommandCounterIncrement(), CONSTR_EXCLUSION, CONSTR_PRIMARY, CONSTR_UNIQUE, context, AlterTableCmd::def, elog, ERROR, get_namespace_name(), RangeVar::inh, lappend(), lfirst, lfirst_node, list_concat(), list_make1, makeNode, makeRangeVar(), AlterTableStmt::missing_ok, OBJECT_TABLE, AlterTableStmt::objtype, ProcessUtilityForAlterTable(), pstrdup(), AlterTableCmd::recurse, AlterTableStmt::relation, RelationGetNamespace, RelationGetRelationName, RelationGetRelid, stmt, AlteredTableInfo::subcmds, AlterTableCmd::subtype, and transformAlterTableStmt().

Referenced by ATExecAddColumn(), ATExecCmd(), and ATPrepCmd().

ATPostAlterTypeCleanup()

static void ATPostAlterTypeCleanup ( List **  wqueue, AlteredTableInfo *  tab, LOCKMODE  lockmode  )

static

Definition at line 14363 of file tablecmds.c.

{
    ObjectAddress obj;
    ObjectAddresses *objects;
    ListCell   *def_item;
    ListCell   *oid_item;
 
    /*
     * Collect all the constraints and indexes to drop so we can process them
     * in a single call.  That way we don't have to worry about dependencies
     * among them.
     */
    objects = new_object_addresses();
 
    /*
     * Re-parse the index and constraint definitions, and attach them to the
     * appropriate work queue entries.  We do this before dropping because in
     * the case of a FOREIGN KEY constraint, we might not yet have exclusive
     * lock on the table the constraint is attached to, and we need to get
     * that before reparsing/dropping.
     *
     * We can't rely on the output of deparsing to tell us which relation to
     * operate on, because concurrent activity might have made the name
     * resolve differently.  Instead, we've got to use the OID of the
     * constraint or index we're processing to figure out which relation to
     * operate on.
     */
    forboth(oid_item, tab->changedConstraintOids,
            def_item, tab->changedConstraintDefs)
    {
        Oid         oldId = lfirst_oid(oid_item);
        HeapTuple   tup;
        Form_pg_constraint con;
        Oid         relid;
        Oid         confrelid;
        char        contype;
        bool        conislocal;
 
        tup = SearchSysCache1(CONSTROID, ObjectIdGetDatum(oldId));
        if (!HeapTupleIsValid(tup)) /* should not happen */
            elog(ERROR, "cache lookup failed for constraint %u", oldId);
        con = (Form_pg_constraint) GETSTRUCT(tup);
        if (OidIsValid(con->conrelid))
            relid = con->conrelid;
        else
        {
            /* must be a domain constraint */
            relid = get_typ_typrelid(getBaseType(con->contypid));
            if (!OidIsValid(relid))
                elog(ERROR, "could not identify relation associated with constraint %u", oldId);
        }
        confrelid = con->confrelid;
        contype = con->contype;
        conislocal = con->conislocal;
        ReleaseSysCache(tup);
 
        ObjectAddressSet(obj, ConstraintRelationId, oldId);
        add_exact_object_address(&obj, objects);
 
        /*
         * If the constraint is inherited (only), we don't want to inject a
         * new definition here; it'll get recreated when
         * ATAddCheckNNConstraint recurses from adding the parent table's
         * constraint.  But we had to carry the info this far so that we can
         * drop the constraint below.
         */
        if (!conislocal)
            continue;
 
        /*
         * When rebuilding an FK constraint that references the table we're
         * modifying, we might not yet have any lock on the FK's table, so get
         * one now.  We'll need AccessExclusiveLock for the DROP CONSTRAINT
         * step, so there's no value in asking for anything weaker.
         */
        if (relid != tab->relid && contype == CONSTRAINT_FOREIGN)
            LockRelationOid(relid, AccessExclusiveLock);
 
        ATPostAlterTypeParse(oldId, relid, confrelid,
                             (char *) lfirst(def_item),
                             wqueue, lockmode, tab->rewrite);
    }
    forboth(oid_item, tab->changedIndexOids,
            def_item, tab->changedIndexDefs)
    {
        Oid         oldId = lfirst_oid(oid_item);
        Oid         relid;
 
        relid = IndexGetRelation(oldId, false);
        ATPostAlterTypeParse(oldId, relid, InvalidOid,
                             (char *) lfirst(def_item),
                             wqueue, lockmode, tab->rewrite);
 
        ObjectAddressSet(obj, RelationRelationId, oldId);
        add_exact_object_address(&obj, objects);
    }
 
    /* add dependencies for new statistics */
    forboth(oid_item, tab->changedStatisticsOids,
            def_item, tab->changedStatisticsDefs)
    {
        Oid         oldId = lfirst_oid(oid_item);
        Oid         relid;
 
        relid = StatisticsGetRelation(oldId, false);
        ATPostAlterTypeParse(oldId, relid, InvalidOid,
                             (char *) lfirst(def_item),
                             wqueue, lockmode, tab->rewrite);
 
        ObjectAddressSet(obj, StatisticExtRelationId, oldId);
        add_exact_object_address(&obj, objects);
    }
 
    /*
     * Queue up command to restore replica identity index marking
     */
    if (tab->replicaIdentityIndex)
    {
        AlterTableCmd *cmd = makeNode(AlterTableCmd);
        ReplicaIdentityStmt *subcmd = makeNode(ReplicaIdentityStmt);
 
        subcmd->identity_type = REPLICA_IDENTITY_INDEX;
        subcmd->name = tab->replicaIdentityIndex;
        cmd->subtype = AT_ReplicaIdentity;
        cmd->def = (Node *) subcmd;
 
        /* do it after indexes and constraints */
        tab->subcmds[AT_PASS_OLD_CONSTR] =
            lappend(tab->subcmds[AT_PASS_OLD_CONSTR], cmd);
    }
 
    /*
     * Queue up command to restore marking of index used for cluster.
     */
    if (tab->clusterOnIndex)
    {
        AlterTableCmd *cmd = makeNode(AlterTableCmd);
 
        cmd->subtype = AT_ClusterOn;
        cmd->name = tab->clusterOnIndex;
 
        /* do it after indexes and constraints */
        tab->subcmds[AT_PASS_OLD_CONSTR] =
            lappend(tab->subcmds[AT_PASS_OLD_CONSTR], cmd);
    }
 
    /*
     * It should be okay to use DROP_RESTRICT here, since nothing else should
     * be depending on these objects.
     */
    performMultipleDeletions(objects, DROP_RESTRICT, PERFORM_DELETION_INTERNAL);
 
    free_object_addresses(objects);
 
    /*
     * The objects will get recreated during subsequent passes over the work
     * queue.
     */
}

References AccessExclusiveLock, add_exact_object_address(), ATPostAlterTypeParse(), AlteredTableInfo::changedConstraintDefs, AlteredTableInfo::changedConstraintOids, elog, ERROR, forboth, get_typ_typrelid(), getBaseType(), GETSTRUCT, HeapTupleIsValid, lfirst, lfirst_oid, LockRelationOid(), new_object_addresses(), ObjectAddressSet, ObjectIdGetDatum(), OidIsValid, ReleaseSysCache(), AlteredTableInfo::relid, AlteredTableInfo::rewrite, and SearchSysCache1().

Referenced by ATRewriteCatalogs().

ATPostAlterTypeParse()

static void ATPostAlterTypeParse ( Oid  oldId, Oid  oldRelId, Oid  refRelId, char *  cmd, List **  wqueue, LOCKMODE  lockmode, bool  rewrite  )

static

Definition at line 14532 of file tablecmds.c.

{
    List       *raw_parsetree_list;
    List       *querytree_list;
    ListCell   *list_item;
    Relation    rel;
 
    /*
     * We expect that we will get only ALTER TABLE and CREATE INDEX
     * statements. Hence, there is no need to pass them through
     * parse_analyze_*() or the rewriter, but instead we need to pass them
     * through parse_utilcmd.c to make them ready for execution.
     */
    raw_parsetree_list = raw_parser(cmd, RAW_PARSE_DEFAULT);
    querytree_list = NIL;
    foreach(list_item, raw_parsetree_list)
    {
        RawStmt    *rs = lfirst_node(RawStmt, list_item);
        Node       *stmt = rs->stmt;
 
        if (IsA(stmt, IndexStmt))
            querytree_list = lappend(querytree_list,
                                     transformIndexStmt(oldRelId,
                                                        (IndexStmt *) stmt,
                                                        cmd));
        else if (IsA(stmt, AlterTableStmt))
        {
            List       *beforeStmts;
            List       *afterStmts;
 
            stmt = (Node *) transformAlterTableStmt(oldRelId,
                                                    (AlterTableStmt *) stmt,
                                                    cmd,
                                                    &beforeStmts,
                                                    &afterStmts);
            querytree_list = list_concat(querytree_list, beforeStmts);
            querytree_list = lappend(querytree_list, stmt);
            querytree_list = list_concat(querytree_list, afterStmts);
        }
        else if (IsA(stmt, CreateStatsStmt))
            querytree_list = lappend(querytree_list,
                                     transformStatsStmt(oldRelId,
                                                        (CreateStatsStmt *) stmt,
                                                        cmd));
        else
            querytree_list = lappend(querytree_list, stmt);
    }
 
    /* Caller should already have acquired whatever lock we need. */
    rel = relation_open(oldRelId, NoLock);
 
    /*
     * Attach each generated command to the proper place in the work queue.
     * Note this could result in creation of entirely new work-queue entries.
     *
     * Also note that we have to tweak the command subtypes, because it turns
     * out that re-creation of indexes and constraints has to act a bit
     * differently from initial creation.
     */
    foreach(list_item, querytree_list)
    {
        Node       *stm = (Node *) lfirst(list_item);
        AlteredTableInfo *tab;
 
        tab = ATGetQueueEntry(wqueue, rel);
 
        if (IsA(stm, IndexStmt))
        {
            IndexStmt  *stmt = (IndexStmt *) stm;
            AlterTableCmd *newcmd;
 
            if (!rewrite)
                TryReuseIndex(oldId, stmt);
            stmt->reset_default_tblspc = true;
            /* keep the index's comment */
            stmt->idxcomment = GetComment(oldId, RelationRelationId, 0);
 
            newcmd = makeNode(AlterTableCmd);
            newcmd->subtype = AT_ReAddIndex;
            newcmd->def = (Node *) stmt;
            tab->subcmds[AT_PASS_OLD_INDEX] =
                lappend(tab->subcmds[AT_PASS_OLD_INDEX], newcmd);
        }
        else if (IsA(stm, AlterTableStmt))
        {
            AlterTableStmt *stmt = (AlterTableStmt *) stm;
            ListCell   *lcmd;
 
            foreach(lcmd, stmt->cmds)
            {
                AlterTableCmd *cmd = lfirst_node(AlterTableCmd, lcmd);
 
                if (cmd->subtype == AT_AddIndex)
                {
                    IndexStmt  *indstmt;
                    Oid         indoid;
 
                    indstmt = castNode(IndexStmt, cmd->def);
                    indoid = get_constraint_index(oldId);
 
                    if (!rewrite)
                        TryReuseIndex(indoid, indstmt);
                    /* keep any comment on the index */
                    indstmt->idxcomment = GetComment(indoid,
                                                     RelationRelationId, 0);
                    indstmt->reset_default_tblspc = true;
 
                    cmd->subtype = AT_ReAddIndex;
                    tab->subcmds[AT_PASS_OLD_INDEX] =
                        lappend(tab->subcmds[AT_PASS_OLD_INDEX], cmd);
 
                    /* recreate any comment on the constraint */
                    RebuildConstraintComment(tab,
                                             AT_PASS_OLD_INDEX,
                                             oldId,
                                             rel,
                                             NIL,
                                             indstmt->idxname);
                }
                else if (cmd->subtype == AT_AddConstraint)
                {
                    Constraint *con = castNode(Constraint, cmd->def);
 
                    con->old_pktable_oid = refRelId;
                    /* rewriting neither side of a FK */
                    if (con->contype == CONSTR_FOREIGN &&
                        !rewrite && tab->rewrite == 0)
                        TryReuseForeignKey(oldId, con);
                    con->reset_default_tblspc = true;
                    cmd->subtype = AT_ReAddConstraint;
                    tab->subcmds[AT_PASS_OLD_CONSTR] =
                        lappend(tab->subcmds[AT_PASS_OLD_CONSTR], cmd);
 
                    /* recreate any comment on the constraint */
                    RebuildConstraintComment(tab,
                                             AT_PASS_OLD_CONSTR,
                                             oldId,
                                             rel,
                                             NIL,
                                             con->conname);
                }
                else if (cmd->subtype == AT_SetAttNotNull)
                {
                    /*
                     * We see this subtype when a primary key is created
                     * internally, for example when it is replaced with a new
                     * constraint (say because one of the columns changes
                     * type); in this case we need to reinstate attnotnull,
                     * because it was removed because of the drop of the old
                     * PK.  Schedule this subcommand to an upcoming AT pass.
                     */
                    cmd->subtype = AT_SetAttNotNull;
                    tab->subcmds[AT_PASS_OLD_COL_ATTRS] =
                        lappend(tab->subcmds[AT_PASS_OLD_COL_ATTRS], cmd);
                }
                else
                    elog(ERROR, "unexpected statement subtype: %d",
                         (int) cmd->subtype);
            }
        }
        else if (IsA(stm, AlterDomainStmt))
        {
            AlterDomainStmt *stmt = (AlterDomainStmt *) stm;
 
            if (stmt->subtype == 'C')   /* ADD CONSTRAINT */
            {
                Constraint *con = castNode(Constraint, stmt->def);
                AlterTableCmd *cmd = makeNode(AlterTableCmd);
 
                cmd->subtype = AT_ReAddDomainConstraint;
                cmd->def = (Node *) stmt;
                tab->subcmds[AT_PASS_OLD_CONSTR] =
                    lappend(tab->subcmds[AT_PASS_OLD_CONSTR], cmd);
 
                /* recreate any comment on the constraint */
                RebuildConstraintComment(tab,
                                         AT_PASS_OLD_CONSTR,
                                         oldId,
                                         NULL,
                                         stmt->typeName,
                                         con->conname);
            }
            else
                elog(ERROR, "unexpected statement subtype: %d",
                     (int) stmt->subtype);
        }
        else if (IsA(stm, CreateStatsStmt))
        {
            CreateStatsStmt *stmt = (CreateStatsStmt *) stm;
            AlterTableCmd *newcmd;
 
            /* keep the statistics object's comment */
            stmt->stxcomment = GetComment(oldId, StatisticExtRelationId, 0);
 
            newcmd = makeNode(AlterTableCmd);
            newcmd->subtype = AT_ReAddStatistics;
            newcmd->def = (Node *) stmt;
            tab->subcmds[AT_PASS_MISC] =
                lappend(tab->subcmds[AT_PASS_MISC], newcmd);
        }
        else
            elog(ERROR, "unexpected statement type: %d",
                 (int) nodeTag(stm));
    }
 
    relation_close(rel, NoLock);
}

References AT_AddConstraint, AT_AddIndex, AT_PASS_MISC, AT_PASS_OLD_COL_ATTRS, AT_PASS_OLD_CONSTR, AT_PASS_OLD_INDEX, AT_ReAddConstraint, AT_ReAddDomainConstraint, AT_ReAddIndex, AT_ReAddStatistics, AT_SetAttNotNull, ATGetQueueEntry(), castNode, Constraint::conname, CONSTR_FOREIGN, Constraint::contype, AlterTableCmd::def, elog, ERROR, get_constraint_index(), GetComment(), IndexStmt::idxcomment, IndexStmt::idxname, IsA, lappend(), lfirst, lfirst_node, list_concat(), makeNode, NIL, nodeTag, NoLock, Constraint::old_pktable_oid, RAW_PARSE_DEFAULT, raw_parser(), RebuildConstraintComment(), relation_close(), relation_open(), Constraint::reset_default_tblspc, IndexStmt::reset_default_tblspc, AlteredTableInfo::rewrite, RawStmt::stmt, stmt, AlteredTableInfo::subcmds, AlterTableCmd::subtype, transformAlterTableStmt(), transformIndexStmt(), transformStatsStmt(), TryReuseForeignKey(), and TryReuseIndex().

Referenced by ATPostAlterTypeCleanup().

ATPrepAddColumn()

static void ATPrepAddColumn ( List **  wqueue, Relation  rel, bool  recurse, bool  recursing, bool  is_view, AlterTableCmd *  cmd, LOCKMODE  lockmode, AlterTableUtilityContext *  context  )

static

Definition at line 7057 of file tablecmds.c.

{
    if (rel->rd_rel->reloftype && !recursing)
        ereport(ERROR,
                (errcode(ERRCODE_WRONG_OBJECT_TYPE),
                 errmsg("cannot add column to typed table")));
 
    if (rel->rd_rel->relkind == RELKIND_COMPOSITE_TYPE)
        ATTypedTableRecursion(wqueue, rel, cmd, lockmode, context);
 
    if (recurse && !is_view)
        cmd->recurse = true;
}

References ATTypedTableRecursion(), context, ereport, errcode(), errmsg(), ERROR, RelationData::rd_rel, and AlterTableCmd::recurse.

Referenced by ATPrepCmd().

ATPrepAddInherit()

static void ATPrepAddInherit ( Relation  child_rel )

static

Definition at line 16144 of file tablecmds.c.

{
    if (child_rel->rd_rel->reloftype)
        ereport(ERROR,
                (errcode(ERRCODE_WRONG_OBJECT_TYPE),
                 errmsg("cannot change inheritance of typed table")));
 
    if (child_rel->rd_rel->relispartition)
        ereport(ERROR,
                (errcode(ERRCODE_WRONG_OBJECT_TYPE),
                 errmsg("cannot change inheritance of a partition")));
 
    if (child_rel->rd_rel->relkind == RELKIND_PARTITIONED_TABLE)
        ereport(ERROR,
                (errcode(ERRCODE_WRONG_OBJECT_TYPE),
                 errmsg("cannot change inheritance of partitioned table")));
}

References ereport, errcode(), errmsg(), ERROR, and RelationData::rd_rel.

Referenced by ATPrepCmd().

ATPrepAddPrimaryKey()

static void ATPrepAddPrimaryKey ( List **  wqueue, Relation  rel, AlterTableCmd *  cmd, LOCKMODE  lockmode, AlterTableUtilityContext *  context  )

static

Definition at line 9352 of file tablecmds.c.

{
    List       *children;
    List       *newconstrs = NIL;
    IndexStmt  *indexstmt;
 
    /* No work if not creating a primary key */
    if (!IsA(cmd->def, IndexStmt))
        return;
    indexstmt = castNode(IndexStmt, cmd->def);
    if (!indexstmt->primary)
        return;
 
    /* No work if no legacy inheritance children are present */
    if (rel->rd_rel->relkind != RELKIND_RELATION ||
        !rel->rd_rel->relhassubclass)
        return;
 
    /*
     * Acquire locks all the way down the hierarchy.  The recursion to lower
     * levels occurs at execution time as necessary, so we don't need to do it
     * here, and we don't need the returned list either.
     */
    (void) find_all_inheritors(RelationGetRelid(rel), lockmode, NULL);
 
    /*
     * Construct the list of constraints that we need to add to each child
     * relation.
     */
    foreach_node(IndexElem, elem, indexstmt->indexParams)
    {
        Constraint *nnconstr;
 
        Assert(elem->expr == NULL);
 
        nnconstr = makeNode(Constraint);
        nnconstr->contype = CONSTR_NOTNULL;
        nnconstr->conname = NULL;   /* XXX use PK name? */
        nnconstr->inhcount = 1;
        nnconstr->deferrable = false;
        nnconstr->initdeferred = false;
        nnconstr->location = -1;
        nnconstr->keys = list_make1(makeString(elem->name));
        nnconstr->skip_validation = false;
        nnconstr->initially_valid = true;
 
        newconstrs = lappend(newconstrs, nnconstr);
    }
 
    /* Finally, add AT subcommands to add each constraint to each child. */
    children = find_inheritance_children(RelationGetRelid(rel), NoLock);
    foreach_oid(childrelid, children)
    {
        Relation    childrel = table_open(childrelid, NoLock);
        AlterTableCmd *newcmd = makeNode(AlterTableCmd);
        ListCell   *lc2;
 
        newcmd->subtype = AT_AddConstraint;
        newcmd->recurse = true;
 
        foreach(lc2, newconstrs)
        {
            /* ATPrepCmd copies newcmd, so we can scribble on it here */
            newcmd->def = lfirst(lc2);
 
            ATPrepCmd(wqueue, childrel, newcmd,
                      true, false, lockmode, context);
        }
 
        table_close(childrel, NoLock);
    }
}

References Assert, AT_AddConstraint, ATPrepCmd(), castNode, Constraint::conname, CONSTR_NOTNULL, context, Constraint::contype, AlterTableCmd::def, Constraint::deferrable, find_all_inheritors(), find_inheritance_children(), foreach_node, foreach_oid, IndexStmt::indexParams, Constraint::inhcount, Constraint::initdeferred, Constraint::initially_valid, IsA, Constraint::keys, lappend(), lfirst, list_make1, Constraint::location, makeNode, makeString(), NIL, NoLock, IndexStmt::primary, RelationData::rd_rel, AlterTableCmd::recurse, RelationGetRelid, Constraint::skip_validation, AlterTableCmd::subtype, table_close(), and table_open().

Referenced by ATParseTransformCmd().

ATPrepAlterColumnType()

static void ATPrepAlterColumnType ( List **  wqueue, AlteredTableInfo *  tab, Relation  rel, bool  recurse, bool  recursing, AlterTableCmd *  cmd, LOCKMODE  lockmode, AlterTableUtilityContext *  context  )

static

Definition at line 13381 of file tablecmds.c.

{
    char       *colName = cmd->name;
    ColumnDef  *def = (ColumnDef *) cmd->def;
    TypeName   *typeName = def->typeName;
    Node       *transform = def->cooked_default;
    HeapTuple   tuple;
    Form_pg_attribute attTup;
    AttrNumber  attnum;
    Oid         targettype;
    int32       targettypmod;
    Oid         targetcollid;
    NewColumnValue *newval;
    ParseState *pstate = make_parsestate(NULL);
    AclResult   aclresult;
    bool        is_expr;
 
    if (rel->rd_rel->reloftype && !recursing)
        ereport(ERROR,
                (errcode(ERRCODE_WRONG_OBJECT_TYPE),
                 errmsg("cannot alter column type of typed table")));
 
    /* lookup the attribute so we can check inheritance status */
    tuple = SearchSysCacheAttName(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)));
 
    /*
     * Don't alter inherited columns.  At outer level, there had better not be
     * any inherited definition; when recursing, we assume this was checked at
     * the parent level (see below).
     */
    if (attTup->attinhcount > 0 && !recursing)
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_TABLE_DEFINITION),
                 errmsg("cannot alter inherited column \"%s\"",
                        colName)));
 
    /* Don't alter columns used in the partition key */
    if (has_partition_attrs(rel,
                            bms_make_singleton(attnum - FirstLowInvalidHeapAttributeNumber),
                            &is_expr))
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_TABLE_DEFINITION),
                 errmsg("cannot alter column \"%s\" because it is part of the partition key of relation \"%s\"",
                        colName, RelationGetRelationName(rel))));
 
    /* Look up the target type */
    typenameTypeIdAndMod(NULL, typeName, &targettype, &targettypmod);
 
    aclresult = object_aclcheck(TypeRelationId, targettype, GetUserId(), ACL_USAGE);
    if (aclresult != ACLCHECK_OK)
        aclcheck_error_type(aclresult, targettype);
 
    /* And the collation */
    targetcollid = GetColumnDefCollation(NULL, def, targettype);
 
    /* make sure datatype is legal for a column */
    CheckAttributeType(colName, targettype, targetcollid,
                       list_make1_oid(rel->rd_rel->reltype),
                       0);
 
    if (tab->relkind == RELKIND_RELATION ||
        tab->relkind == RELKIND_PARTITIONED_TABLE)
    {
        /*
         * Set up an expression to transform the old data value to the new
         * type. If a USING option was given, use the expression as
         * transformed by transformAlterTableStmt, else just take the old
         * value and try to coerce it.  We do this first so that type
         * incompatibility can be detected before we waste effort, and because
         * we need the expression to be parsed against the original table row
         * type.
         */
        if (!transform)
        {
            transform = (Node *) makeVar(1, attnum,
                                         attTup->atttypid, attTup->atttypmod,
                                         attTup->attcollation,
                                         0);
        }
 
        transform = coerce_to_target_type(pstate,
                                          transform, exprType(transform),
                                          targettype, targettypmod,
                                          COERCION_ASSIGNMENT,
                                          COERCE_IMPLICIT_CAST,
                                          -1);
        if (transform == NULL)
        {
            /* error text depends on whether USING was specified or not */
            if (def->cooked_default != NULL)
                ereport(ERROR,
                        (errcode(ERRCODE_DATATYPE_MISMATCH),
                         errmsg("result of USING clause for column \"%s\""
                                " cannot be cast automatically to type %s",
                                colName, format_type_be(targettype)),
                         errhint("You might need to add an explicit cast.")));
            else
                ereport(ERROR,
                        (errcode(ERRCODE_DATATYPE_MISMATCH),
                         errmsg("column \"%s\" cannot be cast automatically to type %s",
                                colName, format_type_be(targettype)),
                /* translator: USING is SQL, don't translate it */
                         errhint("You might need to specify \"USING %s::%s\".",
                                 quote_identifier(colName),
                                 format_type_with_typemod(targettype,
                                                          targettypmod))));
        }
 
        /* Fix collations after all else */
        assign_expr_collations(pstate, transform);
 
        /* Plan the expr now so we can accurately assess the need to rewrite. */
        transform = (Node *) expression_planner((Expr *) transform);
 
        /*
         * Add a work queue item to make ATRewriteTable update the column
         * contents.
         */
        newval = (NewColumnValue *) palloc0(sizeof(NewColumnValue));
        newval->attnum = attnum;
        newval->expr = (Expr *) transform;
        newval->is_generated = false;
 
        tab->newvals = lappend(tab->newvals, newval);
        if (ATColumnChangeRequiresRewrite(transform, attnum))
            tab->rewrite |= AT_REWRITE_COLUMN_REWRITE;
    }
    else if (transform)
        ereport(ERROR,
                (errcode(ERRCODE_WRONG_OBJECT_TYPE),
                 errmsg("\"%s\" is not a table",
                        RelationGetRelationName(rel))));
 
    if (!RELKIND_HAS_STORAGE(tab->relkind))
    {
        /*
         * For relations without storage, do this check now.  Regular tables
         * will check it later when the table is being rewritten.
         */
        find_composite_type_dependencies(rel->rd_rel->reltype, rel, NULL);
    }
 
    ReleaseSysCache(tuple);
 
    /*
     * Recurse manually by queueing a new command for each child, if
     * necessary. We cannot apply ATSimpleRecursion here because we need to
     * remap attribute numbers in the USING expression, if any.
     *
     * If we are told not to recurse, there had better not be any child
     * tables; else the alter would put them out of step.
     */
    if (recurse)
    {
        Oid         relid = RelationGetRelid(rel);
        List       *child_oids,
                   *child_numparents;
        ListCell   *lo,
                   *li;
 
        child_oids = find_all_inheritors(relid, lockmode,
                                         &child_numparents);
 
        /*
         * find_all_inheritors does the recursive search of the inheritance
         * hierarchy, so all we have to do is process all of the relids in the
         * list that it returns.
         */
        forboth(lo, child_oids, li, child_numparents)
        {
            Oid         childrelid = lfirst_oid(lo);
            int         numparents = lfirst_int(li);
            Relation    childrel;
            HeapTuple   childtuple;
            Form_pg_attribute childattTup;
 
            if (childrelid == relid)
                continue;
 
            /* find_all_inheritors already got lock */
            childrel = relation_open(childrelid, NoLock);
            CheckTableNotInUse(childrel, "ALTER TABLE");
 
            /*
             * Verify that the child doesn't have any inherited definitions of
             * this column that came from outside this inheritance hierarchy.
             * (renameatt makes a similar test, though in a different way
             * because of its different recursion mechanism.)
             */
            childtuple = SearchSysCacheAttName(RelationGetRelid(childrel),
                                               colName);
            if (!HeapTupleIsValid(childtuple))
                ereport(ERROR,
                        (errcode(ERRCODE_UNDEFINED_COLUMN),
                         errmsg("column \"%s\" of relation \"%s\" does not exist",
                                colName, RelationGetRelationName(childrel))));
            childattTup = (Form_pg_attribute) GETSTRUCT(childtuple);
 
            if (childattTup->attinhcount > numparents)
                ereport(ERROR,
                        (errcode(ERRCODE_INVALID_TABLE_DEFINITION),
                         errmsg("cannot alter inherited column \"%s\" of relation \"%s\"",
                                colName, RelationGetRelationName(childrel))));
 
            ReleaseSysCache(childtuple);
 
            /*
             * Remap the attribute numbers.  If no USING expression was
             * specified, there is no need for this step.
             */
            if (def->cooked_default)
            {
                AttrMap    *attmap;
                bool        found_whole_row;
 
                /* create a copy to scribble on */
                cmd = copyObject(cmd);
 
                attmap = build_attrmap_by_name(RelationGetDescr(childrel),
                                               RelationGetDescr(rel),
                                               false);
                ((ColumnDef *) cmd->def)->cooked_default =
                    map_variable_attnos(def->cooked_default,
                                        1, 0,
                                        attmap,
                                        InvalidOid, &found_whole_row);
                if (found_whole_row)
                    ereport(ERROR,
                            (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                             errmsg("cannot convert whole-row table reference"),
                             errdetail("USING expression contains a whole-row table reference.")));
                pfree(attmap);
            }
            ATPrepCmd(wqueue, childrel, cmd, false, true, lockmode, context);
            relation_close(childrel, NoLock);
        }
    }
    else if (!recursing &&
             find_inheritance_children(RelationGetRelid(rel), NoLock) != NIL)
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_TABLE_DEFINITION),
                 errmsg("type of inherited column \"%s\" must be changed in child tables too",
                        colName)));
 
    if (tab->relkind == RELKIND_COMPOSITE_TYPE)
        ATTypedTableRecursion(wqueue, rel, cmd, lockmode, context);
}

References ACL_USAGE, aclcheck_error_type(), ACLCHECK_OK, assign_expr_collations(), AT_REWRITE_COLUMN_REWRITE, ATColumnChangeRequiresRewrite(), ATPrepCmd(), attnum, ATTypedTableRecursion(), bms_make_singleton(), build_attrmap_by_name(), CheckAttributeType(), CheckTableNotInUse(), COERCE_IMPLICIT_CAST, coerce_to_target_type(), COERCION_ASSIGNMENT, context, ColumnDef::cooked_default, copyObject, AlterTableCmd::def, ereport, errcode(), errdetail(), errhint(), errmsg(), ERROR, expression_planner(), exprType(), find_all_inheritors(), find_composite_type_dependencies(), find_inheritance_children(), FirstLowInvalidHeapAttributeNumber, forboth, format_type_be(), format_type_with_typemod(), GetColumnDefCollation(), GETSTRUCT, GetUserId(), has_partition_attrs(), HeapTupleIsValid, InvalidOid, lappend(), lfirst_int, lfirst_oid, list_make1_oid, make_parsestate(), makeVar(), map_variable_attnos(), AlterTableCmd::name, newval, AlteredTableInfo::newvals, NIL, NoLock, object_aclcheck(), palloc0(), pfree(), quote_identifier(), RelationData::rd_rel, relation_close(), relation_open(), RelationGetDescr, RelationGetRelationName, RelationGetRelid, ReleaseSysCache(), AlteredTableInfo::relkind, AlteredTableInfo::rewrite, SearchSysCacheAttName(), ColumnDef::typeName, and typenameTypeIdAndMod().

Referenced by ATPrepCmd().

ATPrepChangePersistence()

static bool ATPrepChangePersistence ( Relation  rel, bool  toLogged  )

static

Definition at line 17757 of file tablecmds.c.

{
    Relation    pg_constraint;
    HeapTuple   tuple;
    SysScanDesc scan;
    ScanKeyData skey[1];
 
    /*
     * Disallow changing status for a temp table.  Also verify whether we can
     * get away with doing nothing; in such cases we don't need to run the
     * checks below, either.
     */
    switch (rel->rd_rel->relpersistence)
    {
        case RELPERSISTENCE_TEMP:
            ereport(ERROR,
                    (errcode(ERRCODE_INVALID_TABLE_DEFINITION),
                     errmsg("cannot change logged status of table \"%s\" because it is temporary",
                            RelationGetRelationName(rel)),
                     errtable(rel)));
            break;
        case RELPERSISTENCE_PERMANENT:
            if (toLogged)
                /* nothing to do */
                return false;
            break;
        case RELPERSISTENCE_UNLOGGED:
            if (!toLogged)
                /* nothing to do */
                return false;
            break;
    }
 
    /*
     * Check that the table is not part of any publication when changing to
     * UNLOGGED, as UNLOGGED tables can't be published.
     */
    if (!toLogged &&
        GetRelationPublications(RelationGetRelid(rel)) != NIL)
        ereport(ERROR,
                (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
                 errmsg("cannot change table \"%s\" to unlogged because it is part of a publication",
                        RelationGetRelationName(rel)),
                 errdetail("Unlogged relations cannot be replicated.")));
 
    /*
     * Check existing foreign key constraints to preserve the invariant that
     * permanent tables cannot reference unlogged ones.  Self-referencing
     * foreign keys can safely be ignored.
     */
    pg_constraint = table_open(ConstraintRelationId, AccessShareLock);
 
    /*
     * Scan conrelid if changing to permanent, else confrelid.  This also
     * determines whether a useful index exists.
     */
    ScanKeyInit(&skey[0],
                toLogged ? Anum_pg_constraint_conrelid :
                Anum_pg_constraint_confrelid,
                BTEqualStrategyNumber, F_OIDEQ,
                ObjectIdGetDatum(RelationGetRelid(rel)));
    scan = systable_beginscan(pg_constraint,
                              toLogged ? ConstraintRelidTypidNameIndexId : InvalidOid,
                              true, NULL, 1, skey);
 
    while (HeapTupleIsValid(tuple = systable_getnext(scan)))
    {
        Form_pg_constraint con = (Form_pg_constraint) GETSTRUCT(tuple);
 
        if (con->contype == CONSTRAINT_FOREIGN)
        {
            Oid         foreignrelid;
            Relation    foreignrel;
 
            /* the opposite end of what we used as scankey */
            foreignrelid = toLogged ? con->confrelid : con->conrelid;
 
            /* ignore if self-referencing */
            if (RelationGetRelid(rel) == foreignrelid)
                continue;
 
            foreignrel = relation_open(foreignrelid, AccessShareLock);
 
            if (toLogged)
            {
                if (!RelationIsPermanent(foreignrel))
                    ereport(ERROR,
                            (errcode(ERRCODE_INVALID_TABLE_DEFINITION),
                             errmsg("could not change table \"%s\" to logged because it references unlogged table \"%s\"",
                                    RelationGetRelationName(rel),
                                    RelationGetRelationName(foreignrel)),
                             errtableconstraint(rel, NameStr(con->conname))));
            }
            else
            {
                if (RelationIsPermanent(foreignrel))
                    ereport(ERROR,
                            (errcode(ERRCODE_INVALID_TABLE_DEFINITION),
                             errmsg("could not change table \"%s\" to unlogged because it references logged table \"%s\"",
                                    RelationGetRelationName(rel),
                                    RelationGetRelationName(foreignrel)),
                             errtableconstraint(rel, NameStr(con->conname))));
            }
 
            relation_close(foreignrel, AccessShareLock);
        }
    }
 
    systable_endscan(scan);
 
    table_close(pg_constraint, AccessShareLock);
 
    return true;
}

References AccessShareLock, BTEqualStrategyNumber, ereport, errcode(), errdetail(), errmsg(), ERROR, errtable(), errtableconstraint(), GetRelationPublications(), GETSTRUCT, HeapTupleIsValid, InvalidOid, NameStr, NIL, ObjectIdGetDatum(), RelationData::rd_rel, relation_close(), relation_open(), RelationGetRelationName, RelationGetRelid, RelationIsPermanent, ScanKeyInit(), systable_beginscan(), systable_endscan(), systable_getnext(), table_close(), and table_open().

Referenced by ATPrepCmd().

ATPrepCmd()

static void ATPrepCmd ( List **  wqueue, Relation  rel, AlterTableCmd *  cmd, bool  recurse, bool  recursing, LOCKMODE  lockmode, AlterTableUtilityContext *  context  )

static

Definition at line 4813 of file tablecmds.c.

{
    AlteredTableInfo *tab;
    AlterTablePass pass = AT_PASS_UNSET;
 
    /* Find or create work queue entry for this table */
    tab = ATGetQueueEntry(wqueue, rel);
 
    /*
     * Disallow any ALTER TABLE other than ALTER TABLE DETACH FINALIZE on
     * partitions that are pending detach.
     */
    if (rel->rd_rel->relispartition &&
        cmd->subtype != AT_DetachPartitionFinalize &&
        PartitionHasPendingDetach(RelationGetRelid(rel)))
        ereport(ERROR,
                errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
                errmsg("cannot alter partition \"%s\" with an incomplete detach",
                       RelationGetRelationName(rel)),
                errhint("Use ALTER TABLE ... DETACH PARTITION ... FINALIZE to complete the pending detach operation."));
 
    /*
     * Copy the original subcommand for each table, so we can scribble on it.
     * This avoids conflicts when different child tables need to make
     * different parse transformations (for example, the same column may have
     * different column numbers in different children).
     */
    cmd = copyObject(cmd);
 
    /*
     * Do permissions and relkind checking, recursion to child tables if
     * needed, and any additional phase-1 processing needed.  (But beware of
     * adding any processing that looks at table details that another
     * subcommand could change.  In some cases we reject multiple subcommands
     * that could try to change the same state in contrary ways.)
     */
    switch (cmd->subtype)
    {
        case AT_AddColumn:      /* ADD COLUMN */
            ATSimplePermissions(cmd->subtype, rel,
                                ATT_TABLE | ATT_COMPOSITE_TYPE | ATT_FOREIGN_TABLE);
            ATPrepAddColumn(wqueue, rel, recurse, recursing, false, cmd,
                            lockmode, context);
            /* Recursion occurs during execution phase */
            pass = AT_PASS_ADD_COL;
            break;
        case AT_AddColumnToView:    /* add column via CREATE OR REPLACE VIEW */
            ATSimplePermissions(cmd->subtype, rel, ATT_VIEW);
            ATPrepAddColumn(wqueue, rel, recurse, recursing, true, cmd,
                            lockmode, context);
            /* Recursion occurs during execution phase */
            pass = AT_PASS_ADD_COL;
            break;
        case AT_ColumnDefault:  /* ALTER COLUMN DEFAULT */
 
            /*
             * We allow defaults on views so that INSERT into a view can have
             * default-ish behavior.  This works because the rewriter
             * substitutes default values into INSERTs before it expands
             * rules.
             */
            ATSimplePermissions(cmd->subtype, rel, ATT_TABLE | ATT_VIEW | ATT_FOREIGN_TABLE);
            ATSimpleRecursion(wqueue, rel, cmd, recurse, lockmode, context);
            /* No command-specific prep needed */
            pass = cmd->def ? AT_PASS_ADD_OTHERCONSTR : AT_PASS_DROP;
            break;
        case AT_CookedColumnDefault:    /* add a pre-cooked default */
            /* This is currently used only in CREATE TABLE */
            /* (so the permission check really isn't necessary) */
            ATSimplePermissions(cmd->subtype, rel, ATT_TABLE | ATT_FOREIGN_TABLE);
            /* This command never recurses */
            pass = AT_PASS_ADD_OTHERCONSTR;
            break;
        case AT_AddIdentity:
            ATSimplePermissions(cmd->subtype, rel, ATT_TABLE | ATT_VIEW | ATT_FOREIGN_TABLE);
            /* Set up recursion for phase 2; no other prep needed */
            if (recurse)
                cmd->recurse = true;
            pass = AT_PASS_ADD_OTHERCONSTR;
            break;
        case AT_SetIdentity:
            ATSimplePermissions(cmd->subtype, rel, ATT_TABLE | ATT_VIEW | ATT_FOREIGN_TABLE);
            /* Set up recursion for phase 2; no other prep needed */
            if (recurse)
                cmd->recurse = true;
            /* This should run after AddIdentity, so do it in MISC pass */
            pass = AT_PASS_MISC;
            break;
        case AT_DropIdentity:
            ATSimplePermissions(cmd->subtype, rel, ATT_TABLE | ATT_VIEW | ATT_FOREIGN_TABLE);
            /* Set up recursion for phase 2; no other prep needed */
            if (recurse)
                cmd->recurse = true;
            pass = AT_PASS_DROP;
            break;
        case AT_DropNotNull:    /* ALTER COLUMN DROP NOT NULL */
            ATSimplePermissions(cmd->subtype, rel, ATT_TABLE | ATT_FOREIGN_TABLE);
            /* Set up recursion for phase 2; no other prep needed */
            if (recurse)
                cmd->recurse = true;
            pass = AT_PASS_DROP;
            break;
        case AT_SetNotNull:     /* ALTER COLUMN SET NOT NULL */
            ATSimplePermissions(cmd->subtype, rel, ATT_TABLE | ATT_FOREIGN_TABLE);
            /* Set up recursion for phase 2; no other prep needed */
            if (recurse)
                cmd->recurse = true;
            pass = AT_PASS_COL_ATTRS;
            break;
        case AT_SetAttNotNull:  /* set pg_attribute.attnotnull without adding
                                 * a constraint */
            ATSimplePermissions(cmd->subtype, rel, ATT_TABLE | ATT_FOREIGN_TABLE);
            /* Need command-specific recursion decision */
            ATSimpleRecursion(wqueue, rel, cmd, recurse, lockmode, context);
            pass = AT_PASS_COL_ATTRS;
            break;
        case AT_SetExpression:  /* ALTER COLUMN SET EXPRESSION */
            ATSimplePermissions(cmd->subtype, rel, ATT_TABLE | ATT_FOREIGN_TABLE);
            ATSimpleRecursion(wqueue, rel, cmd, recurse, lockmode, context);
            pass = AT_PASS_SET_EXPRESSION;
            break;
        case AT_DropExpression: /* ALTER COLUMN DROP EXPRESSION */
            ATSimplePermissions(cmd->subtype, rel, ATT_TABLE | ATT_FOREIGN_TABLE);
            ATSimpleRecursion(wqueue, rel, cmd, recurse, lockmode, context);
            ATPrepDropExpression(rel, cmd, recurse, recursing, lockmode);
            pass = AT_PASS_DROP;
            break;
        case AT_SetStatistics:  /* ALTER COLUMN SET STATISTICS */
            ATSimplePermissions(cmd->subtype, rel, ATT_TABLE | ATT_MATVIEW | ATT_INDEX | ATT_PARTITIONED_INDEX | ATT_FOREIGN_TABLE);
            ATSimpleRecursion(wqueue, rel, cmd, recurse, lockmode, context);
            /* No command-specific prep needed */
            pass = AT_PASS_MISC;
            break;
        case AT_SetOptions:     /* ALTER COLUMN SET ( options ) */
        case AT_ResetOptions:   /* ALTER COLUMN RESET ( options ) */
            ATSimplePermissions(cmd->subtype, rel, ATT_TABLE | ATT_MATVIEW | ATT_FOREIGN_TABLE);
            /* This command never recurses */
            pass = AT_PASS_MISC;
            break;
        case AT_SetStorage:     /* ALTER COLUMN SET STORAGE */
            ATSimplePermissions(cmd->subtype, rel, ATT_TABLE | ATT_MATVIEW | ATT_FOREIGN_TABLE);
            ATSimpleRecursion(wqueue, rel, cmd, recurse, lockmode, context);
            /* No command-specific prep needed */
            pass = AT_PASS_MISC;
            break;
        case AT_SetCompression: /* ALTER COLUMN SET COMPRESSION */
            ATSimplePermissions(cmd->subtype, rel, ATT_TABLE | ATT_MATVIEW);
            /* This command never recurses */
            /* No command-specific prep needed */
            pass = AT_PASS_MISC;
            break;
        case AT_DropColumn:     /* DROP COLUMN */
            ATSimplePermissions(cmd->subtype, rel,
                                ATT_TABLE | ATT_COMPOSITE_TYPE | ATT_FOREIGN_TABLE);
            ATPrepDropColumn(wqueue, rel, recurse, recursing, cmd,
                             lockmode, context);
            /* Recursion occurs during execution phase */
            pass = AT_PASS_DROP;
            break;
        case AT_AddIndex:       /* ADD INDEX */
            ATSimplePermissions(cmd->subtype, rel, ATT_TABLE);
            /* This command never recurses */
            /* No command-specific prep needed */
            pass = AT_PASS_ADD_INDEX;
            break;
        case AT_AddConstraint:  /* ADD CONSTRAINT */
            ATSimplePermissions(cmd->subtype, rel, ATT_TABLE | ATT_FOREIGN_TABLE);
            /* Recursion occurs during execution phase */
            /* No command-specific prep needed except saving recurse flag */
            if (recurse)
                cmd->recurse = true;
            pass = AT_PASS_ADD_CONSTR;
            break;
        case AT_AddIndexConstraint: /* ADD CONSTRAINT USING INDEX */
            ATSimplePermissions(cmd->subtype, rel, ATT_TABLE);
            /* This command never recurses */
            /* No command-specific prep needed */
            pass = AT_PASS_ADD_INDEXCONSTR;
            break;
        case AT_DropConstraint: /* DROP CONSTRAINT */
            ATSimplePermissions(cmd->subtype, rel, ATT_TABLE | ATT_FOREIGN_TABLE);
            ATCheckPartitionsNotInUse(rel, lockmode);
            /* Other recursion occurs during execution phase */
            /* No command-specific prep needed except saving recurse flag */
            if (recurse)
                cmd->recurse = true;
            pass = AT_PASS_DROP;
            break;
        case AT_AlterColumnType:    /* ALTER COLUMN TYPE */
            ATSimplePermissions(cmd->subtype, rel,
                                ATT_TABLE | ATT_COMPOSITE_TYPE | ATT_FOREIGN_TABLE);
            /* See comments for ATPrepAlterColumnType */
            cmd = ATParseTransformCmd(wqueue, tab, rel, cmd, recurse, lockmode,
                                      AT_PASS_UNSET, context);
            Assert(cmd != NULL);
            /* Performs own recursion */
            ATPrepAlterColumnType(wqueue, tab, rel, recurse, recursing, cmd,
                                  lockmode, context);
            pass = AT_PASS_ALTER_TYPE;
            break;
        case AT_AlterColumnGenericOptions:
            ATSimplePermissions(cmd->subtype, rel, ATT_FOREIGN_TABLE);
            /* This command never recurses */
            /* No command-specific prep needed */
            pass = AT_PASS_MISC;
            break;
        case AT_ChangeOwner:    /* ALTER OWNER */
            /* This command never recurses */
            /* No command-specific prep needed */
            pass = AT_PASS_MISC;
            break;
        case AT_ClusterOn:      /* CLUSTER ON */
        case AT_DropCluster:    /* SET WITHOUT CLUSTER */
            ATSimplePermissions(cmd->subtype, rel, ATT_TABLE | ATT_MATVIEW);
            /* These commands never recurse */
            /* No command-specific prep needed */
            pass = AT_PASS_MISC;
            break;
        case AT_SetLogged:      /* SET LOGGED */
            ATSimplePermissions(cmd->subtype, rel, ATT_TABLE | ATT_SEQUENCE);
            if (tab->chgPersistence)
                ereport(ERROR,
                        (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                         errmsg("cannot change persistence setting twice")));
            tab->chgPersistence = ATPrepChangePersistence(rel, true);
            /* force rewrite if necessary; see comment in ATRewriteTables */
            if (tab->chgPersistence)
            {
                tab->rewrite |= AT_REWRITE_ALTER_PERSISTENCE;
                tab->newrelpersistence = RELPERSISTENCE_PERMANENT;
            }
            pass = AT_PASS_MISC;
            break;
        case AT_SetUnLogged:    /* SET UNLOGGED */
            ATSimplePermissions(cmd->subtype, rel, ATT_TABLE | ATT_SEQUENCE);
            if (tab->chgPersistence)
                ereport(ERROR,
                        (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                         errmsg("cannot change persistence setting twice")));
            tab->chgPersistence = ATPrepChangePersistence(rel, false);
            /* force rewrite if necessary; see comment in ATRewriteTables */
            if (tab->chgPersistence)
            {
                tab->rewrite |= AT_REWRITE_ALTER_PERSISTENCE;
                tab->newrelpersistence = RELPERSISTENCE_UNLOGGED;
            }
            pass = AT_PASS_MISC;
            break;
        case AT_DropOids:       /* SET WITHOUT OIDS */
            ATSimplePermissions(cmd->subtype, rel, ATT_TABLE | ATT_FOREIGN_TABLE);
            pass = AT_PASS_DROP;
            break;
        case AT_SetAccessMethod:    /* SET ACCESS METHOD */
            ATSimplePermissions(cmd->subtype, rel, ATT_TABLE | ATT_MATVIEW);
 
            /* check if another access method change was already requested */
            if (tab->chgAccessMethod)
                ereport(ERROR,
                        (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                         errmsg("cannot have multiple SET ACCESS METHOD subcommands")));
 
            ATPrepSetAccessMethod(tab, rel, cmd->name);
            pass = AT_PASS_MISC;    /* does not matter; no work in Phase 2 */
            break;
        case AT_SetTableSpace:  /* SET TABLESPACE */
            ATSimplePermissions(cmd->subtype, rel, ATT_TABLE | ATT_MATVIEW | ATT_INDEX |
                                ATT_PARTITIONED_INDEX);
            /* This command never recurses */
            ATPrepSetTableSpace(tab, rel, cmd->name, lockmode);
            pass = AT_PASS_MISC;    /* doesn't actually matter */
            break;
        case AT_SetRelOptions:  /* SET (...) */
        case AT_ResetRelOptions:    /* RESET (...) */
        case AT_ReplaceRelOptions:  /* reset them all, then set just these */
            ATSimplePermissions(cmd->subtype, rel, ATT_TABLE | ATT_VIEW | ATT_MATVIEW | ATT_INDEX);
            /* This command never recurses */
            /* No command-specific prep needed */
            pass = AT_PASS_MISC;
            break;
        case AT_AddInherit:     /* INHERIT */
            ATSimplePermissions(cmd->subtype, rel, ATT_TABLE | ATT_FOREIGN_TABLE);
            /* This command never recurses */
            ATPrepAddInherit(rel);
            pass = AT_PASS_MISC;
            break;
        case AT_DropInherit:    /* NO INHERIT */
            ATSimplePermissions(cmd->subtype, rel, ATT_TABLE | ATT_FOREIGN_TABLE);
            /* This command never recurses */
            /* No command-specific prep needed */
            pass = AT_PASS_MISC;
            break;
        case AT_AlterConstraint:    /* ALTER CONSTRAINT */
            ATSimplePermissions(cmd->subtype, rel, ATT_TABLE);
            /* Recursion occurs during execution phase */
            pass = AT_PASS_MISC;
            break;
        case AT_ValidateConstraint: /* VALIDATE CONSTRAINT */
            ATSimplePermissions(cmd->subtype, rel, ATT_TABLE | ATT_FOREIGN_TABLE);
            /* Recursion occurs during execution phase */
            /* No command-specific prep needed except saving recurse flag */
            if (recurse)
                cmd->recurse = true;
            pass = AT_PASS_MISC;
            break;
        case AT_ReplicaIdentity:    /* REPLICA IDENTITY ... */
            ATSimplePermissions(cmd->subtype, rel, ATT_TABLE | ATT_MATVIEW);
            pass = AT_PASS_MISC;
            /* This command never recurses */
            /* No command-specific prep needed */
            break;
        case AT_EnableTrig:     /* ENABLE TRIGGER variants */
        case AT_EnableAlwaysTrig:
        case AT_EnableReplicaTrig:
        case AT_EnableTrigAll:
        case AT_EnableTrigUser:
        case AT_DisableTrig:    /* DISABLE TRIGGER variants */
        case AT_DisableTrigAll:
        case AT_DisableTrigUser:
            ATSimplePermissions(cmd->subtype, rel, ATT_TABLE | ATT_FOREIGN_TABLE);
            /* Set up recursion for phase 2; no other prep needed */
            if (recurse)
                cmd->recurse = true;
            pass = AT_PASS_MISC;
            break;
        case AT_EnableRule:     /* ENABLE/DISABLE RULE variants */
        case AT_EnableAlwaysRule:
        case AT_EnableReplicaRule:
        case AT_DisableRule:
        case AT_AddOf:          /* OF */
        case AT_DropOf:         /* NOT OF */
        case AT_EnableRowSecurity:
        case AT_DisableRowSecurity:
        case AT_ForceRowSecurity:
        case AT_NoForceRowSecurity:
            ATSimplePermissions(cmd->subtype, rel, ATT_TABLE);
            /* These commands never recurse */
            /* No command-specific prep needed */
            pass = AT_PASS_MISC;
            break;
        case AT_GenericOptions:
            ATSimplePermissions(cmd->subtype, rel, ATT_FOREIGN_TABLE);
            /* No command-specific prep needed */
            pass = AT_PASS_MISC;
            break;
        case AT_AttachPartition:
            ATSimplePermissions(cmd->subtype, rel, ATT_TABLE | ATT_PARTITIONED_INDEX);
            /* No command-specific prep needed */
            pass = AT_PASS_MISC;
            break;
        case AT_DetachPartition:
            ATSimplePermissions(cmd->subtype, rel, ATT_TABLE);
            /* No command-specific prep needed */
            pass = AT_PASS_MISC;
            break;
        case AT_DetachPartitionFinalize:
            ATSimplePermissions(cmd->subtype, rel, ATT_TABLE);
            /* No command-specific prep needed */
            pass = AT_PASS_MISC;
            break;
        case AT_SplitPartition:
            ATSimplePermissions(cmd->subtype, rel, ATT_TABLE);
            /* No command-specific prep needed */
            pass = AT_PASS_MISC;
            break;
        case AT_MergePartitions:
            ATSimplePermissions(cmd->subtype, rel, ATT_TABLE);
            /* No command-specific prep needed */
            pass = AT_PASS_MISC;
            break;
        default:                /* oops */
            elog(ERROR, "unrecognized alter table type: %d",
                 (int) cmd->subtype);
            pass = AT_PASS_UNSET;   /* keep compiler quiet */
            break;
    }
    Assert(pass > AT_PASS_UNSET);
 
    /* Add the subcommand to the appropriate list for phase 2 */
    tab->subcmds[pass] = lappend(tab->subcmds[pass], cmd);
}

References Assert, AT_AddColumn, AT_AddColumnToView, AT_AddConstraint, AT_AddIdentity, AT_AddIndex, AT_AddIndexConstraint, AT_AddInherit, AT_AddOf, AT_AlterColumnGenericOptions, AT_AlterColumnType, AT_AlterConstraint, AT_AttachPartition, AT_ChangeOwner, AT_ClusterOn, AT_ColumnDefault, AT_CookedColumnDefault, AT_DetachPartition, AT_DetachPartitionFinalize, AT_DisableRowSecurity, AT_DisableRule, AT_DisableTrig, AT_DisableTrigAll, AT_DisableTrigUser, AT_DropCluster, AT_DropColumn, AT_DropConstraint, AT_DropExpression, AT_DropIdentity, AT_DropInherit, AT_DropNotNull, AT_DropOf, AT_DropOids, AT_EnableAlwaysRule, AT_EnableAlwaysTrig, AT_EnableReplicaRule, AT_EnableReplicaTrig, AT_EnableRowSecurity, AT_EnableRule, AT_EnableTrig, AT_EnableTrigAll, AT_EnableTrigUser, AT_ForceRowSecurity, AT_GenericOptions, AT_MergePartitions, AT_NoForceRowSecurity, AT_PASS_ADD_COL, AT_PASS_ADD_CONSTR, AT_PASS_ADD_INDEX, AT_PASS_ADD_INDEXCONSTR, AT_PASS_ADD_OTHERCONSTR, AT_PASS_ALTER_TYPE, AT_PASS_COL_ATTRS, AT_PASS_DROP, AT_PASS_MISC, AT_PASS_SET_EXPRESSION, AT_PASS_UNSET, AT_ReplaceRelOptions, AT_ReplicaIdentity, AT_ResetOptions, AT_ResetRelOptions, AT_REWRITE_ALTER_PERSISTENCE, AT_SetAccessMethod, AT_SetAttNotNull, AT_SetCompression, AT_SetExpression, AT_SetIdentity, AT_SetLogged, AT_SetNotNull, AT_SetOptions, AT_SetRelOptions, AT_SetStatistics, AT_SetStorage, AT_SetTableSpace, AT_SetUnLogged, AT_SplitPartition, AT_ValidateConstraint, ATCheckPartitionsNotInUse(), ATGetQueueEntry(), ATParseTransformCmd(), ATPrepAddColumn(), ATPrepAddInherit(), ATPrepAlterColumnType(), ATPrepChangePersistence(), ATPrepDropColumn(), ATPrepDropExpression(), ATPrepSetAccessMethod(), ATPrepSetTableSpace(), ATSimplePermissions(), ATSimpleRecursion(), ATT_COMPOSITE_TYPE, ATT_FOREIGN_TABLE, ATT_INDEX, ATT_MATVIEW, ATT_PARTITIONED_INDEX, ATT_SEQUENCE, ATT_TABLE, ATT_VIEW, AlteredTableInfo::chgAccessMethod, AlteredTableInfo::chgPersistence, context, copyObject, AlterTableCmd::def, elog, ereport, errcode(), errhint(), errmsg(), ERROR, lappend(), AlterTableCmd::name, AlteredTableInfo::newrelpersistence, PartitionHasPendingDetach(), RelationData::rd_rel, AlterTableCmd::recurse, RelationGetRelationName, RelationGetRelid, AlteredTableInfo::rewrite, AlteredTableInfo::subcmds, and AlterTableCmd::subtype.

Referenced by ATController(), ATPrepAddPrimaryKey(), ATPrepAlterColumnType(), ATSimpleRecursion(), and ATTypedTableRecursion().

ATPrepDropColumn()

static void ATPrepDropColumn ( List **  wqueue, Relation  rel, bool  recurse, bool  recursing, AlterTableCmd *  cmd, LOCKMODE  lockmode, AlterTableUtilityContext *  context  )

static

Definition at line 9128 of file tablecmds.c.

{
    if (rel->rd_rel->reloftype && !recursing)
        ereport(ERROR,
                (errcode(ERRCODE_WRONG_OBJECT_TYPE),
                 errmsg("cannot drop column from typed table")));
 
    if (rel->rd_rel->relkind == RELKIND_COMPOSITE_TYPE)
        ATTypedTableRecursion(wqueue, rel, cmd, lockmode, context);
 
    if (recurse)
        cmd->recurse = true;
}

References ATTypedTableRecursion(), context, ereport, errcode(), errmsg(), ERROR, RelationData::rd_rel, and AlterTableCmd::recurse.

Referenced by ATPrepCmd().

ATPrepDropExpression()

static void ATPrepDropExpression ( Relation  rel, AlterTableCmd *  cmd, bool  recurse, bool  recursing, LOCKMODE  lockmode  )

static

Definition at line 8651 of file tablecmds.c.

{
    /*
     * Reject ONLY if there are child tables.  We could implement this, but it
     * is a bit complicated.  GENERATED clauses must be attached to the column
     * definition and cannot be added later like DEFAULT, so if a child table
     * has a generation expression that the parent does not have, the child
     * column will necessarily be an attislocal column.  So to implement ONLY
     * here, we'd need extra code to update attislocal of the direct child
     * tables, somewhat similar to how DROP COLUMN does it, so that the
     * resulting state can be properly dumped and restored.
     */
    if (!recurse &&
        find_inheritance_children(RelationGetRelid(rel), lockmode))
        ereport(ERROR,
                (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                 errmsg("ALTER TABLE / DROP EXPRESSION must be applied to child tables too")));
 
    /*
     * Cannot drop generation expression from inherited columns.
     */
    if (!recursing)
    {
        HeapTuple   tuple;
        Form_pg_attribute attTup;
 
        tuple = SearchSysCacheCopyAttName(RelationGetRelid(rel), cmd->name);
        if (!HeapTupleIsValid(tuple))
            ereport(ERROR,
                    (errcode(ERRCODE_UNDEFINED_COLUMN),
                     errmsg("column \"%s\" of relation \"%s\" does not exist",
                            cmd->name, RelationGetRelationName(rel))));
 
        attTup = (Form_pg_attribute) GETSTRUCT(tuple);
 
        if (attTup->attinhcount > 0)
            ereport(ERROR,
                    (errcode(ERRCODE_INVALID_TABLE_DEFINITION),
                     errmsg("cannot drop generation expression from inherited column")));
    }
}

References ereport, errcode(), errmsg(), ERROR, find_inheritance_children(), GETSTRUCT, HeapTupleIsValid, AlterTableCmd::name, RelationGetRelationName, RelationGetRelid, and SearchSysCacheCopyAttName().

Referenced by ATPrepCmd().

ATPrepSetAccessMethod()

static void ATPrepSetAccessMethod ( AlteredTableInfo *  tab, Relation  rel, const char *  amname  )

static

Definition at line 15401 of file tablecmds.c.

{
    Oid         amoid;
 
    /*
     * Look up the access method name and check that it differs from the
     * table's current AM.  If DEFAULT was specified for a partitioned table
     * (amname is NULL), set it to InvalidOid to reset the catalogued AM.
     */
    if (amname != NULL)
        amoid = get_table_am_oid(amname, false);
    else if (rel->rd_rel->relkind == RELKIND_PARTITIONED_TABLE)
        amoid = InvalidOid;
    else
        amoid = get_table_am_oid(default_table_access_method, false);
 
    /* if it's a match, phase 3 doesn't need to do anything */
    if (rel->rd_rel->relam == amoid)
        return;
 
    /* Save info for Phase 3 to do the real work */
    tab->rewrite |= AT_REWRITE_ACCESS_METHOD;
    tab->newAccessMethod = amoid;
    tab->chgAccessMethod = true;
}

References AT_REWRITE_ACCESS_METHOD, AlteredTableInfo::chgAccessMethod, default_table_access_method, get_table_am_oid(), InvalidOid, AlteredTableInfo::newAccessMethod, RelationData::rd_rel, and AlteredTableInfo::rewrite.

Referenced by ATPrepCmd().

ATPrepSetTableSpace()

static void ATPrepSetTableSpace ( AlteredTableInfo *  tab, Relation  rel, const char *  tablespacename, LOCKMODE  lockmode  )

static

Definition at line 15525 of file tablecmds.c.

{
    Oid         tablespaceId;
 
    /* Check that the tablespace exists */
    tablespaceId = get_tablespace_oid(tablespacename, false);
 
    /* Check permissions except when moving to database's default */
    if (OidIsValid(tablespaceId) && tablespaceId != MyDatabaseTableSpace)
    {
        AclResult   aclresult;
 
        aclresult = object_aclcheck(TableSpaceRelationId, tablespaceId, GetUserId(), ACL_CREATE);
        if (aclresult != ACLCHECK_OK)
            aclcheck_error(aclresult, OBJECT_TABLESPACE, tablespacename);
    }
 
    /* Save info for Phase 3 to do the real work */
    if (OidIsValid(tab->newTableSpace))
        ereport(ERROR,
                (errcode(ERRCODE_SYNTAX_ERROR),
                 errmsg("cannot have multiple SET TABLESPACE subcommands")));
 
    tab->newTableSpace = tablespaceId;
}

References ACL_CREATE, aclcheck_error(), ACLCHECK_OK, ereport, errcode(), errmsg(), ERROR, get_tablespace_oid(), GetUserId(), MyDatabaseTableSpace, AlteredTableInfo::newTableSpace, object_aclcheck(), OBJECT_TABLESPACE, and OidIsValid.

Referenced by ATPrepCmd().

ATRewriteCatalogs()

static void ATRewriteCatalogs ( List **  wqueue, LOCKMODE  lockmode, AlterTableUtilityContext *  context  )

static

Definition at line 5204 of file tablecmds.c.

{
    ListCell   *ltab;
 
    /*
     * We process all the tables "in parallel", one pass at a time.  This is
     * needed because we may have to propagate work from one table to another
     * (specifically, ALTER TYPE on a foreign key's PK has to dispatch the
     * re-adding of the foreign key constraint to the other table).  Work can
     * only be propagated into later passes, however.
     */
    for (AlterTablePass pass = 0; pass < AT_NUM_PASSES; pass++)
    {
        /* Go through each table that needs to be processed */
        foreach(ltab, *wqueue)
        {
            AlteredTableInfo *tab = (AlteredTableInfo *) lfirst(ltab);
            List       *subcmds = tab->subcmds[pass];
            ListCell   *lcmd;
 
            if (subcmds == NIL)
                continue;
 
            /*
             * Open the relation and store it in tab.  This allows subroutines
             * close and reopen, if necessary.  Appropriate lock was obtained
             * by phase 1, needn't get it again.
             */
            tab->rel = relation_open(tab->relid, NoLock);
 
            foreach(lcmd, subcmds)
                ATExecCmd(wqueue, tab,
                          lfirst_node(AlterTableCmd, lcmd),
                          lockmode, pass, context);
 
            /*
             * After the ALTER TYPE or SET EXPRESSION pass, do cleanup work
             * (this is not done in ATExecAlterColumnType since it should be
             * done only once if multiple columns of a table are altered).
             */
            if (pass == AT_PASS_ALTER_TYPE || pass == AT_PASS_SET_EXPRESSION)
                ATPostAlterTypeCleanup(wqueue, tab, lockmode);
 
            if (tab->rel)
            {
                relation_close(tab->rel, NoLock);
                tab->rel = NULL;
            }
        }
    }
 
    /* Check to see if a toast table must be added. */
    foreach(ltab, *wqueue)
    {
        AlteredTableInfo *tab = (AlteredTableInfo *) lfirst(ltab);
 
        /*
         * If the table is source table of ATTACH PARTITION command, we did
         * not modify anything about it that will change its toasting
         * requirement, so no need to check.
         */
        if (((tab->relkind == RELKIND_RELATION ||
              tab->relkind == RELKIND_PARTITIONED_TABLE) &&
             tab->partition_constraint == NULL) ||
            tab->relkind == RELKIND_MATVIEW)
            AlterTableCreateToastTable(tab->relid, (Datum) 0, lockmode);
    }
}

References AlterTableCreateToastTable(), AT_NUM_PASSES, AT_PASS_ALTER_TYPE, AT_PASS_SET_EXPRESSION, ATExecCmd(), ATPostAlterTypeCleanup(), context, lfirst, lfirst_node, NIL, NoLock, AlteredTableInfo::partition_constraint, AlteredTableInfo::rel, relation_close(), relation_open(), AlteredTableInfo::relid, AlteredTableInfo::relkind, and AlteredTableInfo::subcmds.

Referenced by ATController().

ATRewriteTable()

static void ATRewriteTable ( AlteredTableInfo *  tab, Oid  OIDNewHeap, LOCKMODE  lockmode  )

static

Definition at line 6052 of file tablecmds.c.

{
    Relation    oldrel;
    Relation    newrel;
    TupleDesc   oldTupDesc;
    TupleDesc   newTupDesc;
    bool        needscan = false;
    List       *notnull_attrs;
    int         i;
    ListCell   *l;
    EState     *estate;
    CommandId   mycid;
    BulkInsertState bistate;
    int         ti_options;
    ExprState  *partqualstate = NULL;
 
    /*
     * Open the relation(s).  We have surely already locked the existing
     * table.
     */
    oldrel = table_open(tab->relid, NoLock);
    oldTupDesc = tab->oldDesc;
    newTupDesc = RelationGetDescr(oldrel);  /* includes all mods */
 
    if (OidIsValid(OIDNewHeap))
        newrel = table_open(OIDNewHeap, lockmode);
    else
        newrel = NULL;
 
    /*
     * Prepare a BulkInsertState and options for table_tuple_insert.  The FSM
     * is empty, so don't bother using it.
     */
    if (newrel)
    {
        mycid = GetCurrentCommandId(true);
        bistate = GetBulkInsertState();
        ti_options = TABLE_INSERT_SKIP_FSM;
    }
    else
    {
        /* keep compiler quiet about using these uninitialized */
        mycid = 0;
        bistate = NULL;
        ti_options = 0;
    }
 
    /*
     * Generate the constraint and default execution states
     */
 
    estate = CreateExecutorState();
 
    /* Build the needed expression execution states */
    foreach(l, tab->constraints)
    {
        NewConstraint *con = lfirst(l);
 
        switch (con->contype)
        {
            case CONSTR_CHECK:
                needscan = true;
                con->qualstate = ExecPrepareExpr((Expr *) con->qual, estate);
                break;
            case CONSTR_FOREIGN:
                /* Nothing to do here */
                break;
            default:
                elog(ERROR, "unrecognized constraint type: %d",
                     (int) con->contype);
        }
    }
 
    /* Build expression execution states for partition check quals */
    if (tab->partition_constraint)
    {
        needscan = true;
        partqualstate = ExecPrepareExpr(tab->partition_constraint, estate);
    }
 
    foreach(l, tab->newvals)
    {
        NewColumnValue *ex = lfirst(l);
 
        /* expr already planned */
        ex->exprstate = ExecInitExpr((Expr *) ex->expr, NULL);
    }
 
    notnull_attrs = NIL;
    if (newrel || tab->verify_new_notnull)
    {
        /*
         * If we are rebuilding the tuples OR if we added any new but not
         * verified not-null constraints, check all not-null constraints. This
         * is a bit of overkill but it minimizes risk of bugs, and
         * heap_attisnull is a pretty cheap test anyway.
         */
        for (i = 0; i < newTupDesc->natts; i++)
        {
            Form_pg_attribute attr = TupleDescAttr(newTupDesc, i);
 
            if (attr->attnotnull && !attr->attisdropped)
                notnull_attrs = lappend_int(notnull_attrs, i);
        }
        if (notnull_attrs)
            needscan = true;
    }
 
    if (newrel || needscan)
    {
        ExprContext *econtext;
        TupleTableSlot *oldslot;
        TupleTableSlot *newslot;
        TableScanDesc scan;
        MemoryContext oldCxt;
        List       *dropped_attrs = NIL;
        ListCell   *lc;
        Snapshot    snapshot;
 
        if (newrel)
            ereport(DEBUG1,
                    (errmsg_internal("rewriting table \"%s\"",
                                     RelationGetRelationName(oldrel))));
        else
            ereport(DEBUG1,
                    (errmsg_internal("verifying table \"%s\"",
                                     RelationGetRelationName(oldrel))));
 
        if (newrel)
        {
            /*
             * All predicate locks on the tuples or pages are about to be made
             * invalid, because we move tuples around.  Promote them to
             * relation locks.
             */
            TransferPredicateLocksToHeapRelation(oldrel);
        }
 
        econtext = GetPerTupleExprContext(estate);
 
        /*
         * Create necessary tuple slots. When rewriting, two slots are needed,
         * otherwise one suffices. In the case where one slot suffices, we
         * need to use the new tuple descriptor, otherwise some constraints
         * can't be evaluated.  Note that even when the tuple layout is the
         * same and no rewrite is required, the tupDescs might not be
         * (consider ADD COLUMN without a default).
         */
        if (tab->rewrite)
        {
            Assert(newrel != NULL);
            oldslot = MakeSingleTupleTableSlot(oldTupDesc,
                                               table_slot_callbacks(oldrel));
            newslot = MakeSingleTupleTableSlot(newTupDesc,
                                               table_slot_callbacks(newrel));
 
            /*
             * Set all columns in the new slot to NULL initially, to ensure
             * columns added as part of the rewrite are initialized to NULL.
             * That is necessary as tab->newvals will not contain an
             * expression for columns with a NULL default, e.g. when adding a
             * column without a default together with a column with a default
             * requiring an actual rewrite.
             */
            ExecStoreAllNullTuple(newslot);
        }
        else
        {
            oldslot = MakeSingleTupleTableSlot(newTupDesc,
                                               table_slot_callbacks(oldrel));
            newslot = NULL;
        }
 
        /*
         * Any attributes that are dropped according to the new tuple
         * descriptor can be set to NULL. We precompute the list of dropped
         * attributes to avoid needing to do so in the per-tuple loop.
         */
        for (i = 0; i < newTupDesc->natts; i++)
        {
            if (TupleDescAttr(newTupDesc, i)->attisdropped)
                dropped_attrs = lappend_int(dropped_attrs, i);
        }
 
        /*
         * Scan through the rows, generating a new row if needed and then
         * checking all the constraints.
         */
        snapshot = RegisterSnapshot(GetLatestSnapshot());
        scan = table_beginscan(oldrel, snapshot, 0, NULL);
 
        /*
         * Switch to per-tuple memory context and reset it for each tuple
         * produced, so we don't leak memory.
         */
        oldCxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(estate));
 
        while (table_scan_getnextslot(scan, ForwardScanDirection, oldslot))
        {
            TupleTableSlot *insertslot;
 
            if (tab->rewrite > 0)
            {
                /* Extract data from old tuple */
                slot_getallattrs(oldslot);
                ExecClearTuple(newslot);
 
                /* copy attributes */
                memcpy(newslot->tts_values, oldslot->tts_values,
                       sizeof(Datum) * oldslot->tts_nvalid);
                memcpy(newslot->tts_isnull, oldslot->tts_isnull,
                       sizeof(bool) * oldslot->tts_nvalid);
 
                /* Set dropped attributes to null in new tuple */
                foreach(lc, dropped_attrs)
                    newslot->tts_isnull[lfirst_int(lc)] = true;
 
                /*
                 * Constraints and GENERATED expressions might reference the
                 * tableoid column, so fill tts_tableOid with the desired
                 * value.  (We must do this each time, because it gets
                 * overwritten with newrel's OID during storing.)
                 */
                newslot->tts_tableOid = RelationGetRelid(oldrel);
 
                /*
                 * Process supplied expressions to replace selected columns.
                 *
                 * First, evaluate expressions whose inputs come from the old
                 * tuple.
                 */
                econtext->ecxt_scantuple = oldslot;
 
                foreach(l, tab->newvals)
                {
                    NewColumnValue *ex = lfirst(l);
 
                    if (ex->is_generated)
                        continue;
 
                    newslot->tts_values[ex->attnum - 1]
                        = ExecEvalExpr(ex->exprstate,
                                       econtext,
                                       &newslot->tts_isnull[ex->attnum - 1]);
                }
 
                ExecStoreVirtualTuple(newslot);
 
                /*
                 * Now, evaluate any expressions whose inputs come from the
                 * new tuple.  We assume these columns won't reference each
                 * other, so that there's no ordering dependency.
                 */
                econtext->ecxt_scantuple = newslot;
 
                foreach(l, tab->newvals)
                {
                    NewColumnValue *ex = lfirst(l);
 
                    if (!ex->is_generated)
                        continue;
 
                    newslot->tts_values[ex->attnum - 1]
                        = ExecEvalExpr(ex->exprstate,
                                       econtext,
                                       &newslot->tts_isnull[ex->attnum - 1]);
                }
 
                insertslot = newslot;
            }
            else
            {
                /*
                 * If there's no rewrite, old and new table are guaranteed to
                 * have the same AM, so we can just use the old slot to verify
                 * new constraints etc.
                 */
                insertslot = oldslot;
            }
 
            /* Now check any constraints on the possibly-changed tuple */
            econtext->ecxt_scantuple = insertslot;
 
            foreach(l, notnull_attrs)
            {
                int         attn = lfirst_int(l);
 
                if (slot_attisnull(insertslot, attn + 1))
                {
                    Form_pg_attribute attr = TupleDescAttr(newTupDesc, attn);
 
                    ereport(ERROR,
                            (errcode(ERRCODE_NOT_NULL_VIOLATION),
                             errmsg("column \"%s\" of relation \"%s\" contains null values",
                                    NameStr(attr->attname),
                                    RelationGetRelationName(oldrel)),
                             errtablecol(oldrel, attn + 1)));
                }
            }
 
            foreach(l, tab->constraints)
            {
                NewConstraint *con = lfirst(l);
 
                switch (con->contype)
                {
                    case CONSTR_CHECK:
                        if (!ExecCheck(con->qualstate, econtext))
                            ereport(ERROR,
                                    (errcode(ERRCODE_CHECK_VIOLATION),
                                     errmsg("check constraint \"%s\" of relation \"%s\" is violated by some row",
                                            con->name,
                                            RelationGetRelationName(oldrel)),
                                     errtableconstraint(oldrel, con->name)));
                        break;
                    case CONSTR_NOTNULL:
                    case CONSTR_FOREIGN:
                        /* Nothing to do here */
                        break;
                    default:
                        elog(ERROR, "unrecognized constraint type: %d",
                             (int) con->contype);
                }
            }
 
            if (partqualstate && !ExecCheck(partqualstate, econtext))
            {
                if (tab->validate_default)
                    ereport(ERROR,
                            (errcode(ERRCODE_CHECK_VIOLATION),
                             errmsg("updated partition constraint for default partition \"%s\" would be violated by some row",
                                    RelationGetRelationName(oldrel)),
                             errtable(oldrel)));
                else
                    ereport(ERROR,
                            (errcode(ERRCODE_CHECK_VIOLATION),
                             errmsg("partition constraint of relation \"%s\" is violated by some row",
                                    RelationGetRelationName(oldrel)),
                             errtable(oldrel)));
            }
 
            /* Write the tuple out to the new relation */
            if (newrel)
                table_tuple_insert(newrel, insertslot, mycid,
                                   ti_options, bistate);
 
            ResetExprContext(econtext);
 
            CHECK_FOR_INTERRUPTS();
        }
 
        MemoryContextSwitchTo(oldCxt);
        table_endscan(scan);
        UnregisterSnapshot(snapshot);
 
        ExecDropSingleTupleTableSlot(oldslot);
        if (newslot)
            ExecDropSingleTupleTableSlot(newslot);
    }
 
    FreeExecutorState(estate);
 
    table_close(oldrel, NoLock);
    if (newrel)
    {
        FreeBulkInsertState(bistate);
 
        table_finish_bulk_insert(newrel, ti_options);
 
        table_close(newrel, NoLock);
    }
}

References Assert, NewColumnValue::attnum, CHECK_FOR_INTERRUPTS, CONSTR_CHECK, CONSTR_FOREIGN, CONSTR_NOTNULL, AlteredTableInfo::constraints, NewConstraint::contype, CreateExecutorState(), DEBUG1, ExprContext::ecxt_scantuple, elog, ereport, errcode(), errmsg(), errmsg_internal(), ERROR, errtable(), errtablecol(), errtableconstraint(), ExecCheck(), ExecClearTuple(), ExecDropSingleTupleTableSlot(), ExecEvalExpr(), ExecInitExpr(), ExecPrepareExpr(), ExecStoreAllNullTuple(), ExecStoreVirtualTuple(), NewColumnValue::expr, NewColumnValue::exprstate, ForwardScanDirection, FreeBulkInsertState(), FreeExecutorState(), GetBulkInsertState(), GetCurrentCommandId(), GetLatestSnapshot(), GetPerTupleExprContext, GetPerTupleMemoryContext, i, NewColumnValue::is_generated, lappend_int(), lfirst, lfirst_int, MakeSingleTupleTableSlot(), MemoryContextSwitchTo(), NewConstraint::name, NameStr, TupleDescData::natts, AlteredTableInfo::newvals, NIL, NoLock, OidIsValid, AlteredTableInfo::oldDesc, AlteredTableInfo::partition_constraint, NewConstraint::qual, NewConstraint::qualstate, RegisterSnapshot(), RelationGetDescr, RelationGetRelationName, RelationGetRelid, AlteredTableInfo::relid, ResetExprContext, AlteredTableInfo::rewrite, slot_attisnull(), slot_getallattrs(), table_beginscan(), table_close(), table_endscan(), table_finish_bulk_insert(), TABLE_INSERT_SKIP_FSM, table_open(), table_scan_getnextslot(), table_slot_callbacks(), table_tuple_insert(), TransferPredicateLocksToHeapRelation(), TupleTableSlot::tts_isnull, TupleTableSlot::tts_nvalid, TupleTableSlot::tts_tableOid, TupleTableSlot::tts_values, TupleDescAttr, UnregisterSnapshot(), AlteredTableInfo::validate_default, and AlteredTableInfo::verify_new_notnull.

Referenced by ATRewriteTables().

ATRewriteTables()

static void ATRewriteTables ( AlterTableStmt *  parsetree, List **  wqueue, LOCKMODE  lockmode, AlterTableUtilityContext *  context  )

static

Definition at line 5767 of file tablecmds.c.

{
    ListCell   *ltab;
 
    /* Go through each table that needs to be checked or rewritten */
    foreach(ltab, *wqueue)
    {
        AlteredTableInfo *tab = (AlteredTableInfo *) lfirst(ltab);
 
        /* Relations without storage may be ignored here */
        if (!RELKIND_HAS_STORAGE(tab->relkind))
            continue;
 
        /*
         * If we change column data types, the operation has to be propagated
         * to tables that use this table's rowtype as a column type.
         * tab->newvals will also be non-NULL in the case where we're adding a
         * column with a default.  We choose to forbid that case as well,
         * since composite types might eventually support defaults.
         *
         * (Eventually we'll probably need to check for composite type
         * dependencies even when we're just scanning the table without a
         * rewrite, but at the moment a composite type does not enforce any
         * constraints, so it's not necessary/appropriate to enforce them just
         * during ALTER.)
         */
        if (tab->newvals != NIL || tab->rewrite > 0)
        {
            Relation    rel;
 
            rel = table_open(tab->relid, NoLock);
            find_composite_type_dependencies(rel->rd_rel->reltype, rel, NULL);
            table_close(rel, NoLock);
        }
 
        /*
         * We only need to rewrite the table if at least one column needs to
         * be recomputed, or we are changing its persistence or access method.
         *
         * There are two reasons for requiring a rewrite when changing
         * persistence: on one hand, we need to ensure that the buffers
         * belonging to each of the two relations are marked with or without
         * BM_PERMANENT properly.  On the other hand, since rewriting creates
         * and assigns a new relfilenumber, we automatically create or drop an
         * init fork for the relation as appropriate.
         */
        if (tab->rewrite > 0 && tab->relkind != RELKIND_SEQUENCE)
        {
            /* Build a temporary relation and copy data */
            Relation    OldHeap;
            Oid         OIDNewHeap;
            Oid         NewAccessMethod;
            Oid         NewTableSpace;
            char        persistence;
 
            OldHeap = table_open(tab->relid, NoLock);
 
            /*
             * We don't support rewriting of system catalogs; there are too
             * many corner cases and too little benefit.  In particular this
             * is certainly not going to work for mapped catalogs.
             */
            if (IsSystemRelation(OldHeap))
                ereport(ERROR,
                        (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                         errmsg("cannot rewrite system relation \"%s\"",
                                RelationGetRelationName(OldHeap))));
 
            if (RelationIsUsedAsCatalogTable(OldHeap))
                ereport(ERROR,
                        (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                         errmsg("cannot rewrite table \"%s\" used as a catalog table",
                                RelationGetRelationName(OldHeap))));
 
            /*
             * Don't allow rewrite on temp tables of other backends ... their
             * local buffer manager is not going to cope.
             */
            if (RELATION_IS_OTHER_TEMP(OldHeap))
                ereport(ERROR,
                        (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                         errmsg("cannot rewrite temporary tables of other sessions")));
 
            /*
             * Select destination tablespace (same as original unless user
             * requested a change)
             */
            if (tab->newTableSpace)
                NewTableSpace = tab->newTableSpace;
            else
                NewTableSpace = OldHeap->rd_rel->reltablespace;
 
            /*
             * Select destination access method (same as original unless user
             * requested a change)
             */
            if (tab->chgAccessMethod)
                NewAccessMethod = tab->newAccessMethod;
            else
                NewAccessMethod = OldHeap->rd_rel->relam;
 
            /*
             * Select persistence of transient table (same as original unless
             * user requested a change)
             */
            persistence = tab->chgPersistence ?
                tab->newrelpersistence : OldHeap->rd_rel->relpersistence;
 
            table_close(OldHeap, NoLock);
 
            /*
             * Fire off an Event Trigger now, before actually rewriting the
             * table.
             *
             * We don't support Event Trigger for nested commands anywhere,
             * here included, and parsetree is given NULL when coming from
             * AlterTableInternal.
             *
             * And fire it only once.
             */
            if (parsetree)
                EventTriggerTableRewrite((Node *) parsetree,
                                         tab->relid,
                                         tab->rewrite);
 
            /*
             * Create transient table that will receive the modified data.
             *
             * Ensure it is marked correctly as logged or unlogged.  We have
             * to do this here so that buffers for the new relfilenumber will
             * have the right persistence set, and at the same time ensure
             * that the original filenumbers's buffers will get read in with
             * the correct setting (i.e. the original one).  Otherwise a
             * rollback after the rewrite would possibly result with buffers
             * for the original filenumbers having the wrong persistence
             * setting.
             *
             * NB: This relies on swap_relation_files() also swapping the
             * persistence. That wouldn't work for pg_class, but that can't be
             * unlogged anyway.
             */
            OIDNewHeap = make_new_heap(tab->relid, NewTableSpace, NewAccessMethod,
                                       persistence, lockmode);
 
            /*
             * Copy the heap data into the new table with the desired
             * modifications, and test the current data within the table
             * against new constraints generated by ALTER TABLE commands.
             */
            ATRewriteTable(tab, OIDNewHeap, lockmode);
 
            /*
             * Swap the physical files of the old and new heaps, then rebuild
             * indexes and discard the old heap.  We can use RecentXmin for
             * the table's new relfrozenxid because we rewrote all the tuples
             * in ATRewriteTable, so no older Xid remains in the table.  Also,
             * we never try to swap toast tables by content, since we have no
             * interest in letting this code work on system catalogs.
             */
            finish_heap_swap(tab->relid, OIDNewHeap,
                             false, false, true,
                             !OidIsValid(tab->newTableSpace),
                             RecentXmin,
                             ReadNextMultiXactId(),
                             persistence);
 
            InvokeObjectPostAlterHook(RelationRelationId, tab->relid, 0);
        }
        else if (tab->rewrite > 0 && tab->relkind == RELKIND_SEQUENCE)
        {
            if (tab->chgPersistence)
                SequenceChangePersistence(tab->relid, tab->newrelpersistence);
        }
        else
        {
            /*
             * If required, test the current data within the table against new
             * constraints generated by ALTER TABLE commands, but don't
             * rebuild data.
             */
            if (tab->constraints != NIL || tab->verify_new_notnull ||
                tab->partition_constraint != NULL)
                ATRewriteTable(tab, InvalidOid, lockmode);
 
            /*
             * If we had SET TABLESPACE but no reason to reconstruct tuples,
             * just do a block-by-block copy.
             */
            if (tab->newTableSpace)
                ATExecSetTableSpace(tab->relid, tab->newTableSpace, lockmode);
        }
 
        /*
         * Also change persistence of owned sequences, so that it matches the
         * table persistence.
         */
        if (tab->chgPersistence)
        {
            List       *seqlist = getOwnedSequences(tab->relid);
            ListCell   *lc;
 
            foreach(lc, seqlist)
            {
                Oid         seq_relid = lfirst_oid(lc);
 
                SequenceChangePersistence(seq_relid, tab->newrelpersistence);
            }
        }
    }
 
    /*
     * Foreign key constraints are checked in a final pass, since (a) it's
     * generally best to examine each one separately, and (b) it's at least
     * theoretically possible that we have changed both relations of the
     * foreign key, and we'd better have finished both rewrites before we try
     * to read the tables.
     */
    foreach(ltab, *wqueue)
    {
        AlteredTableInfo *tab = (AlteredTableInfo *) lfirst(ltab);
        Relation    rel = NULL;
        ListCell   *lcon;
 
        /* Relations without storage may be ignored here too */
        if (!RELKIND_HAS_STORAGE(tab->relkind))
            continue;
 
        foreach(lcon, tab->constraints)
        {
            NewConstraint *con = lfirst(lcon);
 
            if (con->contype == CONSTR_FOREIGN)
            {
                Constraint *fkconstraint = (Constraint *) con->qual;
                Relation    refrel;
 
                if (rel == NULL)
                {
                    /* Long since locked, no need for another */
                    rel = table_open(tab->relid, NoLock);
                }
 
                refrel = table_open(con->refrelid, RowShareLock);
 
                validateForeignKeyConstraint(fkconstraint->conname, rel, refrel,
                                             con->refindid,
                                             con->conid,
                                             con->conwithperiod);
 
                /*
                 * No need to mark the constraint row as validated, we did
                 * that when we inserted the row earlier.
                 */
 
                table_close(refrel, NoLock);
            }
        }
 
        if (rel)
            table_close(rel, NoLock);
    }
 
    /* Finally, run any afterStmts that were queued up */
    foreach(ltab, *wqueue)
    {
        AlteredTableInfo *tab = (AlteredTableInfo *) lfirst(ltab);
        ListCell   *lc;
 
        foreach(lc, tab->afterStmts)
        {
            Node       *stmt = (Node *) lfirst(lc);
 
            ProcessUtilityForAlterTable(stmt, context);
            CommandCounterIncrement();
        }
    }
}

References AlteredTableInfo::afterStmts, ATExecSetTableSpace(), ATRewriteTable(), AlteredTableInfo::chgAccessMethod, AlteredTableInfo::chgPersistence, CommandCounterIncrement(), NewConstraint::conid, Constraint::conname, CONSTR_FOREIGN, AlteredTableInfo::constraints, context, NewConstraint::contype, NewConstraint::conwithperiod, ereport, errcode(), errmsg(), ERROR, EventTriggerTableRewrite(), find_composite_type_dependencies(), finish_heap_swap(), getOwnedSequences(), if(), InvalidOid, InvokeObjectPostAlterHook, IsSystemRelation(), lfirst, lfirst_oid, make_new_heap(), AlteredTableInfo::newAccessMethod, AlteredTableInfo::newrelpersistence, AlteredTableInfo::newTableSpace, AlteredTableInfo::newvals, NIL, NoLock, OidIsValid, AlteredTableInfo::partition_constraint, ProcessUtilityForAlterTable(), NewConstraint::qual, RelationData::rd_rel, ReadNextMultiXactId(), RecentXmin, NewConstraint::refindid, NewConstraint::refrelid, RELATION_IS_OTHER_TEMP, RelationGetRelationName, RelationIsUsedAsCatalogTable, AlteredTableInfo::relid, AlteredTableInfo::relkind, AlteredTableInfo::rewrite, RowShareLock, SequenceChangePersistence(), stmt, table_close(), table_open(), validateForeignKeyConstraint(), and AlteredTableInfo::verify_new_notnull.

Referenced by ATController().

ATSimplePermissions()

static void ATSimplePermissions ( AlterTableType  cmdtype, Relation  rel, int  allowed_targets  )

static

Definition at line 6612 of file tablecmds.c.

{
    int         actual_target;
 
    switch (rel->rd_rel->relkind)
    {
        case RELKIND_RELATION:
        case RELKIND_PARTITIONED_TABLE:
            actual_target = ATT_TABLE;
            break;
        case RELKIND_VIEW:
            actual_target = ATT_VIEW;
            break;
        case RELKIND_MATVIEW:
            actual_target = ATT_MATVIEW;
            break;
        case RELKIND_INDEX:
            actual_target = ATT_INDEX;
            break;
        case RELKIND_PARTITIONED_INDEX:
            actual_target = ATT_PARTITIONED_INDEX;
            break;
        case RELKIND_COMPOSITE_TYPE:
            actual_target = ATT_COMPOSITE_TYPE;
            break;
        case RELKIND_FOREIGN_TABLE:
            actual_target = ATT_FOREIGN_TABLE;
            break;
        case RELKIND_SEQUENCE:
            actual_target = ATT_SEQUENCE;
            break;
        default:
            actual_target = 0;
            break;
    }
 
    /* Wrong target type? */
    if ((actual_target & allowed_targets) == 0)
    {
        const char *action_str = alter_table_type_to_string(cmdtype);
 
        if (action_str)
            ereport(ERROR,
                    (errcode(ERRCODE_WRONG_OBJECT_TYPE),
            /* translator: %s is a group of some SQL keywords */
                     errmsg("ALTER action %s cannot be performed on relation \"%s\"",
                            action_str, RelationGetRelationName(rel)),
                     errdetail_relkind_not_supported(rel->rd_rel->relkind)));
        else
            /* internal error? */
            elog(ERROR, "invalid ALTER action attempted on relation \"%s\"",
                 RelationGetRelationName(rel));
    }
 
    /* Permissions checks */
    if (!object_ownercheck(RelationRelationId, RelationGetRelid(rel), GetUserId()))
        aclcheck_error(ACLCHECK_NOT_OWNER, get_relkind_objtype(rel->rd_rel->relkind),
                       RelationGetRelationName(rel));
 
    if (!allowSystemTableMods && IsSystemRelation(rel))
        ereport(ERROR,
                (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
                 errmsg("permission denied: \"%s\" is a system catalog",
                        RelationGetRelationName(rel))));
}

References aclcheck_error(), ACLCHECK_NOT_OWNER, allowSystemTableMods, alter_table_type_to_string(), ATT_COMPOSITE_TYPE, ATT_FOREIGN_TABLE, ATT_INDEX, ATT_MATVIEW, ATT_PARTITIONED_INDEX, ATT_SEQUENCE, ATT_TABLE, ATT_VIEW, elog, ereport, errcode(), errdetail_relkind_not_supported(), errmsg(), ERROR, get_relkind_objtype(), GetUserId(), IsSystemRelation(), object_ownercheck(), RelationData::rd_rel, RelationGetRelationName, and RelationGetRelid.

Referenced by ATAddCheckNNConstraint(), ATExecAddColumn(), ATExecAddInherit(), ATExecAttachPartition(), ATExecDropColumn(), ATExecSetNotNull(), ATPrepCmd(), and dropconstraint_internal().

ATSimpleRecursion()

static void ATSimpleRecursion ( List **  wqueue, Relation  rel, AlterTableCmd *  cmd, bool  recurse, LOCKMODE  lockmode, AlterTableUtilityContext *  context  )

static

Definition at line 6687 of file tablecmds.c.

{
    /*
     * Propagate to children, if desired and if there are (or might be) any
     * children.
     */
    if (recurse && rel->rd_rel->relhassubclass)
    {
        Oid         relid = RelationGetRelid(rel);
        ListCell   *child;
        List       *children;
 
        children = find_all_inheritors(relid, lockmode, NULL);
 
        /*
         * find_all_inheritors does the recursive search of the inheritance
         * hierarchy, so all we have to do is process all of the relids in the
         * list that it returns.
         */
        foreach(child, children)
        {
            Oid         childrelid = lfirst_oid(child);
            Relation    childrel;
 
            if (childrelid == relid)
                continue;
            /* find_all_inheritors already got lock */
            childrel = relation_open(childrelid, NoLock);
            CheckTableNotInUse(childrel, "ALTER TABLE");
            ATPrepCmd(wqueue, childrel, cmd, false, true, lockmode, context);
            relation_close(childrel, NoLock);
        }
    }
}

References ATPrepCmd(), CheckTableNotInUse(), context, find_all_inheritors(), lfirst_oid, NoLock, RelationData::rd_rel, relation_close(), relation_open(), and RelationGetRelid.

Referenced by ATParseTransformCmd(), and ATPrepCmd().

AttachPartitionEnsureIndexes()

static void AttachPartitionEnsureIndexes ( List **  wqueue, Relation  rel, Relation  attachrel  )

static

Definition at line 19478 of file tablecmds.c.

{
    List       *idxes;
    List       *attachRelIdxs;
    Relation   *attachrelIdxRels;
    IndexInfo **attachInfos;
    ListCell   *cell;
    MemoryContext cxt;
    MemoryContext oldcxt;
 
    cxt = AllocSetContextCreate(CurrentMemoryContext,
                                "AttachPartitionEnsureIndexes",
                                ALLOCSET_DEFAULT_SIZES);
    oldcxt = MemoryContextSwitchTo(cxt);
 
    idxes = RelationGetIndexList(rel);
    attachRelIdxs = RelationGetIndexList(attachrel);
    attachrelIdxRels = palloc(sizeof(Relation) * list_length(attachRelIdxs));
    attachInfos = palloc(sizeof(IndexInfo *) * list_length(attachRelIdxs));
 
    /* Build arrays of all existing indexes and their IndexInfos */
    foreach(cell, attachRelIdxs)
    {
        Oid         cldIdxId = lfirst_oid(cell);
        int         i = foreach_current_index(cell);
 
        attachrelIdxRels[i] = index_open(cldIdxId, AccessShareLock);
        attachInfos[i] = BuildIndexInfo(attachrelIdxRels[i]);
    }
 
    /*
     * If we're attaching a foreign table, we must fail if any of the indexes
     * is a constraint index; otherwise, there's nothing to do here.  Do this
     * before starting work, to avoid wasting the effort of building a few
     * non-unique indexes before coming across a unique one.
     */
    if (attachrel->rd_rel->relkind == RELKIND_FOREIGN_TABLE)
    {
        foreach(cell, idxes)
        {
            Oid         idx = lfirst_oid(cell);
            Relation    idxRel = index_open(idx, AccessShareLock);
 
            if (idxRel->rd_index->indisunique ||
                idxRel->rd_index->indisprimary)
                ereport(ERROR,
                        (errcode(ERRCODE_WRONG_OBJECT_TYPE),
                         errmsg("cannot attach foreign table \"%s\" as partition of partitioned table \"%s\"",
                                RelationGetRelationName(attachrel),
                                RelationGetRelationName(rel)),
                         errdetail("Partitioned table \"%s\" contains unique indexes.",
                                   RelationGetRelationName(rel))));
            index_close(idxRel, AccessShareLock);
        }
 
        goto out;
    }
 
    /*
     * For each index on the partitioned table, find a matching one in the
     * partition-to-be; if one is not found, create one.
     */
    foreach(cell, idxes)
    {
        Oid         idx = lfirst_oid(cell);
        Relation    idxRel = index_open(idx, AccessShareLock);
        IndexInfo  *info;
        AttrMap    *attmap;
        bool        found = false;
        Oid         constraintOid;
 
        /*
         * Ignore indexes in the partitioned table other than partitioned
         * indexes.
         */
        if (idxRel->rd_rel->relkind != RELKIND_PARTITIONED_INDEX)
        {
            index_close(idxRel, AccessShareLock);
            continue;
        }
 
        /* construct an indexinfo to compare existing indexes against */
        info = BuildIndexInfo(idxRel);
        attmap = build_attrmap_by_name(RelationGetDescr(attachrel),
                                       RelationGetDescr(rel),
                                       false);
        constraintOid = get_relation_idx_constraint_oid(RelationGetRelid(rel), idx);
 
        /*
         * Scan the list of existing indexes in the partition-to-be, and mark
         * the first matching, valid, unattached one we find, if any, as
         * partition of the parent index.  If we find one, we're done.
         */
        for (int i = 0; i < list_length(attachRelIdxs); i++)
        {
            Oid         cldIdxId = RelationGetRelid(attachrelIdxRels[i]);
            Oid         cldConstrOid = InvalidOid;
 
            /* does this index have a parent?  if so, can't use it */
            if (attachrelIdxRels[i]->rd_rel->relispartition)
                continue;
 
            /* If this index is invalid, can't use it */
            if (!attachrelIdxRels[i]->rd_index->indisvalid)
                continue;
 
            if (CompareIndexInfo(attachInfos[i], info,
                                 attachrelIdxRels[i]->rd_indcollation,
                                 idxRel->rd_indcollation,
                                 attachrelIdxRels[i]->rd_opfamily,
                                 idxRel->rd_opfamily,
                                 attmap))
            {
                /*
                 * If this index is being created in the parent because of a
                 * constraint, then the child needs to have a constraint also,
                 * so look for one.  If there is no such constraint, this
                 * index is no good, so keep looking.
                 */
                if (OidIsValid(constraintOid))
                {
                    cldConstrOid =
                        get_relation_idx_constraint_oid(RelationGetRelid(attachrel),
                                                        cldIdxId);
                    /* no dice */
                    if (!OidIsValid(cldConstrOid))
                        continue;
 
                    /* Ensure they're both the same type of constraint */
                    if (get_constraint_type(constraintOid) !=
                        get_constraint_type(cldConstrOid))
                        continue;
                }
 
                /* bingo. */
                IndexSetParentIndex(attachrelIdxRels[i], idx);
                if (OidIsValid(constraintOid))
                    ConstraintSetParentConstraint(cldConstrOid, constraintOid,
                                                  RelationGetRelid(attachrel));
                found = true;
 
                CommandCounterIncrement();
                break;
            }
        }
 
        /*
         * If no suitable index was found in the partition-to-be, create one
         * now.
         */
        if (!found)
        {
            IndexStmt  *stmt;
            Oid         conOid;
 
            stmt = generateClonedIndexStmt(NULL,
                                           idxRel, attmap,
                                           &conOid);
 
            /*
             * If the index is a primary key, mark all columns as NOT NULL if
             * they aren't already.
             */
            if (stmt->primary)
            {
                MemoryContextSwitchTo(oldcxt);
                for (int j = 0; j < info->ii_NumIndexKeyAttrs; j++)
                {
                    AttrNumber  childattno;
 
                    childattno = get_attnum(RelationGetRelid(attachrel),
                                            get_attname(RelationGetRelid(rel),
                                                        info->ii_IndexAttrNumbers[j],
                                                        false));
                    set_attnotnull(wqueue, attachrel, childattno,
                                   true, AccessExclusiveLock);
                }
                MemoryContextSwitchTo(cxt);
            }
 
            DefineIndex(RelationGetRelid(attachrel), stmt, InvalidOid,
                        RelationGetRelid(idxRel),
                        conOid,
                        -1,
                        true, false, false, false, false);
        }
 
        index_close(idxRel, AccessShareLock);
    }
 
out:
    /* Clean up. */
    for (int i = 0; i < list_length(attachRelIdxs); i++)
        index_close(attachrelIdxRels[i], AccessShareLock);
    MemoryContextSwitchTo(oldcxt);
    MemoryContextDelete(cxt);
}

References AccessExclusiveLock, AccessShareLock, ALLOCSET_DEFAULT_SIZES, AllocSetContextCreate, build_attrmap_by_name(), BuildIndexInfo(), CommandCounterIncrement(), CompareIndexInfo(), ConstraintSetParentConstraint(), CurrentMemoryContext, DefineIndex(), ereport, errcode(), errdetail(), errmsg(), ERROR, foreach_current_index, generateClonedIndexStmt(), get_attname(), get_attnum(), get_constraint_type(), get_relation_idx_constraint_oid(), i, idx(), IndexInfo::ii_IndexAttrNumbers, IndexInfo::ii_NumIndexKeyAttrs, index_close(), index_open(), IndexSetParentIndex(), InvalidOid, j, lfirst_oid, list_length(), MemoryContextDelete(), MemoryContextSwitchTo(), OidIsValid, palloc(), RelationData::rd_indcollation, RelationData::rd_index, RelationData::rd_opfamily, RelationData::rd_rel, RelationGetDescr, RelationGetIndexList(), RelationGetRelationName, RelationGetRelid, set_attnotnull(), and stmt.

Referenced by attachPartitionTable().

attachPartitionTable()

static void attachPartitionTable ( List **  wqueue, Relation  rel, Relation  attachrel, PartitionBoundSpec *  bound  )

static

Definition at line 19150 of file tablecmds.c.

{
    /* OK to create inheritance.  Rest of the checks performed there */
    CreateInheritance(attachrel, rel, true);
 
    /* Update the pg_class entry. */
    StorePartitionBound(attachrel, rel, bound);
 
    /* Ensure there exists a correct set of indexes in the partition. */
    AttachPartitionEnsureIndexes(wqueue, rel, attachrel);
 
    /* and triggers */
    CloneRowTriggersToPartition(rel, attachrel);
 
    /*
     * Clone foreign key constraints.  Callee is responsible for setting up
     * for phase 3 constraint verification.
     */
    CloneForeignKeyConstraints(wqueue, rel, attachrel);
}

References AttachPartitionEnsureIndexes(), CloneForeignKeyConstraints(), CloneRowTriggersToPartition(), CreateInheritance(), and StorePartitionBound().

Referenced by ATExecAttachPartition(), ATExecMergePartitions(), and ATExecSplitPartition().

ATTypedTableRecursion()

static void ATTypedTableRecursion ( List **  wqueue, Relation  rel, AlterTableCmd *  cmd, LOCKMODE  lockmode, AlterTableUtilityContext *  context  )

static

Definition at line 6762 of file tablecmds.c.

{
    ListCell   *child;
    List       *children;
 
    Assert(rel->rd_rel->relkind == RELKIND_COMPOSITE_TYPE);
 
    children = find_typed_table_dependencies(rel->rd_rel->reltype,
                                             RelationGetRelationName(rel),
                                             cmd->behavior);
 
    foreach(child, children)
    {
        Oid         childrelid = lfirst_oid(child);
        Relation    childrel;
 
        childrel = relation_open(childrelid, lockmode);
        CheckTableNotInUse(childrel, "ALTER TABLE");
        ATPrepCmd(wqueue, childrel, cmd, true, true, lockmode, context);
        relation_close(childrel, NoLock);
    }
}

References Assert, ATPrepCmd(), AlterTableCmd::behavior, CheckTableNotInUse(), context, find_typed_table_dependencies(), lfirst_oid, NoLock, RelationData::rd_rel, relation_close(), relation_open(), and RelationGetRelationName.

Referenced by ATPrepAddColumn(), ATPrepAlterColumnType(), and ATPrepDropColumn().

BuildDescForRelation()

TupleDesc BuildDescForRelation

(

const List *

columns

)

Definition at line 1307 of file tablecmds.c.

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

References ACL_USAGE, aclcheck_error_type(), ACLCHECK_OK, TypeName::arrayBounds, attname, attnum, TupleConstr::check, ColumnDef::colname, ColumnDef::compression, TupleDescData::constr, CreateTemplateTupleDesc(), TupleConstr::defval, ereport, errcode(), errmsg(), ERROR, ColumnDef::generated, GetAttributeCompression(), GetAttributeStorage(), GetColumnDefCollation(), GetUserId(), TupleConstr::has_generated_stored, TupleConstr::has_not_null, ColumnDef::identity, ColumnDef::inhcount, ColumnDef::is_local, ColumnDef::is_not_null, lfirst, list_length(), TupleConstr::missing, TupleConstr::num_check, TupleConstr::num_defval, object_aclcheck(), palloc0(), PG_INT16_MAX, TypeName::setof, ColumnDef::storage, ColumnDef::storage_name, TupleDescAttr, TupleDescInitEntry(), TupleDescInitEntryCollation(), ColumnDef::typeName, and typenameTypeIdAndMod().

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

change_owner_fix_column_acls()

static void change_owner_fix_column_acls ( Oid  relationOid, Oid  oldOwnerId, Oid  newOwnerId  )

static

Definition at line 15223 of file tablecmds.c.

{
    Relation    attRelation;
    SysScanDesc scan;
    ScanKeyData key[1];
    HeapTuple   attributeTuple;
 
    attRelation = table_open(AttributeRelationId, RowExclusiveLock);
    ScanKeyInit(&key[0],
                Anum_pg_attribute_attrelid,
                BTEqualStrategyNumber, F_OIDEQ,
                ObjectIdGetDatum(relationOid));
    scan = systable_beginscan(attRelation, AttributeRelidNumIndexId,
                              true, NULL, 1, key);
    while (HeapTupleIsValid(attributeTuple = systable_getnext(scan)))
    {
        Form_pg_attribute att = (Form_pg_attribute) GETSTRUCT(attributeTuple);
        Datum       repl_val[Natts_pg_attribute];
        bool        repl_null[Natts_pg_attribute];
        bool        repl_repl[Natts_pg_attribute];
        Acl        *newAcl;
        Datum       aclDatum;
        bool        isNull;
        HeapTuple   newtuple;
 
        /* Ignore dropped columns */
        if (att->attisdropped)
            continue;
 
        aclDatum = heap_getattr(attributeTuple,
                                Anum_pg_attribute_attacl,
                                RelationGetDescr(attRelation),
                                &isNull);
        /* Null ACLs do not require changes */
        if (isNull)
            continue;
 
        memset(repl_null, false, sizeof(repl_null));
        memset(repl_repl, false, sizeof(repl_repl));
 
        newAcl = aclnewowner(DatumGetAclP(aclDatum),
                             oldOwnerId, newOwnerId);
        repl_repl[Anum_pg_attribute_attacl - 1] = true;
        repl_val[Anum_pg_attribute_attacl - 1] = PointerGetDatum(newAcl);
 
        newtuple = heap_modify_tuple(attributeTuple,
                                     RelationGetDescr(attRelation),
                                     repl_val, repl_null, repl_repl);
 
        CatalogTupleUpdate(attRelation, &newtuple->t_self, newtuple);
 
        heap_freetuple(newtuple);
    }
    systable_endscan(scan);
    table_close(attRelation, RowExclusiveLock);
}

References aclnewowner(), BTEqualStrategyNumber, CatalogTupleUpdate(), DatumGetAclP, GETSTRUCT, heap_freetuple(), heap_getattr(), heap_modify_tuple(), HeapTupleIsValid, sort-test::key, ObjectIdGetDatum(), PointerGetDatum(), RelationGetDescr, RowExclusiveLock, ScanKeyInit(), systable_beginscan(), systable_endscan(), systable_getnext(), HeapTupleData::t_self, table_close(), and table_open().

Referenced by ATExecChangeOwner().

change_owner_recurse_to_sequences()

static void change_owner_recurse_to_sequences ( Oid  relationOid, Oid  newOwnerId, LOCKMODE  lockmode  )

static

Definition at line 15288 of file tablecmds.c.

{
    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(relationOid));
    /* 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;
        }
 
        /* We don't need to close the sequence while we alter it. */
        ATExecChangeOwner(depForm->objid, newOwnerId, true, lockmode);
 
        /* Now we can close it.  Keep the lock till end of transaction. */
        relation_close(seqRel, NoLock);
    }
 
    systable_endscan(scan);
 
    relation_close(depRel, AccessShareLock);
}

References AccessShareLock, ATExecChangeOwner(), BTEqualStrategyNumber, DEPENDENCY_AUTO, DEPENDENCY_INTERNAL, GETSTRUCT, HeapTupleIsValid, sort-test::key, NoLock, ObjectIdGetDatum(), relation_close(), relation_open(), RelationGetForm, ScanKeyInit(), systable_beginscan(), systable_endscan(), systable_getnext(), and table_open().

Referenced by ATExecChangeOwner().

check_for_column_name_collision()

static bool check_for_column_name_collision ( Relation  rel, const char *  colname, bool  if_not_exists  )

static

Definition at line 7474 of file tablecmds.c.

{
    HeapTuple   attTuple;
    int         attnum;
 
    /*
     * this test is deliberately not attisdropped-aware, since if one tries to
     * add a column matching a dropped column name, it's gonna fail anyway.
     */
    attTuple = SearchSysCache2(ATTNAME,
                               ObjectIdGetDatum(RelationGetRelid(rel)),
                               PointerGetDatum(colname));
    if (!HeapTupleIsValid(attTuple))
        return true;
 
    attnum = ((Form_pg_attribute) GETSTRUCT(attTuple))->attnum;
    ReleaseSysCache(attTuple);
 
    /*
     * We throw a different error message for conflicts with system column
     * names, since they are normally not shown and the user might otherwise
     * be confused about the reason for the conflict.
     */
    if (attnum <= 0)
        ereport(ERROR,
                (errcode(ERRCODE_DUPLICATE_COLUMN),
                 errmsg("column name \"%s\" conflicts with a system column name",
                        colname)));
    else
    {
        if (if_not_exists)
        {
            ereport(NOTICE,
                    (errcode(ERRCODE_DUPLICATE_COLUMN),
                     errmsg("column \"%s\" of relation \"%s\" already exists, skipping",
                            colname, RelationGetRelationName(rel))));
            return false;
        }
 
        ereport(ERROR,
                (errcode(ERRCODE_DUPLICATE_COLUMN),
                 errmsg("column \"%s\" of relation \"%s\" already exists",
                        colname, RelationGetRelationName(rel))));
    }
 
    return true;
}

References attnum, ereport, errcode(), errmsg(), ERROR, GETSTRUCT, HeapTupleIsValid, NOTICE, ObjectIdGetDatum(), PointerGetDatum(), RelationGetRelationName, RelationGetRelid, ReleaseSysCache(), and SearchSysCache2().

Referenced by ATExecAddColumn(), and renameatt_internal().

check_of_type()

void check_of_type

(

HeapTuple

typetuple

)

Definition at line 7014 of file tablecmds.c.

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

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

Referenced by ATExecAddOf(), and transformOfType().

checkFkeyPermissions()

static void checkFkeyPermissions ( Relation  rel, int16 *  attnums, int  natts  )

static

Definition at line 12524 of file tablecmds.c.

{
    Oid         roleid = GetUserId();
    AclResult   aclresult;
    int         i;
 
    /* Okay if we have relation-level REFERENCES permission */
    aclresult = pg_class_aclcheck(RelationGetRelid(rel), roleid,
                                  ACL_REFERENCES);
    if (aclresult == ACLCHECK_OK)
        return;
    /* Else we must have REFERENCES on each column */
    for (i = 0; i < natts; i++)
    {
        aclresult = pg_attribute_aclcheck(RelationGetRelid(rel), attnums[i],
                                          roleid, ACL_REFERENCES);
        if (aclresult != ACLCHECK_OK)
            aclcheck_error(aclresult, get_relkind_objtype(rel->rd_rel->relkind),
                           RelationGetRelationName(rel));
    }
}

References ACL_REFERENCES, aclcheck_error(), ACLCHECK_OK, get_relkind_objtype(), GetUserId(), i, pg_attribute_aclcheck(), pg_class_aclcheck(), RelationData::rd_rel, RelationGetRelationName, and RelationGetRelid.

Referenced by ATAddForeignKeyConstraint().

CheckRelationTableSpaceMove()

bool CheckRelationTableSpaceMove	(	Relation	rel,
		Oid	newTableSpaceId
	)

Definition at line 3629 of file tablecmds.c.

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

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

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

CheckTableNotInUse()

void CheckTableNotInUse	(	Relation	rel,
		const char *	stmt
	)

Definition at line 4346 of file tablecmds.c.

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

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

Referenced by addFkRecurseReferencing(), AlterTable(), ATAddCheckNNConstraint(), ATCheckPartitionsNotInUse(), ATExecAddColumn(), ATExecDropColumn(), ATPrepAlterColumnType(), ATSimpleRecursion(), ATTypedTableRecursion(), cluster_rel(), DefineIndex(), DefineVirtualRelation(), dropconstraint_internal(), ExecRefreshMatView(), heap_drop_with_catalog(), index_drop(), MergeAttributes(), reindex_index(), set_attnotnull(), and truncate_check_activity().

ChooseForeignKeyConstraintNameAddition()

static char * ChooseForeignKeyConstraintNameAddition ( List *  colnames )

static

Definition at line 9686 of file tablecmds.c.

{
    char        buf[NAMEDATALEN * 2];
    int         buflen = 0;
    ListCell   *lc;
 
    buf[0] = '\0';
    foreach(lc, colnames)
    {
        const char *name = strVal(lfirst(lc));
 
        if (buflen > 0)
            buf[buflen++] = '_';    /* insert _ between names */
 
        /*
         * At this point we have buflen <= NAMEDATALEN.  name should be less
         * than NAMEDATALEN already, but use strlcpy for paranoia.
         */
        strlcpy(buf + buflen, name, NAMEDATALEN);
        buflen += strlen(buf + buflen);
        if (buflen >= NAMEDATALEN)
            break;
    }
    return pstrdup(buf);
}

References buf, lfirst, name, NAMEDATALEN, pstrdup(), strlcpy(), and strVal.

Referenced by addFkRecurseReferenced(), addFkRecurseReferencing(), ATExecAddConstraint(), and CloneFkReferencing().

CloneFkReferenced()

static void CloneFkReferenced ( Relation  parentRel, Relation  partitionRel  )

static

Definition at line 10964 of file tablecmds.c.

{
    Relation    pg_constraint;
    AttrMap    *attmap;
    ListCell   *cell;
    SysScanDesc scan;
    ScanKeyData key[2];
    HeapTuple   tuple;
    List       *clone = NIL;
    Relation    trigrel;
 
    /*
     * Search for any constraints where this partition's parent is in the
     * referenced side.  However, we must not clone any constraint whose
     * parent constraint is also going to be cloned, to avoid duplicates.  So
     * do it in two steps: first construct the list of constraints to clone,
     * then go over that list cloning those whose parents are not in the list.
     * (We must not rely on the parent being seen first, since the catalog
     * scan could return children first.)
     */
    pg_constraint = table_open(ConstraintRelationId, RowShareLock);
    ScanKeyInit(&key[0],
                Anum_pg_constraint_confrelid, BTEqualStrategyNumber,
                F_OIDEQ, ObjectIdGetDatum(RelationGetRelid(parentRel)));
    ScanKeyInit(&key[1],
                Anum_pg_constraint_contype, BTEqualStrategyNumber,
                F_CHAREQ, CharGetDatum(CONSTRAINT_FOREIGN));
    /* This is a seqscan, as we don't have a usable index ... */
    scan = systable_beginscan(pg_constraint, InvalidOid, true,
                              NULL, 2, key);
    while ((tuple = systable_getnext(scan)) != NULL)
    {
        Form_pg_constraint constrForm = (Form_pg_constraint) GETSTRUCT(tuple);
 
        clone = lappend_oid(clone, constrForm->oid);
    }
    systable_endscan(scan);
    table_close(pg_constraint, RowShareLock);
 
    /*
     * Triggers of the foreign keys will be manipulated a bunch of times in
     * the loop below.  To avoid repeatedly opening/closing the trigger
     * catalog relation, we open it here and pass it to the subroutines called
     * below.
     */
    trigrel = table_open(TriggerRelationId, RowExclusiveLock);
 
    attmap = build_attrmap_by_name(RelationGetDescr(partitionRel),
                                   RelationGetDescr(parentRel),
                                   false);
    foreach(cell, clone)
    {
        Oid         constrOid = lfirst_oid(cell);
        Form_pg_constraint constrForm;
        Relation    fkRel;
        Oid         indexOid;
        Oid         partIndexId;
        int         numfks;
        AttrNumber  conkey[INDEX_MAX_KEYS];
        AttrNumber  mapped_confkey[INDEX_MAX_KEYS];
        AttrNumber  confkey[INDEX_MAX_KEYS];
        Oid         conpfeqop[INDEX_MAX_KEYS];
        Oid         conppeqop[INDEX_MAX_KEYS];
        Oid         conffeqop[INDEX_MAX_KEYS];
        int         numfkdelsetcols;
        AttrNumber  confdelsetcols[INDEX_MAX_KEYS];
        Constraint *fkconstraint;
        Oid         deleteTriggerOid,
                    updateTriggerOid;
 
        tuple = SearchSysCache1(CONSTROID, ObjectIdGetDatum(constrOid));
        if (!HeapTupleIsValid(tuple))
            elog(ERROR, "cache lookup failed for constraint %u", constrOid);
        constrForm = (Form_pg_constraint) GETSTRUCT(tuple);
 
        /*
         * As explained above: don't try to clone a constraint for which we're
         * going to clone the parent.
         */
        if (list_member_oid(clone, constrForm->conparentid))
        {
            ReleaseSysCache(tuple);
            continue;
        }
 
        /*
         * Don't clone self-referencing foreign keys, which can be in the
         * partitioned table or in the partition-to-be.
         */
        if (constrForm->conrelid == RelationGetRelid(parentRel) ||
            constrForm->conrelid == RelationGetRelid(partitionRel))
        {
            ReleaseSysCache(tuple);
            continue;
        }
 
        /*
         * Because we're only expanding the key space at the referenced side,
         * we don't need to prevent any operation in the referencing table, so
         * AccessShareLock suffices (assumes that dropping the constraint
         * acquires AEL).
         */
        fkRel = table_open(constrForm->conrelid, AccessShareLock);
 
        indexOid = constrForm->conindid;
        DeconstructFkConstraintRow(tuple,
                                   &numfks,
                                   conkey,
                                   confkey,
                                   conpfeqop,
                                   conppeqop,
                                   conffeqop,
                                   &numfkdelsetcols,
                                   confdelsetcols);
 
        for (int i = 0; i < numfks; i++)
            mapped_confkey[i] = attmap->attnums[confkey[i] - 1];
 
        fkconstraint = makeNode(Constraint);
        fkconstraint->contype = CONSTRAINT_FOREIGN;
        fkconstraint->conname = NameStr(constrForm->conname);
        fkconstraint->deferrable = constrForm->condeferrable;
        fkconstraint->initdeferred = constrForm->condeferred;
        fkconstraint->location = -1;
        fkconstraint->pktable = NULL;
        /* ->fk_attrs determined below */
        fkconstraint->pk_attrs = NIL;
        fkconstraint->fk_matchtype = constrForm->confmatchtype;
        fkconstraint->fk_upd_action = constrForm->confupdtype;
        fkconstraint->fk_del_action = constrForm->confdeltype;
        fkconstraint->fk_del_set_cols = NIL;
        fkconstraint->old_conpfeqop = NIL;
        fkconstraint->old_pktable_oid = InvalidOid;
        fkconstraint->skip_validation = false;
        fkconstraint->initially_valid = true;
 
        /* set up colnames that are used to generate the constraint name */
        for (int i = 0; i < numfks; i++)
        {
            Form_pg_attribute att;
 
            att = TupleDescAttr(RelationGetDescr(fkRel),
                                conkey[i] - 1);
            fkconstraint->fk_attrs = lappend(fkconstraint->fk_attrs,
                                             makeString(NameStr(att->attname)));
        }
 
        /*
         * Add the new foreign key constraint pointing to the new partition.
         * Because this new partition appears in the referenced side of the
         * constraint, we don't need to set up for Phase 3 check.
         */
        partIndexId = index_get_partition(partitionRel, indexOid);
        if (!OidIsValid(partIndexId))
            elog(ERROR, "index for %u not found in partition %s",
                 indexOid, RelationGetRelationName(partitionRel));
 
        /*
         * Get the "action" triggers belonging to the constraint to pass as
         * parent OIDs for similar triggers that will be created on the
         * partition in addFkRecurseReferenced().
         */
        GetForeignKeyActionTriggers(trigrel, constrOid,
                                    constrForm->confrelid, constrForm->conrelid,
                                    &deleteTriggerOid, &updateTriggerOid);
 
        addFkRecurseReferenced(NULL,
                               fkconstraint,
                               fkRel,
                               partitionRel,
                               partIndexId,
                               constrOid,
                               numfks,
                               mapped_confkey,
                               conkey,
                               conpfeqop,
                               conppeqop,
                               conffeqop,
                               numfkdelsetcols,
                               confdelsetcols,
                               true,
                               deleteTriggerOid,
                               updateTriggerOid,
                               constrForm->conperiod);
 
        table_close(fkRel, NoLock);
        ReleaseSysCache(tuple);
    }
 
    table_close(trigrel, RowExclusiveLock);
}

References AccessShareLock, addFkRecurseReferenced(), AttrMap::attnums, BTEqualStrategyNumber, build_attrmap_by_name(), CharGetDatum(), Constraint::conname, Constraint::contype, DeconstructFkConstraintRow(), Constraint::deferrable, elog, ERROR, Constraint::fk_attrs, Constraint::fk_del_action, Constraint::fk_del_set_cols, Constraint::fk_matchtype, Constraint::fk_upd_action, GetForeignKeyActionTriggers(), GETSTRUCT, HeapTupleIsValid, i, index_get_partition(), INDEX_MAX_KEYS, Constraint::initdeferred, Constraint::initially_valid, InvalidOid, sort-test::key, lappend(), lappend_oid(), lfirst_oid, list_member_oid(), Constraint::location, makeNode, makeString(), NameStr, NIL, NoLock, ObjectIdGetDatum(), OidIsValid, Constraint::old_conpfeqop, Constraint::old_pktable_oid, Constraint::pk_attrs, Constraint::pktable, RelationGetDescr, RelationGetRelationName, RelationGetRelid, ReleaseSysCache(), RowExclusiveLock, RowShareLock, ScanKeyInit(), SearchSysCache1(), Constraint::skip_validation, systable_beginscan(), systable_endscan(), systable_getnext(), table_close(), table_open(), and TupleDescAttr.

Referenced by CloneForeignKeyConstraints().

CloneFkReferencing()

static void CloneFkReferencing ( List **  wqueue, Relation  parentRel, Relation  partRel  )

static

Definition at line 11170 of file tablecmds.c.

{
    AttrMap    *attmap;
    List       *partFKs;
    List       *clone = NIL;
    ListCell   *cell;
    Relation    trigrel;
 
    /* obtain a list of constraints that we need to clone */
    foreach(cell, RelationGetFKeyList(parentRel))
    {
        ForeignKeyCacheInfo *fk = lfirst(cell);
 
        clone = lappend_oid(clone, fk->conoid);
    }
 
    /*
     * Silently do nothing if there's nothing to do.  In particular, this
     * avoids throwing a spurious error for foreign tables.
     */
    if (clone == NIL)
        return;
 
    if (partRel->rd_rel->relkind == RELKIND_FOREIGN_TABLE)
        ereport(ERROR,
                (errcode(ERRCODE_WRONG_OBJECT_TYPE),
                 errmsg("foreign key constraints are not supported on foreign tables")));
 
    /*
     * Triggers of the foreign keys will be manipulated a bunch of times in
     * the loop below.  To avoid repeatedly opening/closing the trigger
     * catalog relation, we open it here and pass it to the subroutines called
     * below.
     */
    trigrel = table_open(TriggerRelationId, RowExclusiveLock);
 
    /*
     * The constraint key may differ, if the columns in the partition are
     * different.  This map is used to convert them.
     */
    attmap = build_attrmap_by_name(RelationGetDescr(partRel),
                                   RelationGetDescr(parentRel),
                                   false);
 
    partFKs = copyObject(RelationGetFKeyList(partRel));
 
    foreach(cell, clone)
    {
        Oid         parentConstrOid = lfirst_oid(cell);
        Form_pg_constraint constrForm;
        Relation    pkrel;
        HeapTuple   tuple;
        int         numfks;
        AttrNumber  conkey[INDEX_MAX_KEYS];
        AttrNumber  mapped_conkey[INDEX_MAX_KEYS];
        AttrNumber  confkey[INDEX_MAX_KEYS];
        Oid         conpfeqop[INDEX_MAX_KEYS];
        Oid         conppeqop[INDEX_MAX_KEYS];
        Oid         conffeqop[INDEX_MAX_KEYS];
        int         numfkdelsetcols;
        AttrNumber  confdelsetcols[INDEX_MAX_KEYS];
        Constraint *fkconstraint;
        bool        attached;
        Oid         indexOid;
        Oid         constrOid;
        ObjectAddress address,
                    referenced;
        ListCell   *lc;
        Oid         insertTriggerOid,
                    updateTriggerOid;
        bool        with_period;
 
        tuple = SearchSysCache1(CONSTROID, ObjectIdGetDatum(parentConstrOid));
        if (!HeapTupleIsValid(tuple))
            elog(ERROR, "cache lookup failed for constraint %u",
                 parentConstrOid);
        constrForm = (Form_pg_constraint) GETSTRUCT(tuple);
 
        /* Don't clone constraints whose parents are being cloned */
        if (list_member_oid(clone, constrForm->conparentid))
        {
            ReleaseSysCache(tuple);
            continue;
        }
 
        /*
         * Need to prevent concurrent deletions.  If pkrel is a partitioned
         * relation, that means to lock all partitions.
         */
        pkrel = table_open(constrForm->confrelid, ShareRowExclusiveLock);
        if (pkrel->rd_rel->relkind == RELKIND_PARTITIONED_TABLE)
            (void) find_all_inheritors(RelationGetRelid(pkrel),
                                       ShareRowExclusiveLock, NULL);
 
        DeconstructFkConstraintRow(tuple, &numfks, conkey, confkey,
                                   conpfeqop, conppeqop, conffeqop,
                                   &numfkdelsetcols, confdelsetcols);
        for (int i = 0; i < numfks; i++)
            mapped_conkey[i] = attmap->attnums[conkey[i] - 1];
 
        /*
         * Get the "check" triggers belonging to the constraint to pass as
         * parent OIDs for similar triggers that will be created on the
         * partition in addFkRecurseReferencing().  They are also passed to
         * tryAttachPartitionForeignKey() below to simply assign as parents to
         * the partition's existing "check" triggers, that is, if the
         * corresponding constraints is deemed attachable to the parent
         * constraint.
         */
        GetForeignKeyCheckTriggers(trigrel, constrForm->oid,
                                   constrForm->confrelid, constrForm->conrelid,
                                   &insertTriggerOid, &updateTriggerOid);
 
        /*
         * Before creating a new constraint, see whether any existing FKs are
         * fit for the purpose.  If one is, attach the parent constraint to
         * it, and don't clone anything.  This way we avoid the expensive
         * verification step and don't end up with a duplicate FK, and we
         * don't need to recurse to partitions for this constraint.
         */
        attached = false;
        foreach(lc, partFKs)
        {
            ForeignKeyCacheInfo *fk = lfirst_node(ForeignKeyCacheInfo, lc);
 
            if (tryAttachPartitionForeignKey(fk,
                                             RelationGetRelid(partRel),
                                             parentConstrOid,
                                             numfks,
                                             mapped_conkey,
                                             confkey,
                                             conpfeqop,
                                             insertTriggerOid,
                                             updateTriggerOid,
                                             trigrel))
            {
                attached = true;
                table_close(pkrel, NoLock);
                break;
            }
        }
        if (attached)
        {
            ReleaseSysCache(tuple);
            continue;
        }
 
        /* No dice.  Set up to create our own constraint */
        fkconstraint = makeNode(Constraint);
        fkconstraint->contype = CONSTRAINT_FOREIGN;
        /* ->conname determined below */
        fkconstraint->deferrable = constrForm->condeferrable;
        fkconstraint->initdeferred = constrForm->condeferred;
        fkconstraint->location = -1;
        fkconstraint->pktable = NULL;
        /* ->fk_attrs determined below */
        fkconstraint->pk_attrs = NIL;
        fkconstraint->fk_matchtype = constrForm->confmatchtype;
        fkconstraint->fk_upd_action = constrForm->confupdtype;
        fkconstraint->fk_del_action = constrForm->confdeltype;
        fkconstraint->fk_del_set_cols = NIL;
        fkconstraint->old_conpfeqop = NIL;
        fkconstraint->old_pktable_oid = InvalidOid;
        fkconstraint->skip_validation = false;
        fkconstraint->initially_valid = true;
        for (int i = 0; i < numfks; i++)
        {
            Form_pg_attribute att;
 
            att = TupleDescAttr(RelationGetDescr(partRel),
                                mapped_conkey[i] - 1);
            fkconstraint->fk_attrs = lappend(fkconstraint->fk_attrs,
                                             makeString(NameStr(att->attname)));
        }
        if (ConstraintNameIsUsed(CONSTRAINT_RELATION,
                                 RelationGetRelid(partRel),
                                 NameStr(constrForm->conname)))
            fkconstraint->conname =
                ChooseConstraintName(RelationGetRelationName(partRel),
                                     ChooseForeignKeyConstraintNameAddition(fkconstraint->fk_attrs),
                                     "fkey",
                                     RelationGetNamespace(partRel), NIL);
        else
            fkconstraint->conname = pstrdup(NameStr(constrForm->conname));
 
        indexOid = constrForm->conindid;
        with_period = constrForm->conperiod;
        constrOid =
            CreateConstraintEntry(fkconstraint->conname,
                                  constrForm->connamespace,
                                  CONSTRAINT_FOREIGN,
                                  fkconstraint->deferrable,
                                  fkconstraint->initdeferred,
                                  constrForm->convalidated,
                                  parentConstrOid,
                                  RelationGetRelid(partRel),
                                  mapped_conkey,
                                  numfks,
                                  numfks,
                                  InvalidOid,   /* not a domain constraint */
                                  indexOid,
                                  constrForm->confrelid,    /* same foreign rel */
                                  confkey,
                                  conpfeqop,
                                  conppeqop,
                                  conffeqop,
                                  numfks,
                                  fkconstraint->fk_upd_action,
                                  fkconstraint->fk_del_action,
                                  confdelsetcols,
                                  numfkdelsetcols,
                                  fkconstraint->fk_matchtype,
                                  NULL,
                                  NULL,
                                  NULL,
                                  false,    /* islocal */
                                  1,    /* inhcount */
                                  false,    /* conNoInherit */
                                  with_period,  /* conPeriod */
                                  true);
 
        /* Set up partition dependencies for the new constraint */
        ObjectAddressSet(address, ConstraintRelationId, constrOid);
        ObjectAddressSet(referenced, ConstraintRelationId, parentConstrOid);
        recordDependencyOn(&address, &referenced, DEPENDENCY_PARTITION_PRI);
        ObjectAddressSet(referenced, RelationRelationId,
                         RelationGetRelid(partRel));
        recordDependencyOn(&address, &referenced, DEPENDENCY_PARTITION_SEC);
 
        /* Done with the cloned constraint's tuple */
        ReleaseSysCache(tuple);
 
        /* Make all this visible before recursing */
        CommandCounterIncrement();
 
        addFkRecurseReferencing(wqueue,
                                fkconstraint,
                                partRel,
                                pkrel,
                                indexOid,
                                constrOid,
                                numfks,
                                confkey,
                                mapped_conkey,
                                conpfeqop,
                                conppeqop,
                                conffeqop,
                                numfkdelsetcols,
                                confdelsetcols,
                                false,  /* no old check exists */
                                AccessExclusiveLock,
                                insertTriggerOid,
                                updateTriggerOid,
                                with_period);
        table_close(pkrel, NoLock);
    }
 
    table_close(trigrel, RowExclusiveLock);
}

References AccessExclusiveLock, addFkRecurseReferencing(), AttrMap::attnums, build_attrmap_by_name(), ChooseConstraintName(), ChooseForeignKeyConstraintNameAddition(), CommandCounterIncrement(), Constraint::conname, ForeignKeyCacheInfo::conoid, CONSTRAINT_RELATION, ConstraintNameIsUsed(), Constraint::contype, copyObject, CreateConstraintEntry(), DeconstructFkConstraintRow(), Constraint::deferrable, DEPENDENCY_PARTITION_PRI, DEPENDENCY_PARTITION_SEC, elog, ereport, errcode(), errmsg(), ERROR, find_all_inheritors(), Constraint::fk_attrs, Constraint::fk_del_action, Constraint::fk_del_set_cols, Constraint::fk_matchtype, Constraint::fk_upd_action, GetForeignKeyCheckTriggers(), GETSTRUCT, HeapTupleIsValid, i, INDEX_MAX_KEYS, Constraint::initdeferred, Constraint::initially_valid, InvalidOid, lappend(), lappend_oid(), lfirst, lfirst_node, lfirst_oid, list_member_oid(), Constraint::location, makeNode, makeString(), NameStr, NIL, NoLock, ObjectAddressSet, ObjectIdGetDatum(), Constraint::old_conpfeqop, Constraint::old_pktable_oid, Constraint::pk_attrs, Constraint::pktable, pstrdup(), RelationData::rd_rel, recordDependencyOn(), RelationGetDescr, RelationGetFKeyList(), RelationGetNamespace, RelationGetRelationName, RelationGetRelid, ReleaseSysCache(), RowExclusiveLock, SearchSysCache1(), ShareRowExclusiveLock, Constraint::skip_validation, table_close(), table_open(), tryAttachPartitionForeignKey(), and TupleDescAttr.

Referenced by CloneForeignKeyConstraints().

CloneForeignKeyConstraints()

static void CloneForeignKeyConstraints ( List **  wqueue, Relation  parentRel, Relation  partitionRel  )

static

Definition at line 10933 of file tablecmds.c.

{
    /* This only works for declarative partitioning */
    Assert(parentRel->rd_rel->relkind == RELKIND_PARTITIONED_TABLE);
 
    /*
     * Clone constraints for which the parent is on the referenced side.
     */
    CloneFkReferenced(parentRel, partitionRel);
 
    /*
     * Now clone constraints where the parent is on the referencing side.
     */
    CloneFkReferencing(wqueue, parentRel, partitionRel);
}

References Assert, CloneFkReferenced(), CloneFkReferencing(), and RelationData::rd_rel.

Referenced by attachPartitionTable(), and DefineRelation().

CloneRowTriggersToPartition()

static void CloneRowTriggersToPartition ( Relation  parent, Relation  partition  )

static

Definition at line 19682 of file tablecmds.c.

{
    Relation    pg_trigger;
    ScanKeyData key;
    SysScanDesc scan;
    HeapTuple   tuple;
    MemoryContext perTupCxt;
 
    ScanKeyInit(&key, Anum_pg_trigger_tgrelid, BTEqualStrategyNumber,
                F_OIDEQ, ObjectIdGetDatum(RelationGetRelid(parent)));
    pg_trigger = table_open(TriggerRelationId, RowExclusiveLock);
    scan = systable_beginscan(pg_trigger, TriggerRelidNameIndexId,
                              true, NULL, 1, &key);
 
    perTupCxt = AllocSetContextCreate(CurrentMemoryContext,
                                      "clone trig", ALLOCSET_SMALL_SIZES);
 
    while (HeapTupleIsValid(tuple = systable_getnext(scan)))
    {
        Form_pg_trigger trigForm = (Form_pg_trigger) GETSTRUCT(tuple);
        CreateTrigStmt *trigStmt;
        Node       *qual = NULL;
        Datum       value;
        bool        isnull;
        List       *cols = NIL;
        List       *trigargs = NIL;
        MemoryContext oldcxt;
 
        /*
         * Ignore statement-level triggers; those are not cloned.
         */
        if (!TRIGGER_FOR_ROW(trigForm->tgtype))
            continue;
 
        /*
         * Don't clone internal triggers, because the constraint cloning code
         * will.
         */
        if (trigForm->tgisinternal)
            continue;
 
        /*
         * Complain if we find an unexpected trigger type.
         */
        if (!TRIGGER_FOR_BEFORE(trigForm->tgtype) &&
            !TRIGGER_FOR_AFTER(trigForm->tgtype))
            elog(ERROR, "unexpected trigger \"%s\" found",
                 NameStr(trigForm->tgname));
 
        /* Use short-lived context for CREATE TRIGGER */
        oldcxt = MemoryContextSwitchTo(perTupCxt);
 
        /*
         * If there is a WHEN clause, generate a 'cooked' version of it that's
         * appropriate for the partition.
         */
        value = heap_getattr(tuple, Anum_pg_trigger_tgqual,
                             RelationGetDescr(pg_trigger), &isnull);
        if (!isnull)
        {
            qual = stringToNode(TextDatumGetCString(value));
            qual = (Node *) map_partition_varattnos((List *) qual, PRS2_OLD_VARNO,
                                                    partition, parent);
            qual = (Node *) map_partition_varattnos((List *) qual, PRS2_NEW_VARNO,
                                                    partition, parent);
        }
 
        /*
         * If there is a column list, transform it to a list of column names.
         * Note we don't need to map this list in any way ...
         */
        if (trigForm->tgattr.dim1 > 0)
        {
            int         i;
 
            for (i = 0; i < trigForm->tgattr.dim1; i++)
            {
                Form_pg_attribute col;
 
                col = TupleDescAttr(parent->rd_att,
                                    trigForm->tgattr.values[i] - 1);
                cols = lappend(cols,
                               makeString(pstrdup(NameStr(col->attname))));
            }
        }
 
        /* Reconstruct trigger arguments list. */
        if (trigForm->tgnargs > 0)
        {
            char       *p;
 
            value = heap_getattr(tuple, Anum_pg_trigger_tgargs,
                                 RelationGetDescr(pg_trigger), &isnull);
            if (isnull)
                elog(ERROR, "tgargs is null for trigger \"%s\" in partition \"%s\"",
                     NameStr(trigForm->tgname), RelationGetRelationName(partition));
 
            p = (char *) VARDATA_ANY(DatumGetByteaPP(value));
 
            for (int i = 0; i < trigForm->tgnargs; i++)
            {
                trigargs = lappend(trigargs, makeString(pstrdup(p)));
                p += strlen(p) + 1;
            }
        }
 
        trigStmt = makeNode(CreateTrigStmt);
        trigStmt->replace = false;
        trigStmt->isconstraint = OidIsValid(trigForm->tgconstraint);
        trigStmt->trigname = NameStr(trigForm->tgname);
        trigStmt->relation = NULL;
        trigStmt->funcname = NULL;  /* passed separately */
        trigStmt->args = trigargs;
        trigStmt->row = true;
        trigStmt->timing = trigForm->tgtype & TRIGGER_TYPE_TIMING_MASK;
        trigStmt->events = trigForm->tgtype & TRIGGER_TYPE_EVENT_MASK;
        trigStmt->columns = cols;
        trigStmt->whenClause = NULL;    /* passed separately */
        trigStmt->transitionRels = NIL; /* not supported at present */
        trigStmt->deferrable = trigForm->tgdeferrable;
        trigStmt->initdeferred = trigForm->tginitdeferred;
        trigStmt->constrrel = NULL; /* passed separately */
 
        CreateTriggerFiringOn(trigStmt, NULL, RelationGetRelid(partition),
                              trigForm->tgconstrrelid, InvalidOid, InvalidOid,
                              trigForm->tgfoid, trigForm->oid, qual,
                              false, true, trigForm->tgenabled);
 
        MemoryContextSwitchTo(oldcxt);
        MemoryContextReset(perTupCxt);
    }
 
    MemoryContextDelete(perTupCxt);
 
    systable_endscan(scan);
    table_close(pg_trigger, RowExclusiveLock);
}

References ALLOCSET_SMALL_SIZES, AllocSetContextCreate, CreateTrigStmt::args, BTEqualStrategyNumber, CreateTrigStmt::columns, CreateTrigStmt::constrrel, CreateTriggerFiringOn(), CurrentMemoryContext, DatumGetByteaPP, CreateTrigStmt::deferrable, elog, ERROR, CreateTrigStmt::events, CreateTrigStmt::funcname, GETSTRUCT, heap_getattr(), HeapTupleIsValid, i, CreateTrigStmt::initdeferred, InvalidOid, CreateTrigStmt::isconstraint, sort-test::key, lappend(), makeNode, makeString(), map_partition_varattnos(), MemoryContextDelete(), MemoryContextReset(), MemoryContextSwitchTo(), NameStr, NIL, ObjectIdGetDatum(), OidIsValid, PRS2_NEW_VARNO, PRS2_OLD_VARNO, pstrdup(), RelationData::rd_att, CreateTrigStmt::relation, RelationGetDescr, RelationGetRelationName, RelationGetRelid, CreateTrigStmt::replace, CreateTrigStmt::row, RowExclusiveLock, ScanKeyInit(), stringToNode(), systable_beginscan(), systable_endscan(), systable_getnext(), table_close(), table_open(), TextDatumGetCString, CreateTrigStmt::timing, CreateTrigStmt::transitionRels, CreateTrigStmt::trigname, TupleDescAttr, value, VARDATA_ANY, and CreateTrigStmt::whenClause.

Referenced by attachPartitionTable(), and DefineRelation().

ComputePartitionAttrs()

static void ComputePartitionAttrs ( ParseState *  pstate, Relation  rel, List *  partParams, AttrNumber *  partattrs, List **  partexprs, Oid *  partopclass, Oid *  partcollation, PartitionStrategy  strategy  )

static

Definition at line 18705 of file tablecmds.c.

{
    int         attn;
    ListCell   *lc;
    Oid         am_oid;
 
    attn = 0;
    foreach(lc, partParams)
    {
        PartitionElem *pelem = lfirst_node(PartitionElem, lc);
        Oid         atttype;
        Oid         attcollation;
 
        if (pelem->name != NULL)
        {
            /* Simple attribute reference */
            HeapTuple   atttuple;
            Form_pg_attribute attform;
 
            atttuple = SearchSysCacheAttName(RelationGetRelid(rel),
                                             pelem->name);
            if (!HeapTupleIsValid(atttuple))
                ereport(ERROR,
                        (errcode(ERRCODE_UNDEFINED_COLUMN),
                         errmsg("column \"%s\" named in partition key does not exist",
                                pelem->name),
                         parser_errposition(pstate, pelem->location)));
            attform = (Form_pg_attribute) GETSTRUCT(atttuple);
 
            if (attform->attnum <= 0)
                ereport(ERROR,
                        (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
                         errmsg("cannot use system column \"%s\" in partition key",
                                pelem->name),
                         parser_errposition(pstate, pelem->location)));
 
            /*
             * Generated columns cannot work: They are computed after BEFORE
             * triggers, but partition routing is done before all triggers.
             */
            if (attform->attgenerated)
                ereport(ERROR,
                        (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
                         errmsg("cannot use generated column in partition key"),
                         errdetail("Column \"%s\" is a generated column.",
                                   pelem->name),
                         parser_errposition(pstate, pelem->location)));
 
            partattrs[attn] = attform->attnum;
            atttype = attform->atttypid;
            attcollation = attform->attcollation;
            ReleaseSysCache(atttuple);
        }
        else
        {
            /* Expression */
            Node       *expr = pelem->expr;
            char        partattname[16];
 
            Assert(expr != NULL);
            atttype = exprType(expr);
            attcollation = exprCollation(expr);
 
            /*
             * The expression must be of a storable type (e.g., not RECORD).
             * The test is the same as for whether a table column is of a safe
             * type (which is why we needn't check for the non-expression
             * case).
             */
            snprintf(partattname, sizeof(partattname), "%d", attn + 1);
            CheckAttributeType(partattname,
                               atttype, attcollation,
                               NIL, CHKATYPE_IS_PARTKEY);
 
            /*
             * Strip any top-level COLLATE clause.  This ensures that we treat
             * "x COLLATE y" and "(x COLLATE y)" alike.
             */
            while (IsA(expr, CollateExpr))
                expr = (Node *) ((CollateExpr *) expr)->arg;
 
            if (IsA(expr, Var) &&
                ((Var *) expr)->varattno > 0)
            {
                /*
                 * User wrote "(column)" or "(column COLLATE something)".
                 * Treat it like simple attribute anyway.
                 */
                partattrs[attn] = ((Var *) expr)->varattno;
            }
            else
            {
                Bitmapset  *expr_attrs = NULL;
                int         i;
 
                partattrs[attn] = 0;    /* marks the column as expression */
                *partexprs = lappend(*partexprs, expr);
 
                /*
                 * transformPartitionSpec() should have already rejected
                 * subqueries, aggregates, window functions, and SRFs, based
                 * on the EXPR_KIND_ for partition expressions.
                 */
 
                /*
                 * Cannot allow system column references, since that would
                 * make partition routing impossible: their values won't be
                 * known yet when we need to do that.
                 */
                pull_varattnos(expr, 1, &expr_attrs);
                for (i = FirstLowInvalidHeapAttributeNumber; i < 0; i++)
                {
                    if (bms_is_member(i - FirstLowInvalidHeapAttributeNumber,
                                      expr_attrs))
                        ereport(ERROR,
                                (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
                                 errmsg("partition key expressions cannot contain system column references")));
                }
 
                /*
                 * Generated columns cannot work: They are computed after
                 * BEFORE triggers, but partition routing is done before all
                 * triggers.
                 */
                i = -1;
                while ((i = bms_next_member(expr_attrs, i)) >= 0)
                {
                    AttrNumber  attno = i + FirstLowInvalidHeapAttributeNumber;
 
                    if (attno > 0 &&
                        TupleDescAttr(RelationGetDescr(rel), attno - 1)->attgenerated)
                        ereport(ERROR,
                                (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
                                 errmsg("cannot use generated column in partition key"),
                                 errdetail("Column \"%s\" is a generated column.",
                                           get_attname(RelationGetRelid(rel), attno, false)),
                                 parser_errposition(pstate, pelem->location)));
                }
 
                /*
                 * Preprocess the expression before checking for mutability.
                 * This is essential for the reasons described in
                 * contain_mutable_functions_after_planning.  However, we call
                 * expression_planner for ourselves rather than using that
                 * function, because if constant-folding reduces the
                 * expression to a constant, we'd like to know that so we can
                 * complain below.
                 *
                 * Like contain_mutable_functions_after_planning, assume that
                 * expression_planner won't scribble on its input, so this
                 * won't affect the partexprs entry we saved above.
                 */
                expr = (Node *) expression_planner((Expr *) expr);
 
                /*
                 * Partition expressions cannot contain mutable functions,
                 * because a given row must always map to the same partition
                 * as long as there is no change in the partition boundary
                 * structure.
                 */
                if (contain_mutable_functions(expr))
                    ereport(ERROR,
                            (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
                             errmsg("functions in partition key expression must be marked IMMUTABLE")));
 
                /*
                 * While it is not exactly *wrong* for a partition expression
                 * to be a constant, it seems better to reject such keys.
                 */
                if (IsA(expr, Const))
                    ereport(ERROR,
                            (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
                             errmsg("cannot use constant expression as partition key")));
            }
        }
 
        /*
         * Apply collation override if any
         */
        if (pelem->collation)
            attcollation = get_collation_oid(pelem->collation, false);
 
        /*
         * Check we have a collation iff it's a collatable type.  The only
         * expected failures here are (1) COLLATE applied to a noncollatable
         * type, or (2) partition expression had an unresolved collation. But
         * we might as well code this to be a complete consistency check.
         */
        if (type_is_collatable(atttype))
        {
            if (!OidIsValid(attcollation))
                ereport(ERROR,
                        (errcode(ERRCODE_INDETERMINATE_COLLATION),
                         errmsg("could not determine which collation to use for partition expression"),
                         errhint("Use the COLLATE clause to set the collation explicitly.")));
        }
        else
        {
            if (OidIsValid(attcollation))
                ereport(ERROR,
                        (errcode(ERRCODE_DATATYPE_MISMATCH),
                         errmsg("collations are not supported by type %s",
                                format_type_be(atttype))));
        }
 
        partcollation[attn] = attcollation;
 
        /*
         * Identify the appropriate operator class.  For list and range
         * partitioning, we use a btree operator class; hash partitioning uses
         * a hash operator class.
         */
        if (strategy == PARTITION_STRATEGY_HASH)
            am_oid = HASH_AM_OID;
        else
            am_oid = BTREE_AM_OID;
 
        if (!pelem->opclass)
        {
            partopclass[attn] = GetDefaultOpClass(atttype, am_oid);
 
            if (!OidIsValid(partopclass[attn]))
            {
                if (strategy == PARTITION_STRATEGY_HASH)
                    ereport(ERROR,
                            (errcode(ERRCODE_UNDEFINED_OBJECT),
                             errmsg("data type %s has no default operator class for access method \"%s\"",
                                    format_type_be(atttype), "hash"),
                             errhint("You must specify a hash operator class or define a default hash operator class for the data type.")));
                else
                    ereport(ERROR,
                            (errcode(ERRCODE_UNDEFINED_OBJECT),
                             errmsg("data type %s has no default operator class for access method \"%s\"",
                                    format_type_be(atttype), "btree"),
                             errhint("You must specify a btree operator class or define a default btree operator class for the data type.")));
            }
        }
        else
            partopclass[attn] = ResolveOpClass(pelem->opclass,
                                               atttype,
                                               am_oid == HASH_AM_OID ? "hash" : "btree",
                                               am_oid);
 
        attn++;
    }
}

References arg, Assert, bms_is_member(), bms_next_member(), CheckAttributeType(), CHKATYPE_IS_PARTKEY, PartitionElem::collation, contain_mutable_functions(), ereport, errcode(), errdetail(), errhint(), errmsg(), ERROR, PartitionElem::expr, exprCollation(), expression_planner(), exprType(), FirstLowInvalidHeapAttributeNumber, format_type_be(), get_attname(), get_collation_oid(), GetDefaultOpClass(), GETSTRUCT, HeapTupleIsValid, i, IsA, lappend(), lfirst_node, PartitionElem::location, PartitionElem::name, NIL, OidIsValid, PartitionElem::opclass, parser_errposition(), PARTITION_STRATEGY_HASH, pull_varattnos(), RelationGetDescr, RelationGetRelid, ReleaseSysCache(), ResolveOpClass(), SearchSysCacheAttName(), snprintf, TupleDescAttr, and type_is_collatable().

Referenced by DefineRelation().

ConstraintImpliedByRelConstraint()

bool ConstraintImpliedByRelConstraint ( Relation  scanrel, List *  testConstraint, List *  provenConstraint  )

static

Definition at line 19016 of file tablecmds.c.

{
    List       *existConstraint = list_copy(provenConstraint);
    TupleConstr *constr = RelationGetDescr(scanrel)->constr;
    int         num_check,
                i;
 
    num_check = (constr != NULL) ? constr->num_check : 0;
    for (i = 0; i < num_check; i++)
    {
        Node       *cexpr;
 
        /*
         * If this constraint hasn't been fully validated yet, we must ignore
         * it here.
         */
        if (!constr->check[i].ccvalid)
            continue;
 
        cexpr = stringToNode(constr->check[i].ccbin);
 
        /*
         * Run each expression through const-simplification and
         * canonicalization.  It is necessary, because we will be comparing it
         * to similarly-processed partition constraint expressions, and may
         * fail to detect valid matches without this.
         */
        cexpr = eval_const_expressions(NULL, cexpr);
        cexpr = (Node *) canonicalize_qual((Expr *) cexpr, true);
 
        existConstraint = list_concat(existConstraint,
                                      make_ands_implicit((Expr *) cexpr));
    }
 
    /*
     * Try to make the proof.  Since we are comparing CHECK constraints, we
     * need to use weak implication, i.e., we assume existConstraint is
     * not-false and try to prove the same for testConstraint.
     *
     * Note that predicate_implied_by assumes its first argument is known
     * immutable.  That should always be true for both NOT NULL and partition
     * constraints, so we don't test it here.
     */
    return predicate_implied_by(testConstraint, existConstraint, true);
}

References canonicalize_qual(), ConstrCheck::ccbin, ConstrCheck::ccvalid, TupleConstr::check, eval_const_expressions(), for(), i, list_concat(), list_copy(), make_ands_implicit(), TupleConstr::num_check, predicate_implied_by(), RelationGetDescr, and stringToNode().

Referenced by NotNullImpliedByRelConstraints(), and PartConstraintImpliedByRelConstraint().

constraints_equivalent()

static bool constraints_equivalent ( HeapTuple  a, HeapTuple  b, TupleDesc  tupleDesc  )

static

Definition at line 16379 of file tablecmds.c.

{
    Form_pg_constraint acon = (Form_pg_constraint) GETSTRUCT(a);
    Form_pg_constraint bcon = (Form_pg_constraint) GETSTRUCT(b);
 
    if (acon->condeferrable != bcon->condeferrable ||
        acon->condeferred != bcon->condeferred ||
        strcmp(decompile_conbin(a, tupleDesc),
               decompile_conbin(b, tupleDesc)) != 0)
        return false;
    else
        return true;
}

References a, b, decompile_conbin(), and GETSTRUCT.

Referenced by MergeConstraintsIntoExisting().

CreateFKCheckTrigger()

static Oid CreateFKCheckTrigger ( Oid  myRelOid, Oid  refRelOid, Constraint *  fkconstraint, Oid  constraintOid, Oid  indexOid, Oid  parentTrigOid, bool  on_insert  )

static

Definition at line 12653 of file tablecmds.c.

{
    ObjectAddress trigAddress;
    CreateTrigStmt *fk_trigger;
 
    /*
     * Note: for a self-referential FK (referencing and referenced tables are
     * the same), it is important that the ON UPDATE action fires before the
     * CHECK action, since both triggers will fire on the same row during an
     * UPDATE event; otherwise the CHECK trigger will be checking a non-final
     * state of the row.  Triggers fire in name order, so we ensure this by
     * using names like "RI_ConstraintTrigger_a_NNNN" for the action triggers
     * and "RI_ConstraintTrigger_c_NNNN" for the check triggers.
     */
    fk_trigger = makeNode(CreateTrigStmt);
    fk_trigger->replace = false;
    fk_trigger->isconstraint = true;
    fk_trigger->trigname = "RI_ConstraintTrigger_c";
    fk_trigger->relation = NULL;
 
    /* Either ON INSERT or ON UPDATE */
    if (on_insert)
    {
        fk_trigger->funcname = SystemFuncName("RI_FKey_check_ins");
        fk_trigger->events = TRIGGER_TYPE_INSERT;
    }
    else
    {
        fk_trigger->funcname = SystemFuncName("RI_FKey_check_upd");
        fk_trigger->events = TRIGGER_TYPE_UPDATE;
    }
 
    fk_trigger->args = NIL;
    fk_trigger->row = true;
    fk_trigger->timing = TRIGGER_TYPE_AFTER;
    fk_trigger->columns = NIL;
    fk_trigger->whenClause = NULL;
    fk_trigger->transitionRels = NIL;
    fk_trigger->deferrable = fkconstraint->deferrable;
    fk_trigger->initdeferred = fkconstraint->initdeferred;
    fk_trigger->constrrel = NULL;
 
    trigAddress = CreateTrigger(fk_trigger, NULL, myRelOid, refRelOid,
                                constraintOid, indexOid, InvalidOid,
                                parentTrigOid, NULL, true, false);
 
    /* Make changes-so-far visible */
    CommandCounterIncrement();
 
    return trigAddress.objectId;
}

References CreateTrigStmt::args, CreateTrigStmt::columns, CommandCounterIncrement(), CreateTrigStmt::constrrel, CreateTrigger(), Constraint::deferrable, CreateTrigStmt::deferrable, CreateTrigStmt::events, CreateTrigStmt::funcname, Constraint::initdeferred, CreateTrigStmt::initdeferred, InvalidOid, CreateTrigStmt::isconstraint, makeNode, NIL, ObjectAddress::objectId, CreateTrigStmt::relation, CreateTrigStmt::replace, CreateTrigStmt::row, SystemFuncName(), CreateTrigStmt::timing, CreateTrigStmt::transitionRels, CreateTrigStmt::trigname, and CreateTrigStmt::whenClause.

Referenced by createForeignKeyCheckTriggers().

createForeignKeyActionTriggers()

static void createForeignKeyActionTriggers ( Relation  rel, Oid  refRelOid, Constraint *  fkconstraint, Oid  constraintOid, Oid  indexOid, Oid  parentDelTrigger, Oid  parentUpdTrigger, Oid *  deleteTrigOid, Oid *  updateTrigOid  )

static

Definition at line 12716 of file tablecmds.c.

{
    CreateTrigStmt *fk_trigger;
    ObjectAddress trigAddress;
 
    /*
     * Build and execute a CREATE CONSTRAINT TRIGGER statement for the ON
     * DELETE action on the referenced table.
     */
    fk_trigger = makeNode(CreateTrigStmt);
    fk_trigger->replace = false;
    fk_trigger->isconstraint = true;
    fk_trigger->trigname = "RI_ConstraintTrigger_a";
    fk_trigger->relation = NULL;
    fk_trigger->args = NIL;
    fk_trigger->row = true;
    fk_trigger->timing = TRIGGER_TYPE_AFTER;
    fk_trigger->events = TRIGGER_TYPE_DELETE;
    fk_trigger->columns = NIL;
    fk_trigger->whenClause = NULL;
    fk_trigger->transitionRels = NIL;
    fk_trigger->constrrel = NULL;
 
    switch (fkconstraint->fk_del_action)
    {
        case FKCONSTR_ACTION_NOACTION:
            fk_trigger->deferrable = fkconstraint->deferrable;
            fk_trigger->initdeferred = fkconstraint->initdeferred;
            fk_trigger->funcname = SystemFuncName("RI_FKey_noaction_del");
            break;
        case FKCONSTR_ACTION_RESTRICT:
            fk_trigger->deferrable = false;
            fk_trigger->initdeferred = false;
            fk_trigger->funcname = SystemFuncName("RI_FKey_restrict_del");
            break;
        case FKCONSTR_ACTION_CASCADE:
            fk_trigger->deferrable = false;
            fk_trigger->initdeferred = false;
            fk_trigger->funcname = SystemFuncName("RI_FKey_cascade_del");
            break;
        case FKCONSTR_ACTION_SETNULL:
            fk_trigger->deferrable = false;
            fk_trigger->initdeferred = false;
            fk_trigger->funcname = SystemFuncName("RI_FKey_setnull_del");
            break;
        case FKCONSTR_ACTION_SETDEFAULT:
            fk_trigger->deferrable = false;
            fk_trigger->initdeferred = false;
            fk_trigger->funcname = SystemFuncName("RI_FKey_setdefault_del");
            break;
        default:
            elog(ERROR, "unrecognized FK action type: %d",
                 (int) fkconstraint->fk_del_action);
            break;
    }
 
    trigAddress = CreateTrigger(fk_trigger, NULL, refRelOid,
                                RelationGetRelid(rel),
                                constraintOid, indexOid, InvalidOid,
                                parentDelTrigger, NULL, true, false);
    if (deleteTrigOid)
        *deleteTrigOid = trigAddress.objectId;
 
    /* Make changes-so-far visible */
    CommandCounterIncrement();
 
    /*
     * Build and execute a CREATE CONSTRAINT TRIGGER statement for the ON
     * UPDATE action on the referenced table.
     */
    fk_trigger = makeNode(CreateTrigStmt);
    fk_trigger->replace = false;
    fk_trigger->isconstraint = true;
    fk_trigger->trigname = "RI_ConstraintTrigger_a";
    fk_trigger->relation = NULL;
    fk_trigger->args = NIL;
    fk_trigger->row = true;
    fk_trigger->timing = TRIGGER_TYPE_AFTER;
    fk_trigger->events = TRIGGER_TYPE_UPDATE;
    fk_trigger->columns = NIL;
    fk_trigger->whenClause = NULL;
    fk_trigger->transitionRels = NIL;
    fk_trigger->constrrel = NULL;
 
    switch (fkconstraint->fk_upd_action)
    {
        case FKCONSTR_ACTION_NOACTION:
            fk_trigger->deferrable = fkconstraint->deferrable;
            fk_trigger->initdeferred = fkconstraint->initdeferred;
            fk_trigger->funcname = SystemFuncName("RI_FKey_noaction_upd");
            break;
        case FKCONSTR_ACTION_RESTRICT:
            fk_trigger->deferrable = false;
            fk_trigger->initdeferred = false;
            fk_trigger->funcname = SystemFuncName("RI_FKey_restrict_upd");
            break;
        case FKCONSTR_ACTION_CASCADE:
            fk_trigger->deferrable = false;
            fk_trigger->initdeferred = false;
            fk_trigger->funcname = SystemFuncName("RI_FKey_cascade_upd");
            break;
        case FKCONSTR_ACTION_SETNULL:
            fk_trigger->deferrable = false;
            fk_trigger->initdeferred = false;
            fk_trigger->funcname = SystemFuncName("RI_FKey_setnull_upd");
            break;
        case FKCONSTR_ACTION_SETDEFAULT:
            fk_trigger->deferrable = false;
            fk_trigger->initdeferred = false;
            fk_trigger->funcname = SystemFuncName("RI_FKey_setdefault_upd");
            break;
        default:
            elog(ERROR, "unrecognized FK action type: %d",
                 (int) fkconstraint->fk_upd_action);
            break;
    }
 
    trigAddress = CreateTrigger(fk_trigger, NULL, refRelOid,
                                RelationGetRelid(rel),
                                constraintOid, indexOid, InvalidOid,
                                parentUpdTrigger, NULL, true, false);
    if (updateTrigOid)
        *updateTrigOid = trigAddress.objectId;
}

References CreateTrigStmt::args, CreateTrigStmt::columns, CommandCounterIncrement(), CreateTrigStmt::constrrel, CreateTrigger(), Constraint::deferrable, CreateTrigStmt::deferrable, elog, ERROR, CreateTrigStmt::events, Constraint::fk_del_action, Constraint::fk_upd_action, FKCONSTR_ACTION_CASCADE, FKCONSTR_ACTION_NOACTION, FKCONSTR_ACTION_RESTRICT, FKCONSTR_ACTION_SETDEFAULT, FKCONSTR_ACTION_SETNULL, CreateTrigStmt::funcname, Constraint::initdeferred, CreateTrigStmt::initdeferred, InvalidOid, CreateTrigStmt::isconstraint, makeNode, NIL, ObjectAddress::objectId, CreateTrigStmt::relation, RelationGetRelid, CreateTrigStmt::replace, CreateTrigStmt::row, SystemFuncName(), CreateTrigStmt::timing, CreateTrigStmt::transitionRels, CreateTrigStmt::trigname, and CreateTrigStmt::whenClause.

Referenced by addFkRecurseReferenced(), and DetachPartitionFinalize().

createForeignKeyCheckTriggers()

static void createForeignKeyCheckTriggers ( Oid  myRelOid, Oid  refRelOid, Constraint *  fkconstraint, Oid  constraintOid, Oid  indexOid, Oid  parentInsTrigger, Oid  parentUpdTrigger, Oid *  insertTrigOid, Oid *  updateTrigOid  )

static

Definition at line 12853 of file tablecmds.c.

{
    *insertTrigOid = CreateFKCheckTrigger(myRelOid, refRelOid, fkconstraint,
                                          constraintOid, indexOid,
                                          parentInsTrigger, true);
    *updateTrigOid = CreateFKCheckTrigger(myRelOid, refRelOid, fkconstraint,
                                          constraintOid, indexOid,
                                          parentUpdTrigger, false);
}

References CreateFKCheckTrigger().

Referenced by addFkRecurseReferencing().

CreateInheritance()

static void CreateInheritance ( Relation  child_rel, Relation  parent_rel, bool  ispartition  )

static

Definition at line 16285 of file tablecmds.c.

{
    Relation    catalogRelation;
    SysScanDesc scan;
    ScanKeyData key;
    HeapTuple   inheritsTuple;
    int32       inhseqno;
 
    /* Note: get RowExclusiveLock because we will write pg_inherits below. */
    catalogRelation = table_open(InheritsRelationId, RowExclusiveLock);
 
    /*
     * Check for duplicates in the list of parents, and determine the highest
     * inhseqno already present; we'll use the next one for the new parent.
     * Also, if proposed child is a partition, it cannot already be
     * inheriting.
     *
     * Note: we do not reject the case where the child already inherits from
     * the parent indirectly; CREATE TABLE doesn't reject comparable cases.
     */
    ScanKeyInit(&key,
                Anum_pg_inherits_inhrelid,
                BTEqualStrategyNumber, F_OIDEQ,
                ObjectIdGetDatum(RelationGetRelid(child_rel)));
    scan = systable_beginscan(catalogRelation, InheritsRelidSeqnoIndexId,
                              true, NULL, 1, &key);
 
    /* inhseqno sequences start at 1 */
    inhseqno = 0;
    while (HeapTupleIsValid(inheritsTuple = systable_getnext(scan)))
    {
        Form_pg_inherits inh = (Form_pg_inherits) GETSTRUCT(inheritsTuple);
 
        if (inh->inhparent == RelationGetRelid(parent_rel))
            ereport(ERROR,
                    (errcode(ERRCODE_DUPLICATE_TABLE),
                     errmsg("relation \"%s\" would be inherited from more than once",
                            RelationGetRelationName(parent_rel))));
 
        if (inh->inhseqno > inhseqno)
            inhseqno = inh->inhseqno;
    }
    systable_endscan(scan);
 
    /* Match up the columns and bump attinhcount as needed */
    MergeAttributesIntoExisting(child_rel, parent_rel, ispartition);
 
    /* Match up the constraints and bump coninhcount as needed */
    MergeConstraintsIntoExisting(child_rel, parent_rel);
 
    /*
     * OK, it looks valid.  Make the catalog entries that show inheritance.
     */
    StoreCatalogInheritance1(RelationGetRelid(child_rel),
                             RelationGetRelid(parent_rel),
                             inhseqno + 1,
                             catalogRelation,
                             parent_rel->rd_rel->relkind ==
                             RELKIND_PARTITIONED_TABLE);
 
    /* Now we're done with pg_inherits */
    table_close(catalogRelation, RowExclusiveLock);
}

References BTEqualStrategyNumber, ereport, errcode(), errmsg(), ERROR, GETSTRUCT, HeapTupleIsValid, sort-test::key, MergeAttributesIntoExisting(), MergeConstraintsIntoExisting(), ObjectIdGetDatum(), RelationData::rd_rel, RelationGetRelationName, RelationGetRelid, RowExclusiveLock, ScanKeyInit(), StoreCatalogInheritance1(), systable_beginscan(), systable_endscan(), systable_getnext(), table_close(), and table_open().

Referenced by ATExecAddInherit(), and attachPartitionTable().

createPartitionTable()

static void createPartitionTable ( RangeVar *  newPartName, RangeVar *  modelRelName, AlterTableUtilityContext *  context  )

static

Definition at line 21192 of file tablecmds.c.

{
    CreateStmt *createStmt;
    TableLikeClause *tlc;
    PlannedStmt *wrapper;
 
    createStmt = makeNode(CreateStmt);
    createStmt->relation = newPartName;
    createStmt->tableElts = NIL;
    createStmt->inhRelations = NIL;
    createStmt->constraints = NIL;
    createStmt->options = NIL;
    createStmt->oncommit = ONCOMMIT_NOOP;
    createStmt->tablespacename = NULL;
    createStmt->if_not_exists = false;
 
    tlc = makeNode(TableLikeClause);
    tlc->relation = modelRelName;
 
    /*
     * Indexes will be inherited on "attach new partitions" stage, after data
     * moving.
     */
    tlc->options = CREATE_TABLE_LIKE_ALL & ~(CREATE_TABLE_LIKE_INDEXES | CREATE_TABLE_LIKE_IDENTITY);
    tlc->relationOid = InvalidOid;
    createStmt->tableElts = lappend(createStmt->tableElts, tlc);
 
    /* Need to make a wrapper PlannedStmt. */
    wrapper = makeNode(PlannedStmt);
    wrapper->commandType = CMD_UTILITY;
    wrapper->canSetTag = false;
    wrapper->utilityStmt = (Node *) createStmt;
    wrapper->stmt_location = context->pstmt->stmt_location;
    wrapper->stmt_len = context->pstmt->stmt_len;
 
    ProcessUtility(wrapper,
                   context->queryString,
                   false,
                   PROCESS_UTILITY_SUBCOMMAND,
                   NULL,
                   NULL,
                   None_Receiver,
                   NULL);
}

References PlannedStmt::canSetTag, CMD_UTILITY, PlannedStmt::commandType, CreateStmt::constraints, context, CREATE_TABLE_LIKE_ALL, CREATE_TABLE_LIKE_IDENTITY, CREATE_TABLE_LIKE_INDEXES, CreateStmt::if_not_exists, CreateStmt::inhRelations, InvalidOid, lappend(), makeNode, NIL, None_Receiver, CreateStmt::oncommit, ONCOMMIT_NOOP, TableLikeClause::options, CreateStmt::options, PROCESS_UTILITY_SUBCOMMAND, ProcessUtility(), TableLikeClause::relation, CreateStmt::relation, TableLikeClause::relationOid, PlannedStmt::stmt_len, PlannedStmt::stmt_location, CreateStmt::tableElts, CreateStmt::tablespacename, and PlannedStmt::utilityStmt.

Referenced by ATExecMergePartitions(), and ATExecSplitPartition().

createSplitPartitionContext()

static SplitPartitionContext* createSplitPartitionContext ( Relation  partRel )

static

Definition at line 20951 of file tablecmds.c.

{
    SplitPartitionContext *pc;
 
    pc = (SplitPartitionContext *) palloc0(sizeof(SplitPartitionContext));
    pc->partRel = partRel;
 
    /*
     * Prepare a BulkInsertState for table_tuple_insert. The FSM is empty, so
     * don't bother using it.
     */
    pc->bistate = GetBulkInsertState();
 
    /* Create tuple slot for new partition. */
    pc->dstslot = MakeSingleTupleTableSlot(RelationGetDescr(pc->partRel),
                                           table_slot_callbacks(pc->partRel));
    ExecStoreAllNullTuple(pc->dstslot);
 
    return pc;
}

References SplitPartitionContext::bistate, SplitPartitionContext::dstslot, ExecStoreAllNullTuple(), GetBulkInsertState(), MakeSingleTupleTableSlot(), palloc0(), SplitPartitionContext::partRel, RelationGetDescr, and table_slot_callbacks().

Referenced by moveSplitTableRows().

decompile_conbin()

static char* decompile_conbin ( HeapTuple  contup, TupleDesc  tupdesc  )

static

Definition at line 16354 of file tablecmds.c.

{
    Form_pg_constraint con;
    bool        isnull;
    Datum       attr;
    Datum       expr;
 
    con = (Form_pg_constraint) GETSTRUCT(contup);
    attr = heap_getattr(contup, Anum_pg_constraint_conbin, tupdesc, &isnull);
    if (isnull)
        elog(ERROR, "null conbin for constraint %u", con->oid);
 
    expr = DirectFunctionCall2(pg_get_expr, attr,
                               ObjectIdGetDatum(con->conrelid));
    return TextDatumGetCString(expr);
}

References DirectFunctionCall2, elog, ERROR, GETSTRUCT, heap_getattr(), ObjectIdGetDatum(), pg_get_expr(), and TextDatumGetCString.

Referenced by constraints_equivalent().

DefineRelation()

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

Definition at line 700 of file tablecmds.c.

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

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

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

deleteSplitPartitionContext()

static void deleteSplitPartitionContext ( SplitPartitionContext *  pc, int  ti_options  )

static

Definition at line 20976 of file tablecmds.c.

{
    ExecDropSingleTupleTableSlot(pc->dstslot);
    FreeBulkInsertState(pc->bistate);
 
    table_finish_bulk_insert(pc->partRel, ti_options);
 
    pfree(pc);
}

References SplitPartitionContext::bistate, SplitPartitionContext::dstslot, ExecDropSingleTupleTableSlot(), FreeBulkInsertState(), SplitPartitionContext::partRel, pfree(), and table_finish_bulk_insert().

Referenced by moveSplitTableRows().

DetachAddConstraintIfNeeded()

static void DetachAddConstraintIfNeeded ( List **  wqueue, Relation  partRel  )

static

Definition at line 20284 of file tablecmds.c.

{
    List       *constraintExpr;
 
    constraintExpr = RelationGetPartitionQual(partRel);
    constraintExpr = (List *) eval_const_expressions(NULL, (Node *) constraintExpr);
 
    /*
     * Avoid adding a new constraint if the needed constraint is implied by an
     * existing constraint
     */
    if (!PartConstraintImpliedByRelConstraint(partRel, constraintExpr))
    {
        AlteredTableInfo *tab;
        Constraint *n;
 
        tab = ATGetQueueEntry(wqueue, partRel);
 
        /* Add constraint on partition, equivalent to the partition constraint */
        n = makeNode(Constraint);
        n->contype = CONSTR_CHECK;
        n->conname = NULL;
        n->location = -1;
        n->is_no_inherit = false;
        n->raw_expr = NULL;
        n->cooked_expr = nodeToString(make_ands_explicit(constraintExpr));
        n->initially_valid = true;
        n->skip_validation = true;
        /* It's a re-add, since it nominally already exists */
        ATAddCheckNNConstraint(wqueue, tab, partRel, n,
                               true, false, true, ShareUpdateExclusiveLock);
    }
}

References ATAddCheckNNConstraint(), ATGetQueueEntry(), Constraint::conname, CONSTR_CHECK, Constraint::contype, Constraint::cooked_expr, eval_const_expressions(), Constraint::initially_valid, Constraint::is_no_inherit, Constraint::location, make_ands_explicit(), makeNode, nodeToString(), PartConstraintImpliedByRelConstraint(), Constraint::raw_expr, RelationGetPartitionQual(), ShareUpdateExclusiveLock, and Constraint::skip_validation.

Referenced by ATExecDetachPartition().

DetachPartitionFinalize()

static void DetachPartitionFinalize ( Relation  rel, Relation  partRel, bool  concurrent, Oid  defaultPartOid  )

static

Definition at line 20010 of file tablecmds.c.

{
    Relation    classRel;
    List       *fks;
    ListCell   *cell;
    List       *indexes;
    Datum       new_val[Natts_pg_class];
    bool        new_null[Natts_pg_class],
                new_repl[Natts_pg_class];
    HeapTuple   tuple,
                newtuple;
    Relation    trigrel = NULL;
 
    if (concurrent)
    {
        /*
         * We can remove the pg_inherits row now. (In the non-concurrent case,
         * this was already done).
         */
        RemoveInheritance(partRel, rel, true);
    }
 
    /* Drop any triggers that were cloned on creation/attach. */
    DropClonedTriggersFromPartition(RelationGetRelid(partRel));
 
    /*
     * Detach any foreign keys that are inherited.  This includes creating
     * additional action triggers.
     */
    fks = copyObject(RelationGetFKeyList(partRel));
    if (fks != NIL)
        trigrel = table_open(TriggerRelationId, RowExclusiveLock);
    foreach(cell, fks)
    {
        ForeignKeyCacheInfo *fk = lfirst(cell);
        HeapTuple   contup;
        Form_pg_constraint conform;
        Constraint *fkconstraint;
        Oid         insertTriggerOid,
                    updateTriggerOid;
 
        contup = SearchSysCache1(CONSTROID, ObjectIdGetDatum(fk->conoid));
        if (!HeapTupleIsValid(contup))
            elog(ERROR, "cache lookup failed for constraint %u", fk->conoid);
        conform = (Form_pg_constraint) GETSTRUCT(contup);
 
        /* consider only the inherited foreign keys */
        if (conform->contype != CONSTRAINT_FOREIGN ||
            !OidIsValid(conform->conparentid))
        {
            ReleaseSysCache(contup);
            continue;
        }
 
        /* unset conparentid and adjust conislocal, coninhcount, etc. */
        ConstraintSetParentConstraint(fk->conoid, InvalidOid, InvalidOid);
 
        /*
         * Also, look up the partition's "check" triggers corresponding to the
         * constraint being detached and detach them from the parent triggers.
         */
        GetForeignKeyCheckTriggers(trigrel,
                                   fk->conoid, fk->confrelid, fk->conrelid,
                                   &insertTriggerOid, &updateTriggerOid);
        Assert(OidIsValid(insertTriggerOid));
        TriggerSetParentTrigger(trigrel, insertTriggerOid, InvalidOid,
                                RelationGetRelid(partRel));
        Assert(OidIsValid(updateTriggerOid));
        TriggerSetParentTrigger(trigrel, updateTriggerOid, InvalidOid,
                                RelationGetRelid(partRel));
 
        /*
         * Make the action triggers on the referenced relation.  When this was
         * a partition the action triggers pointed to the parent rel (they
         * still do), but now we need separate ones of our own.
         */
        fkconstraint = makeNode(Constraint);
        fkconstraint->contype = CONSTRAINT_FOREIGN;
        fkconstraint->conname = pstrdup(NameStr(conform->conname));
        fkconstraint->deferrable = conform->condeferrable;
        fkconstraint->initdeferred = conform->condeferred;
        fkconstraint->location = -1;
        fkconstraint->pktable = NULL;
        fkconstraint->fk_attrs = NIL;
        fkconstraint->pk_attrs = NIL;
        fkconstraint->fk_matchtype = conform->confmatchtype;
        fkconstraint->fk_upd_action = conform->confupdtype;
        fkconstraint->fk_del_action = conform->confdeltype;
        fkconstraint->fk_del_set_cols = NIL;
        fkconstraint->old_conpfeqop = NIL;
        fkconstraint->old_pktable_oid = InvalidOid;
        fkconstraint->skip_validation = false;
        fkconstraint->initially_valid = true;
 
        createForeignKeyActionTriggers(partRel, conform->confrelid,
                                       fkconstraint, fk->conoid,
                                       conform->conindid,
                                       InvalidOid, InvalidOid,
                                       NULL, NULL);
 
        ReleaseSysCache(contup);
    }
    list_free_deep(fks);
    if (trigrel)
        table_close(trigrel, RowExclusiveLock);
 
    /*
     * Any sub-constraints that are in the referenced-side of a larger
     * constraint have to be removed.  This partition is no longer part of the
     * key space of the constraint.
     */
    foreach(cell, GetParentedForeignKeyRefs(partRel))
    {
        Oid         constrOid = lfirst_oid(cell);
        ObjectAddress constraint;
 
        ConstraintSetParentConstraint(constrOid, InvalidOid, InvalidOid);
        deleteDependencyRecordsForClass(ConstraintRelationId,
                                        constrOid,
                                        ConstraintRelationId,
                                        DEPENDENCY_INTERNAL);
        CommandCounterIncrement();
 
        ObjectAddressSet(constraint, ConstraintRelationId, constrOid);
        performDeletion(&constraint, DROP_RESTRICT, 0);
    }
 
    /* Now we can detach indexes */
    indexes = RelationGetIndexList(partRel);
    foreach(cell, indexes)
    {
        Oid         idxid = lfirst_oid(cell);
        Relation    idx;
        Oid         constrOid;
 
        if (!has_superclass(idxid))
            continue;
 
        Assert((IndexGetRelation(get_partition_parent(idxid, false), false) ==
                RelationGetRelid(rel)));
 
        idx = index_open(idxid, AccessExclusiveLock);
        IndexSetParentIndex(idx, InvalidOid);
 
        /* If there's a constraint associated with the index, detach it too */
        constrOid = get_relation_idx_constraint_oid(RelationGetRelid(partRel),
                                                    idxid);
        if (OidIsValid(constrOid))
            ConstraintSetParentConstraint(constrOid, InvalidOid, InvalidOid);
 
        index_close(idx, NoLock);
    }
 
    /* Update pg_class tuple */
    classRel = table_open(RelationRelationId, RowExclusiveLock);
    tuple = SearchSysCacheCopy1(RELOID,
                                ObjectIdGetDatum(RelationGetRelid(partRel)));
    if (!HeapTupleIsValid(tuple))
        elog(ERROR, "cache lookup failed for relation %u",
             RelationGetRelid(partRel));
    Assert(((Form_pg_class) GETSTRUCT(tuple))->relispartition);
 
    /* Clear relpartbound and reset relispartition */
    memset(new_val, 0, sizeof(new_val));
    memset(new_null, false, sizeof(new_null));
    memset(new_repl, false, sizeof(new_repl));
    new_val[Anum_pg_class_relpartbound - 1] = (Datum) 0;
    new_null[Anum_pg_class_relpartbound - 1] = true;
    new_repl[Anum_pg_class_relpartbound - 1] = true;
    newtuple = heap_modify_tuple(tuple, RelationGetDescr(classRel),
                                 new_val, new_null, new_repl);
 
    ((Form_pg_class) GETSTRUCT(newtuple))->relispartition = false;
    CatalogTupleUpdate(classRel, &newtuple->t_self, newtuple);
    heap_freetuple(newtuple);
    table_close(classRel, RowExclusiveLock);
 
    /*
     * Drop identity property from all identity columns of partition.
     */
    for (int attno = 0; attno < RelationGetNumberOfAttributes(partRel); attno++)
    {
        Form_pg_attribute attr = TupleDescAttr(partRel->rd_att, attno);
 
        if (!attr->attisdropped && attr->attidentity)
            ATExecDropIdentity(partRel, NameStr(attr->attname), false,
                               AccessExclusiveLock, true, true);
    }
 
    if (OidIsValid(defaultPartOid))
    {
        /*
         * If the relation being detached is the default partition itself,
         * remove it from the parent's pg_partitioned_table entry.
         *
         * If not, we must invalidate default partition's relcache entry, as
         * in StorePartitionBound: its partition constraint depends on every
         * other partition's partition constraint.
         */
        if (RelationGetRelid(partRel) == defaultPartOid)
            update_default_partition_oid(RelationGetRelid(rel), InvalidOid);
        else
            CacheInvalidateRelcacheByRelid(defaultPartOid);
    }
 
    /*
     * Invalidate the parent's relcache so that the partition is no longer
     * included in its partition descriptor.
     */
    CacheInvalidateRelcache(rel);
 
    /*
     * If the partition we just detached is partitioned itself, invalidate
     * relcache for all descendent partitions too to ensure that their
     * rd_partcheck expression trees are rebuilt; must lock partitions before
     * doing so, using the same lockmode as what partRel has been locked with
     * by the caller.
     */
    if (partRel->rd_rel->relkind == RELKIND_PARTITIONED_TABLE)
    {
        List       *children;
 
        children = find_all_inheritors(RelationGetRelid(partRel),
                                       AccessExclusiveLock, NULL);
        foreach(cell, children)
        {
            CacheInvalidateRelcacheByRelid(lfirst_oid(cell));
        }
    }
}

References AccessExclusiveLock, Assert, ATExecDropIdentity(), CacheInvalidateRelcache(), CacheInvalidateRelcacheByRelid(), CatalogTupleUpdate(), CommandCounterIncrement(), ForeignKeyCacheInfo::confrelid, Constraint::conname, ForeignKeyCacheInfo::conoid, ForeignKeyCacheInfo::conrelid, ConstraintSetParentConstraint(), Constraint::contype, copyObject, createForeignKeyActionTriggers(), Constraint::deferrable, deleteDependencyRecordsForClass(), DEPENDENCY_INTERNAL, DROP_RESTRICT, DropClonedTriggersFromPartition(), elog, ERROR, find_all_inheritors(), Constraint::fk_attrs, Constraint::fk_del_action, Constraint::fk_del_set_cols, Constraint::fk_matchtype, Constraint::fk_upd_action, get_partition_parent(), get_relation_idx_constraint_oid(), GetForeignKeyCheckTriggers(), GetParentedForeignKeyRefs(), GETSTRUCT, has_superclass(), heap_freetuple(), heap_modify_tuple(), HeapTupleIsValid, idx(), index_close(), index_open(), IndexGetRelation(), IndexSetParentIndex(), Constraint::initdeferred, Constraint::initially_valid, InvalidOid, lfirst, lfirst_oid, list_free_deep(), Constraint::location, makeNode, NameStr, NIL, NoLock, ObjectAddressSet, ObjectIdGetDatum(), OidIsValid, Constraint::old_conpfeqop, Constraint::old_pktable_oid, performDeletion(), Constraint::pk_attrs, Constraint::pktable, pstrdup(), RelationData::rd_att, RelationData::rd_rel, RelationGetDescr, RelationGetFKeyList(), RelationGetIndexList(), RelationGetNumberOfAttributes, RelationGetRelid, ReleaseSysCache(), RemoveInheritance(), RowExclusiveLock, SearchSysCache1(), SearchSysCacheCopy1, Constraint::skip_validation, HeapTupleData::t_self, table_close(), table_open(), TriggerSetParentTrigger(), TupleDescAttr, and update_default_partition_oid().

Referenced by ATExecDetachPartition(), ATExecDetachPartitionFinalize(), ATExecMergePartitions(), and ATExecSplitPartition().

drop_parent_dependency()

static void drop_parent_dependency ( Oid  relid, Oid  refclassid, Oid  refobjid, DependencyType  deptype  )

static

Definition at line 17103 of file tablecmds.c.

{
    Relation    catalogRelation;
    SysScanDesc scan;
    ScanKeyData key[3];
    HeapTuple   depTuple;
 
    catalogRelation = table_open(DependRelationId, RowExclusiveLock);
 
    ScanKeyInit(&key[0],
                Anum_pg_depend_classid,
                BTEqualStrategyNumber, F_OIDEQ,
                ObjectIdGetDatum(RelationRelationId));
    ScanKeyInit(&key[1],
                Anum_pg_depend_objid,
                BTEqualStrategyNumber, F_OIDEQ,
                ObjectIdGetDatum(relid));
    ScanKeyInit(&key[2],
                Anum_pg_depend_objsubid,
                BTEqualStrategyNumber, F_INT4EQ,
                Int32GetDatum(0));
 
    scan = systable_beginscan(catalogRelation, DependDependerIndexId, true,
                              NULL, 3, key);
 
    while (HeapTupleIsValid(depTuple = systable_getnext(scan)))
    {
        Form_pg_depend dep = (Form_pg_depend) GETSTRUCT(depTuple);
 
        if (dep->refclassid == refclassid &&
            dep->refobjid == refobjid &&
            dep->refobjsubid == 0 &&
            dep->deptype == deptype)
            CatalogTupleDelete(catalogRelation, &depTuple->t_self);
    }
 
    systable_endscan(scan);
    table_close(catalogRelation, RowExclusiveLock);
}

References BTEqualStrategyNumber, CatalogTupleDelete(), GETSTRUCT, HeapTupleIsValid, Int32GetDatum(), sort-test::key, ObjectIdGetDatum(), RowExclusiveLock, ScanKeyInit(), systable_beginscan(), systable_endscan(), systable_getnext(), HeapTupleData::t_self, table_close(), and table_open().

Referenced by ATExecAddOf(), ATExecDropOf(), and RemoveInheritance().

DropClonedTriggersFromPartition()

static void DropClonedTriggersFromPartition ( Oid  partitionId )

static

Definition at line 20325 of file tablecmds.c.

{
    ScanKeyData skey;
    SysScanDesc scan;
    HeapTuple   trigtup;
    Relation    tgrel;
    ObjectAddresses *objects;
 
    objects = new_object_addresses();
 
    /*
     * Scan pg_trigger to search for all triggers on this rel.
     */
    ScanKeyInit(&skey, Anum_pg_trigger_tgrelid, BTEqualStrategyNumber,
                F_OIDEQ, ObjectIdGetDatum(partitionId));
    tgrel = table_open(TriggerRelationId, RowExclusiveLock);
    scan = systable_beginscan(tgrel, TriggerRelidNameIndexId,
                              true, NULL, 1, &skey);
    while (HeapTupleIsValid(trigtup = systable_getnext(scan)))
    {
        Form_pg_trigger pg_trigger = (Form_pg_trigger) GETSTRUCT(trigtup);
        ObjectAddress trig;
 
        /* Ignore triggers that weren't cloned */
        if (!OidIsValid(pg_trigger->tgparentid))
            continue;
 
        /*
         * Ignore internal triggers that are implementation objects of foreign
         * keys, because these will be detached when the foreign keys
         * themselves are.
         */
        if (OidIsValid(pg_trigger->tgconstrrelid))
            continue;
 
        /*
         * This is ugly, but necessary: remove the dependency markings on the
         * trigger so that it can be removed.
         */
        deleteDependencyRecordsForClass(TriggerRelationId, pg_trigger->oid,
                                        TriggerRelationId,
                                        DEPENDENCY_PARTITION_PRI);
        deleteDependencyRecordsForClass(TriggerRelationId, pg_trigger->oid,
                                        RelationRelationId,
                                        DEPENDENCY_PARTITION_SEC);
 
        /* remember this trigger to remove it below */
        ObjectAddressSet(trig, TriggerRelationId, pg_trigger->oid);
        add_exact_object_address(&trig, objects);
    }
 
    /* make the dependency removal visible to the deletion below */
    CommandCounterIncrement();
    performMultipleDeletions(objects, DROP_RESTRICT, PERFORM_DELETION_INTERNAL);
 
    /* done */
    free_object_addresses(objects);
    systable_endscan(scan);
    table_close(tgrel, RowExclusiveLock);
}

References add_exact_object_address(), BTEqualStrategyNumber, CommandCounterIncrement(), deleteDependencyRecordsForClass(), DEPENDENCY_PARTITION_PRI, DEPENDENCY_PARTITION_SEC, DROP_RESTRICT, free_object_addresses(), GETSTRUCT, HeapTupleIsValid, new_object_addresses(), ObjectAddressSet, ObjectIdGetDatum(), OidIsValid, PERFORM_DELETION_INTERNAL, performMultipleDeletions(), RowExclusiveLock, ScanKeyInit(), systable_beginscan(), systable_endscan(), systable_getnext(), table_close(), and table_open().

Referenced by DetachPartitionFinalize().

dropconstraint_internal()

static ObjectAddress dropconstraint_internal ( Relation  rel, HeapTuple  constraintTup, DropBehavior  behavior, bool  recurse, bool  recursing, bool  missing_ok, List **  readyRels, LOCKMODE  lockmode  )

static

Definition at line 12940 of file tablecmds.c.

{
    Relation    conrel;
    Form_pg_constraint con;
    ObjectAddress conobj;
    List       *children;
    bool        is_no_inherit_constraint = false;
    char       *constrName;
    List       *unconstrained_cols = NIL;
    char       *colname = NULL;
    bool        dropping_pk = false;
 
    if (list_member_oid(*readyRels, RelationGetRelid(rel)))
        return InvalidObjectAddress;
    *readyRels = lappend_oid(*readyRels, RelationGetRelid(rel));
 
    /* Guard against stack overflow due to overly deep inheritance tree. */
    check_stack_depth();
 
    /* At top level, permission check was done in ATPrepCmd, else do it */
    if (recursing)
        ATSimplePermissions(AT_DropConstraint, rel, ATT_TABLE | ATT_FOREIGN_TABLE);
 
    conrel = table_open(ConstraintRelationId, RowExclusiveLock);
 
    con = (Form_pg_constraint) GETSTRUCT(constraintTup);
    constrName = NameStr(con->conname);
 
    /*
     * If we're asked to drop a constraint which is both defined locally and
     * inherited, we can simply mark it as no longer having a local
     * definition, and no further changes are required.
     *
     * XXX We do this for not-null constraints only, not CHECK, because the
     * latter have historically not behaved this way and it might be confusing
     * to change the behavior now.
     */
    if (con->contype == CONSTRAINT_NOTNULL &&
        con->conislocal && con->coninhcount > 0)
    {
        HeapTuple   copytup;
 
        copytup = heap_copytuple(constraintTup);
        con = (Form_pg_constraint) GETSTRUCT(copytup);
        con->conislocal = false;
        CatalogTupleUpdate(conrel, &copytup->t_self, copytup);
        ObjectAddressSet(conobj, ConstraintRelationId, con->oid);
 
        CommandCounterIncrement();
        table_close(conrel, RowExclusiveLock);
        return conobj;
    }
 
    /* Don't allow drop of inherited constraints */
    if (con->coninhcount > 0 && !recursing)
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_TABLE_DEFINITION),
                 errmsg("cannot drop inherited constraint \"%s\" of relation \"%s\"",
                        constrName, RelationGetRelationName(rel))));
 
    /*
     * See if we have a not-null constraint or a PRIMARY KEY.  If so, we have
     * more checks and actions below, so obtain the list of columns that are
     * constrained by the constraint being dropped.
     */
    if (con->contype == CONSTRAINT_NOTNULL)
    {
        AttrNumber  colnum;
 
        colnum = extractNotNullColumn(constraintTup);
        unconstrained_cols = list_make1_int(colnum);
        colname = NameStr(TupleDescAttr(RelationGetDescr(rel),
                                        colnum - 1)->attname);
    }
    else if (con->contype == CONSTRAINT_PRIMARY)
    {
        Datum       adatum;
        ArrayType  *arr;
        int         numkeys;
        bool        isNull;
        int16      *attnums;
 
        dropping_pk = true;
 
        adatum = heap_getattr(constraintTup, Anum_pg_constraint_conkey,
                              RelationGetDescr(conrel), &isNull);
        if (isNull)
            elog(ERROR, "null conkey for constraint %u", con->oid);
        arr = DatumGetArrayTypeP(adatum);   /* ensure not toasted */
        numkeys = ARR_DIMS(arr)[0];
        if (ARR_NDIM(arr) != 1 ||
            numkeys < 0 ||
            ARR_HASNULL(arr) ||
            ARR_ELEMTYPE(arr) != INT2OID)
            elog(ERROR, "conkey is not a 1-D smallint array");
        attnums = (int16 *) ARR_DATA_PTR(arr);
 
        for (int i = 0; i < numkeys; i++)
            unconstrained_cols = lappend_int(unconstrained_cols, attnums[i]);
    }
 
    is_no_inherit_constraint = con->connoinherit;
 
    /*
     * If it's a foreign-key constraint, we'd better lock the referenced table
     * and check that that's not in use, just as we've already done for the
     * constrained table (else we might, eg, be dropping a trigger that has
     * unfired events).  But we can/must skip that in the self-referential
     * case.
     */
    if (con->contype == CONSTRAINT_FOREIGN &&
        con->confrelid != RelationGetRelid(rel))
    {
        Relation    frel;
 
        /* Must match lock taken by RemoveTriggerById: */
        frel = table_open(con->confrelid, AccessExclusiveLock);
        CheckTableNotInUse(frel, "ALTER TABLE");
        table_close(frel, NoLock);
    }
 
    /*
     * Perform the actual constraint deletion
     */
    ObjectAddressSet(conobj, ConstraintRelationId, con->oid);
    performDeletion(&conobj, behavior, 0);
 
    /*
     * If this was a NOT NULL or the primary key, verify that we still have
     * constraints to support GENERATED AS IDENTITY or the replica identity.
     */
    if (unconstrained_cols != NIL)
    {
        Relation    attrel;
        Bitmapset  *pkcols;
        Bitmapset  *ircols;
 
        /* Make implicit attnotnull changes visible */
        CommandCounterIncrement();
 
        attrel = table_open(AttributeRelationId, RowExclusiveLock);
 
        /*
         * We want to test columns for their presence in the primary key, but
         * only if we're not dropping it.
         */
        pkcols = dropping_pk ? NULL :
            RelationGetIndexAttrBitmap(rel,
                                       INDEX_ATTR_BITMAP_PRIMARY_KEY);
        ircols = RelationGetIndexAttrBitmap(rel, INDEX_ATTR_BITMAP_IDENTITY_KEY);
 
        foreach_int(attnum, unconstrained_cols)
        {
            HeapTuple   atttup;
            HeapTuple   contup;
            Form_pg_attribute attForm;
            char        attidentity;
 
            /*
             * Obtain pg_attribute tuple and verify conditions on it.
             */
            atttup = SearchSysCacheAttNum(RelationGetRelid(rel), attnum);
            if (!HeapTupleIsValid(atttup))
                elog(ERROR, "cache lookup failed for attribute %d of relation %u",
                     attnum, RelationGetRelid(rel));
            attForm = (Form_pg_attribute) GETSTRUCT(atttup);
            attidentity = attForm->attidentity;
            ReleaseSysCache(atttup);
 
            /*
             * Since the above deletion has been made visible, we can now
             * search for any remaining constraints on this column (or these
             * columns, in the case we're dropping a multicol primary key.)
             * Then, verify whether any further NOT NULL or primary key
             * exists: if none and this is a generated identity column or the
             * replica identity, abort the whole thing.
             */
            contup = findNotNullConstraintAttnum(RelationGetRelid(rel), attnum);
            if (contup ||
                bms_is_member(attnum - FirstLowInvalidHeapAttributeNumber,
                              pkcols))
                continue;
 
            /*
             * It's not valid to drop the not-null constraint for a GENERATED
             * AS IDENTITY column.
             */
            if (attidentity != '\0')
                ereport(ERROR,
                        errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
                        errmsg("column \"%s\" of relation \"%s\" is an identity column",
                               get_attname(RelationGetRelid(rel), attnum,
                                           false),
                               RelationGetRelationName(rel)));
 
            /*
             * It's not valid to drop the not-null constraint for a column in
             * the replica identity index, either. (FULL is not affected.)
             */
            if (bms_is_member(attnum - FirstLowInvalidHeapAttributeNumber, ircols))
                ereport(ERROR,
                        errcode(ERRCODE_INVALID_TABLE_DEFINITION),
                        errmsg("column \"%s\" is in index used as replica identity",
                               get_attname(RelationGetRelid(rel), attnum, false)));
        }
        table_close(attrel, RowExclusiveLock);
    }
 
    /*
     * For partitioned tables, non-CHECK, non-NOT-NULL inherited constraints
     * are dropped via the dependency mechanism, so we're done here.
     */
    if (con->contype != CONSTRAINT_CHECK &&
        con->contype != CONSTRAINT_NOTNULL &&
        rel->rd_rel->relkind == RELKIND_PARTITIONED_TABLE)
    {
        table_close(conrel, RowExclusiveLock);
        return conobj;
    }
 
    /*
     * 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.
     */
    if (!is_no_inherit_constraint)
        children = find_inheritance_children(RelationGetRelid(rel), lockmode);
    else
        children = NIL;
 
    /*
     * For a partitioned table, if partitions exist and we are told not to
     * recurse, it's a user error.  It doesn't make sense to have a constraint
     * be defined only on the parent, especially if it's a partitioned table.
     */
    if (rel->rd_rel->relkind == RELKIND_PARTITIONED_TABLE &&
        children != NIL && !recurse)
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_TABLE_DEFINITION),
                 errmsg("cannot remove constraint from only the partitioned table when partitions exist"),
                 errhint("Do not specify the ONLY keyword.")));
 
    foreach_oid(childrelid, children)
    {
        Relation    childrel;
        HeapTuple   tuple;
        Form_pg_constraint childcon;
 
        if (list_member_oid(*readyRels, childrelid))
            continue;           /* child already processed */
 
        /* find_inheritance_children already got lock */
        childrel = table_open(childrelid, NoLock);
        CheckTableNotInUse(childrel, "ALTER TABLE");
 
        /*
         * We search for not-null constraints by column name, and others by
         * constraint name.
         */
        if (con->contype == CONSTRAINT_NOTNULL)
        {
            tuple = findNotNullConstraint(childrelid, colname);
            if (!HeapTupleIsValid(tuple))
                elog(ERROR, "cache lookup failed for not-null constraint on column \"%s\" of relation %u",
                     colname, RelationGetRelid(childrel));
        }
        else
        {
            SysScanDesc scan;
            ScanKeyData skey[3];
 
            ScanKeyInit(&skey[0],
                        Anum_pg_constraint_conrelid,
                        BTEqualStrategyNumber, F_OIDEQ,
                        ObjectIdGetDatum(childrelid));
            ScanKeyInit(&skey[1],
                        Anum_pg_constraint_contypid,
                        BTEqualStrategyNumber, F_OIDEQ,
                        ObjectIdGetDatum(InvalidOid));
            ScanKeyInit(&skey[2],
                        Anum_pg_constraint_conname,
                        BTEqualStrategyNumber, F_NAMEEQ,
                        CStringGetDatum(constrName));
            scan = systable_beginscan(conrel, ConstraintRelidTypidNameIndexId,
                                      true, NULL, 3, skey);
            /* There can only be one, so no need to loop */
            tuple = systable_getnext(scan);
            if (!HeapTupleIsValid(tuple))
                ereport(ERROR,
                        (errcode(ERRCODE_UNDEFINED_OBJECT),
                         errmsg("constraint \"%s\" of relation \"%s\" does not exist",
                                constrName,
                                RelationGetRelationName(childrel))));
            tuple = heap_copytuple(tuple);
            systable_endscan(scan);
        }
 
        childcon = (Form_pg_constraint) GETSTRUCT(tuple);
 
        /* Right now only CHECK and not-null constraints can be inherited */
        if (childcon->contype != CONSTRAINT_CHECK &&
            childcon->contype != CONSTRAINT_NOTNULL)
            elog(ERROR, "inherited constraint is not a CHECK or not-null constraint");
 
        if (childcon->coninhcount <= 0) /* shouldn't happen */
            elog(ERROR, "relation %u has non-inherited constraint \"%s\"",
                 childrelid, NameStr(childcon->conname));
 
        if (recurse)
        {
            /*
             * If the child constraint has other definition sources, just
             * decrement its inheritance count; if not, recurse to delete it.
             */
            if (childcon->coninhcount == 1 && !childcon->conislocal)
            {
                /* Time to delete this child constraint, too */
                dropconstraint_internal(childrel, tuple, behavior,
                                        recurse, true, missing_ok, readyRels,
                                        lockmode);
            }
            else
            {
                /* Child constraint must survive my deletion */
                childcon->coninhcount--;
                CatalogTupleUpdate(conrel, &tuple->t_self, tuple);
 
                /* Make update visible */
                CommandCounterIncrement();
            }
        }
        else
        {
            /*
             * If we were told to drop ONLY in this table (no recursion) and
             * there are no further parents for this constraint, we need to
             * mark the inheritors' constraints as locally defined rather than
             * inherited.
             */
            childcon->coninhcount--;
            if (childcon->coninhcount == 0)
                childcon->conislocal = true;
 
            CatalogTupleUpdate(conrel, &tuple->t_self, tuple);
 
            /* Make update visible */
            CommandCounterIncrement();
        }
 
        heap_freetuple(tuple);
 
        table_close(childrel, NoLock);
    }
 
    /*
     * In addition, when dropping a primary key from a legacy-inheritance
     * parent table, we must recurse to children to mark the corresponding NOT
     * NULL constraint as no longer inherited, or drop it if this its last
     * reference.
     */
    if (con->contype == CONSTRAINT_PRIMARY &&
        rel->rd_rel->relkind == RELKIND_RELATION &&
        rel->rd_rel->relhassubclass)
    {
        List       *colnames = NIL;
        List       *pkready = NIL;
 
        /*
         * Because primary keys are always marked as NO INHERIT, we don't have
         * a list of children yet, so obtain one now.
         */
        children = find_inheritance_children(RelationGetRelid(rel), lockmode);
 
        /*
         * Find out the list of column names to process.  Fortunately, we
         * already have the list of column numbers.
         */
        foreach_int(attnum, unconstrained_cols)
        {
            colnames = lappend(colnames, get_attname(RelationGetRelid(rel),
                                                     attnum, false));
        }
 
        foreach_oid(childrelid, children)
        {
            Relation    childrel;
 
            if (list_member_oid(pkready, childrelid))
                continue;       /* child already processed */
 
            /* find_inheritance_children already got lock */
            childrel = table_open(childrelid, NoLock);
            CheckTableNotInUse(childrel, "ALTER TABLE");
 
            foreach_ptr(char, colName, colnames)
            {
                HeapTuple   contup;
 
                contup = findNotNullConstraint(childrelid, colName);
                if (contup == NULL)
                    elog(ERROR, "cache lookup failed for not-null constraint on column \"%s\", relation \"%s\"",
                         colName, RelationGetRelationName(childrel));
 
                dropconstraint_internal(childrel, contup,
                                        DROP_RESTRICT, true, true,
                                        false, &pkready,
                                        lockmode);
                pkready = NIL;
            }
 
            table_close(childrel, NoLock);
 
            pkready = lappend_oid(pkready, childrelid);
        }
    }
 
    table_close(conrel, RowExclusiveLock);
 
    return conobj;
}

References AccessExclusiveLock, ARR_DATA_PTR, ARR_DIMS, ARR_ELEMTYPE, ARR_HASNULL, ARR_NDIM, AT_DropConstraint, ATSimplePermissions(), ATT_FOREIGN_TABLE, ATT_TABLE, attname, attnum, bms_is_member(), BTEqualStrategyNumber, CatalogTupleUpdate(), check_stack_depth(), CheckTableNotInUse(), CommandCounterIncrement(), CStringGetDatum(), DatumGetArrayTypeP, DROP_RESTRICT, elog, ereport, errcode(), errhint(), errmsg(), ERROR, extractNotNullColumn(), find_inheritance_children(), findNotNullConstraint(), findNotNullConstraintAttnum(), FirstLowInvalidHeapAttributeNumber, foreach_int, foreach_oid, foreach_ptr, get_attname(), GETSTRUCT, heap_copytuple(), heap_freetuple(), heap_getattr(), HeapTupleIsValid, i, INDEX_ATTR_BITMAP_IDENTITY_KEY, INDEX_ATTR_BITMAP_PRIMARY_KEY, InvalidObjectAddress, InvalidOid, lappend(), lappend_int(), lappend_oid(), list_make1_int, list_member_oid(), NameStr, NIL, NoLock, ObjectAddressSet, ObjectIdGetDatum(), performDeletion(), RelationData::rd_rel, RelationGetDescr, RelationGetIndexAttrBitmap(), RelationGetRelationName, RelationGetRelid, ReleaseSysCache(), RowExclusiveLock, ScanKeyInit(), SearchSysCacheAttNum(), systable_beginscan(), systable_endscan(), systable_getnext(), HeapTupleData::t_self, table_close(), table_open(), and TupleDescAttr.

Referenced by ATExecDropConstraint(), and ATExecDropNotNull().

DropErrorMsgNonExistent()

static void DropErrorMsgNonExistent ( RangeVar *  rel, char  rightkind, bool  missing_ok  )

static

Definition at line 1409 of file tablecmds.c.

{
    const struct dropmsgstrings *rentry;
 
    if (rel->schemaname != NULL &&
        !OidIsValid(LookupNamespaceNoError(rel->schemaname)))
    {
        if (!missing_ok)
        {
            ereport(ERROR,
                    (errcode(ERRCODE_UNDEFINED_SCHEMA),
                     errmsg("schema \"%s\" does not exist", rel->schemaname)));
        }
        else
        {
            ereport(NOTICE,
                    (errmsg("schema \"%s\" does not exist, skipping",
                            rel->schemaname)));
        }
        return;
    }
 
    for (rentry = dropmsgstringarray; rentry->kind != '\0'; rentry++)
    {
        if (rentry->kind == rightkind)
        {
            if (!missing_ok)
            {
                ereport(ERROR,
                        (errcode(rentry->nonexistent_code),
                         errmsg(rentry->nonexistent_msg, rel->relname)));
            }
            else
            {
                ereport(NOTICE, (errmsg(rentry->skipping_msg, rel->relname)));
                break;
            }
        }
    }
 
    Assert(rentry->kind != '\0');   /* Should be impossible */
}

References Assert, dropmsgstringarray, ereport, errcode(), errmsg(), ERROR, dropmsgstrings::kind, LookupNamespaceNoError(), dropmsgstrings::nonexistent_code, dropmsgstrings::nonexistent_msg, NOTICE, OidIsValid, RangeVar::relname, RangeVar::schemaname, and dropmsgstrings::skipping_msg.

Referenced by RemoveRelations().

DropErrorMsgWrongType()

static void DropErrorMsgWrongType ( const char *  relname, char  wrongkind, char  rightkind  )

static

Definition at line 1457 of file tablecmds.c.

{
    const struct dropmsgstrings *rentry;
    const struct dropmsgstrings *wentry;
 
    for (rentry = dropmsgstringarray; rentry->kind != '\0'; rentry++)
        if (rentry->kind == rightkind)
            break;
    Assert(rentry->kind != '\0');
 
    for (wentry = dropmsgstringarray; wentry->kind != '\0'; wentry++)
        if (wentry->kind == wrongkind)
            break;
    /* wrongkind could be something we don't have in our table... */
 
    ereport(ERROR,
            (errcode(ERRCODE_WRONG_OBJECT_TYPE),
             errmsg(rentry->nota_msg, relname),
             (wentry->kind != '\0') ? errhint("%s", _(wentry->drophint_msg)) : 0));
}

References _, Assert, dropmsgstrings::drophint_msg, dropmsgstringarray, ereport, errcode(), errhint(), errmsg(), ERROR, dropmsgstrings::kind, dropmsgstrings::nota_msg, and relname.

Referenced by RangeVarCallbackForDropRelation().

ExecuteTruncate()

void ExecuteTruncate

(

TruncateStmt *

stmt

)

Definition at line 1807 of file tablecmds.c.

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

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

Referenced by standard_ProcessUtility().

ExecuteTruncateGuts()

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

Definition at line 1931 of file tablecmds.c.

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

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

Referenced by apply_handle_truncate(), and ExecuteTruncate().

find_composite_type_dependencies()

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

Definition at line 6807 of file tablecmds.c.

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

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

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

find_typed_table_dependencies()

static List * find_typed_table_dependencies ( Oid  typeOid, const char *  typeName, DropBehavior  behavior  )

static

Definition at line 6965 of file tablecmds.c.

{
    Relation    classRel;
    ScanKeyData key[1];
    TableScanDesc scan;
    HeapTuple   tuple;
    List       *result = NIL;
 
    classRel = table_open(RelationRelationId, AccessShareLock);
 
    ScanKeyInit(&key[0],
                Anum_pg_class_reloftype,
                BTEqualStrategyNumber, F_OIDEQ,
                ObjectIdGetDatum(typeOid));
 
    scan = table_beginscan_catalog(classRel, 1, key);
 
    while ((tuple = heap_getnext(scan, ForwardScanDirection)) != NULL)
    {
        Form_pg_class classform = (Form_pg_class) GETSTRUCT(tuple);
 
        if (behavior == DROP_RESTRICT)
            ereport(ERROR,
                    (errcode(ERRCODE_DEPENDENT_OBJECTS_STILL_EXIST),
                     errmsg("cannot alter type \"%s\" because it is the type of a typed table",
                            typeName),
                     errhint("Use ALTER ... CASCADE to alter the typed tables too.")));
        else
            result = lappend_oid(result, classform->oid);
    }
 
    table_endscan(scan);
    table_close(classRel, AccessShareLock);
 
    return result;
}

References AccessShareLock, BTEqualStrategyNumber, DROP_RESTRICT, ereport, errcode(), errhint(), errmsg(), ERROR, ForwardScanDirection, GETSTRUCT, heap_getnext(), sort-test::key, lappend_oid(), NIL, ObjectIdGetDatum(), ScanKeyInit(), table_beginscan_catalog(), table_close(), table_endscan(), and table_open().

Referenced by ATTypedTableRecursion(), and renameatt_internal().

findAttrByName()

static int findAttrByName ( const char *  attributeName, const List *  columns  )

static

Definition at line 3558 of file tablecmds.c.

{
    ListCell   *lc;
    int         i = 1;
 
    foreach(lc, columns)
    {
        if (strcmp(attributeName, lfirst_node(ColumnDef, lc)->colname) == 0)
            return i;
 
        i++;
    }
    return 0;
}

References i, and lfirst_node.

Referenced by MergeAttributes().

findFkeyCast()

static CoercionPathType findFkeyCast ( Oid  targetTypeId, Oid  sourceTypeId, Oid *  funcid  )

static

Definition at line 12495 of file tablecmds.c.

{
    CoercionPathType ret;
 
    if (targetTypeId == sourceTypeId)
    {
        ret = COERCION_PATH_RELABELTYPE;
        *funcid = InvalidOid;
    }
    else
    {
        ret = find_coercion_pathway(targetTypeId, sourceTypeId,
                                    COERCION_IMPLICIT, funcid);
        if (ret == COERCION_PATH_NONE)
            /* A previously-relied-upon cast is now gone. */
            elog(ERROR, "could not find cast from %u to %u",
                 sourceTypeId, targetTypeId);
    }
 
    return ret;
}

References COERCION_IMPLICIT, COERCION_PATH_NONE, COERCION_PATH_RELABELTYPE, elog, ERROR, find_coercion_pathway(), and InvalidOid.

Referenced by ATAddForeignKeyConstraint().

GetAttributeCompression()

static char GetAttributeCompression ( Oid  atttypid, const char *  compression  )

static

Definition at line 20863 of file tablecmds.c.

{
    char        cmethod;
 
    if (compression == NULL || strcmp(compression, "default") == 0)
        return InvalidCompressionMethod;
 
    /*
     * To specify a nondefault method, the column data type must be toastable.
     * Note this says nothing about whether the column's attstorage setting
     * permits compression; we intentionally allow attstorage and
     * attcompression to be independent.  But with a non-toastable type,
     * attstorage could not be set to a value that would permit compression.
     *
     * We don't actually need to enforce this, since nothing bad would happen
     * if attcompression were non-default; it would never be consulted.  But
     * it seems more user-friendly to complain about a certainly-useless
     * attempt to set the property.
     */
    if (!TypeIsToastable(atttypid))
        ereport(ERROR,
                (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                 errmsg("column data type %s does not support compression",
                        format_type_be(atttypid))));
 
    cmethod = CompressionNameToMethod(compression);
    if (!CompressionMethodIsValid(cmethod))
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                 errmsg("invalid compression method \"%s\"", compression)));
 
    return cmethod;
}

References CompressionMethodIsValid, CompressionNameToMethod(), ereport, errcode(), errmsg(), ERROR, format_type_be(), InvalidCompressionMethod, and TypeIsToastable.

Referenced by ATExecSetCompression(), and BuildDescForRelation().

GetAttributeStorage()

static char GetAttributeStorage ( Oid  atttypid, const char *  storagemode  )

static

Definition at line 20901 of file tablecmds.c.

{
    char        cstorage = 0;
 
    if (pg_strcasecmp(storagemode, "plain") == 0)
        cstorage = TYPSTORAGE_PLAIN;
    else if (pg_strcasecmp(storagemode, "external") == 0)
        cstorage = TYPSTORAGE_EXTERNAL;
    else if (pg_strcasecmp(storagemode, "extended") == 0)
        cstorage = TYPSTORAGE_EXTENDED;
    else if (pg_strcasecmp(storagemode, "main") == 0)
        cstorage = TYPSTORAGE_MAIN;
    else if (pg_strcasecmp(storagemode, "default") == 0)
        cstorage = get_typstorage(atttypid);
    else
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                 errmsg("invalid storage type \"%s\"",
                        storagemode)));
 
    /*
     * safety check: do not allow toasted storage modes unless column datatype
     * is TOAST-aware.
     */
    if (!(cstorage == TYPSTORAGE_PLAIN || TypeIsToastable(atttypid)))
        ereport(ERROR,
                (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                 errmsg("column data type %s can only have storage PLAIN",
                        format_type_be(atttypid))));
 
    return cstorage;
}

References ereport, errcode(), errmsg(), ERROR, format_type_be(), get_typstorage(), pg_strcasecmp(), and TypeIsToastable.

Referenced by ATExecSetStorage(), and BuildDescForRelation().

GetForeignKeyActionTriggers()

static void GetForeignKeyActionTriggers ( Relation  trigrel, Oid  conoid, Oid  confrelid, Oid  conrelid, Oid *  deleteTriggerOid, Oid *  updateTriggerOid  )

static

Definition at line 11585 of file tablecmds.c.

{
    ScanKeyData key;
    SysScanDesc scan;
    HeapTuple   trigtup;
 
    *deleteTriggerOid = *updateTriggerOid = InvalidOid;
    ScanKeyInit(&key,
                Anum_pg_trigger_tgconstraint,
                BTEqualStrategyNumber, F_OIDEQ,
                ObjectIdGetDatum(conoid));
 
    scan = systable_beginscan(trigrel, TriggerConstraintIndexId, true,
                              NULL, 1, &key);
    while ((trigtup = systable_getnext(scan)) != NULL)
    {
        Form_pg_trigger trgform = (Form_pg_trigger) GETSTRUCT(trigtup);
 
        if (trgform->tgconstrrelid != conrelid)
            continue;
        if (trgform->tgrelid != confrelid)
            continue;
        /* Only ever look at "action" triggers on the PK side. */
        if (RI_FKey_trigger_type(trgform->tgfoid) != RI_TRIGGER_PK)
            continue;
        if (TRIGGER_FOR_DELETE(trgform->tgtype))
        {
            Assert(*deleteTriggerOid == InvalidOid);
            *deleteTriggerOid = trgform->oid;
        }
        else if (TRIGGER_FOR_UPDATE(trgform->tgtype))
        {
            Assert(*updateTriggerOid == InvalidOid);
            *updateTriggerOid = trgform->oid;
        }
#ifndef USE_ASSERT_CHECKING
        /* In an assert-enabled build, continue looking to find duplicates */
        if (OidIsValid(*deleteTriggerOid) && OidIsValid(*updateTriggerOid))
            break;
#endif
    }
 
    if (!OidIsValid(*deleteTriggerOid))
        elog(ERROR, "could not find ON DELETE action trigger of foreign key constraint %u",
             conoid);
    if (!OidIsValid(*updateTriggerOid))
        elog(ERROR, "could not find ON UPDATE action trigger of foreign key constraint %u",
             conoid);
 
    systable_endscan(scan);
}

References Assert, BTEqualStrategyNumber, elog, ERROR, GETSTRUCT, InvalidOid, sort-test::key, ObjectIdGetDatum(), OidIsValid, RI_FKey_trigger_type(), RI_TRIGGER_PK, ScanKeyInit(), systable_beginscan(), systable_endscan(), and systable_getnext().

Referenced by CloneFkReferenced().

GetForeignKeyCheckTriggers()

static void GetForeignKeyCheckTriggers ( Relation  trigrel, Oid  conoid, Oid  confrelid, Oid  conrelid, Oid *  insertTriggerOid, Oid *  updateTriggerOid  )

static

Definition at line 11646 of file tablecmds.c.

{
    ScanKeyData key;
    SysScanDesc scan;
    HeapTuple   trigtup;
 
    *insertTriggerOid = *updateTriggerOid = InvalidOid;
    ScanKeyInit(&key,
                Anum_pg_trigger_tgconstraint,
                BTEqualStrategyNumber, F_OIDEQ,
                ObjectIdGetDatum(conoid));
 
    scan = systable_beginscan(trigrel, TriggerConstraintIndexId, true,
                              NULL, 1, &key);
    while ((trigtup = systable_getnext(scan)) != NULL)
    {
        Form_pg_trigger trgform = (Form_pg_trigger) GETSTRUCT(trigtup);
 
        if (trgform->tgconstrrelid != confrelid)
            continue;
        if (trgform->tgrelid != conrelid)
            continue;
        /* Only ever look at "check" triggers on the FK side. */
        if (RI_FKey_trigger_type(trgform->tgfoid) != RI_TRIGGER_FK)
            continue;
        if (TRIGGER_FOR_INSERT(trgform->tgtype))
        {
            Assert(*insertTriggerOid == InvalidOid);
            *insertTriggerOid = trgform->oid;
        }
        else if (TRIGGER_FOR_UPDATE(trgform->tgtype))
        {
            Assert(*updateTriggerOid == InvalidOid);
            *updateTriggerOid = trgform->oid;
        }
#ifndef USE_ASSERT_CHECKING
        /* In an assert-enabled build, continue looking to find duplicates. */
        if (OidIsValid(*insertTriggerOid) && OidIsValid(*updateTriggerOid))
            break;
#endif
    }
 
    if (!OidIsValid(*insertTriggerOid))
        elog(ERROR, "could not find ON INSERT check triggers of foreign key constraint %u",
             conoid);
    if (!OidIsValid(*updateTriggerOid))
        elog(ERROR, "could not find ON UPDATE check triggers of foreign key constraint %u",
             conoid);
 
    systable_endscan(scan);
}

References Assert, BTEqualStrategyNumber, elog, ERROR, GETSTRUCT, InvalidOid, sort-test::key, ObjectIdGetDatum(), OidIsValid, RI_FKey_trigger_type(), RI_TRIGGER_FK, ScanKeyInit(), systable_beginscan(), systable_endscan(), and systable_getnext().

Referenced by CloneFkReferencing(), DetachPartitionFinalize(), and tryAttachPartitionForeignKey().

GetParentedForeignKeyRefs()

static List * GetParentedForeignKeyRefs ( Relation  partition )

static

Definition at line 20761 of file tablecmds.c.

{
    Relation    pg_constraint;
    HeapTuple   tuple;
    SysScanDesc scan;
    ScanKeyData key[2];
    List       *constraints = NIL;
 
    /*
     * If no indexes, or no columns are referenceable by FKs, we can avoid the
     * scan.
     */
    if (RelationGetIndexList(partition) == NIL ||
        bms_is_empty(RelationGetIndexAttrBitmap(partition,
                                                INDEX_ATTR_BITMAP_KEY)))
        return NIL;
 
    /* Search for constraints referencing this table */
    pg_constraint = table_open(ConstraintRelationId, AccessShareLock);
    ScanKeyInit(&key[0],
                Anum_pg_constraint_confrelid, BTEqualStrategyNumber,
                F_OIDEQ, ObjectIdGetDatum(RelationGetRelid(partition)));
    ScanKeyInit(&key[1],
                Anum_pg_constraint_contype, BTEqualStrategyNumber,
                F_CHAREQ, CharGetDatum(CONSTRAINT_FOREIGN));
 
    /* XXX This is a seqscan, as we don't have a usable index */
    scan = systable_beginscan(pg_constraint, InvalidOid, true, NULL, 2, key);
    while ((tuple = systable_getnext(scan)) != NULL)
    {
        Form_pg_constraint constrForm = (Form_pg_constraint) GETSTRUCT(tuple);
 
        /*
         * We only need to process constraints that are part of larger ones.
         */
        if (!OidIsValid(constrForm->conparentid))
            continue;
 
        constraints = lappend_oid(constraints, constrForm->oid);
    }
 
    systable_endscan(scan);
    table_close(pg_constraint, AccessShareLock);
 
    return constraints;
}

References AccessShareLock, bms_is_empty, BTEqualStrategyNumber, CharGetDatum(), GETSTRUCT, INDEX_ATTR_BITMAP_KEY, InvalidOid, sort-test::key, lappend_oid(), NIL, ObjectIdGetDatum(), OidIsValid, RelationGetIndexAttrBitmap(), RelationGetIndexList(), RelationGetRelid, ScanKeyInit(), systable_beginscan(), systable_endscan(), systable_getnext(), table_close(), and table_open().

Referenced by ATDetachCheckNoForeignKeyRefs(), and DetachPartitionFinalize().

index_copy_data()

static void index_copy_data ( Relation  rel, RelFileLocator  newrlocator  )

static

Definition at line 16052 of file tablecmds.c.

{
    SMgrRelation dstrel;
 
    /*
     * Since we copy the file directly without looking at the shared buffers,
     * we'd better first flush out any pages of the source relation that are
     * in shared buffers.  We assume no new changes will be made while we are
     * holding exclusive lock on the rel.
     */
    FlushRelationBuffers(rel);
 
    /*
     * Create and copy all forks of the relation, and schedule unlinking of
     * old physical files.
     *
     * NOTE: any conflict in relfilenumber value will be caught in
     * RelationCreateStorage().
     */
    dstrel = RelationCreateStorage(newrlocator, rel->rd_rel->relpersistence, true);
 
    /* copy main fork */
    RelationCopyStorage(RelationGetSmgr(rel), dstrel, MAIN_FORKNUM,
                        rel->rd_rel->relpersistence);
 
    /* copy those extra forks that exist */
    for (ForkNumber forkNum = MAIN_FORKNUM + 1;
         forkNum <= MAX_FORKNUM; forkNum++)
    {
        if (smgrexists(RelationGetSmgr(rel), forkNum))
        {
            smgrcreate(dstrel, forkNum, false);
 
            /*
             * WAL log creation if the relation is persistent, or this is the
             * init fork of an unlogged relation.
             */
            if (RelationIsPermanent(rel) ||
                (rel->rd_rel->relpersistence == RELPERSISTENCE_UNLOGGED &&
                 forkNum == INIT_FORKNUM))
                log_smgrcreate(&newrlocator, forkNum);
            RelationCopyStorage(RelationGetSmgr(rel), dstrel, forkNum,
                                rel->rd_rel->relpersistence);
        }
    }
 
    /* drop old relation, and close new one */
    RelationDropStorage(rel);
    smgrclose(dstrel);
}

References FlushRelationBuffers(), INIT_FORKNUM, log_smgrcreate(), MAIN_FORKNUM, MAX_FORKNUM, RelationData::rd_rel, RelationCopyStorage(), RelationCreateStorage(), RelationDropStorage(), RelationGetSmgr(), RelationIsPermanent, smgrclose(), smgrcreate(), and smgrexists().

Referenced by ATExecSetTableSpace().

MarkInheritDetached()

static void MarkInheritDetached ( Relation  child_rel, Relation  parent_rel  )

static

Definition at line 16778 of file tablecmds.c.

{
    Relation    catalogRelation;
    SysScanDesc scan;
    ScanKeyData key;
    HeapTuple   inheritsTuple;
    bool        found = false;
 
    Assert(parent_rel->rd_rel->relkind == RELKIND_PARTITIONED_TABLE);
 
    /*
     * Find pg_inherits entries by inhparent.  (We need to scan them all in
     * order to verify that no other partition is pending detach.)
     */
    catalogRelation = table_open(InheritsRelationId, RowExclusiveLock);
    ScanKeyInit(&key,
                Anum_pg_inherits_inhparent,
                BTEqualStrategyNumber, F_OIDEQ,
                ObjectIdGetDatum(RelationGetRelid(parent_rel)));
    scan = systable_beginscan(catalogRelation, InheritsParentIndexId,
                              true, NULL, 1, &key);
 
    while (HeapTupleIsValid(inheritsTuple = systable_getnext(scan)))
    {
        Form_pg_inherits inhForm;
 
        inhForm = (Form_pg_inherits) GETSTRUCT(inheritsTuple);
        if (inhForm->inhdetachpending)
            ereport(ERROR,
                    errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
                    errmsg("partition \"%s\" already pending detach in partitioned table \"%s.%s\"",
                           get_rel_name(inhForm->inhrelid),
                           get_namespace_name(parent_rel->rd_rel->relnamespace),
                           RelationGetRelationName(parent_rel)),
                    errhint("Use ALTER TABLE ... DETACH PARTITION ... FINALIZE to complete the pending detach operation."));
 
        if (inhForm->inhrelid == RelationGetRelid(child_rel))
        {
            HeapTuple   newtup;
 
            newtup = heap_copytuple(inheritsTuple);
            ((Form_pg_inherits) GETSTRUCT(newtup))->inhdetachpending = true;
 
            CatalogTupleUpdate(catalogRelation,
                               &inheritsTuple->t_self,
                               newtup);
            found = true;
            heap_freetuple(newtup);
            /* keep looking, to ensure we catch others pending detach */
        }
    }
 
    /* Done */
    systable_endscan(scan);
    table_close(catalogRelation, RowExclusiveLock);
 
    if (!found)
        ereport(ERROR,
                (errcode(ERRCODE_UNDEFINED_TABLE),
                 errmsg("relation \"%s\" is not a partition of relation \"%s\"",
                        RelationGetRelationName(child_rel),
                        RelationGetRelationName(parent_rel))));
}

References Assert, BTEqualStrategyNumber, CatalogTupleUpdate(), ereport, errcode(), ERRCODE_UNDEFINED_TABLE, errhint(), errmsg(), ERROR, get_namespace_name(), get_rel_name(), GETSTRUCT, heap_copytuple(), heap_freetuple(), HeapTupleIsValid, sort-test::key, ObjectIdGetDatum(), RelationData::rd_rel, RelationGetRelationName, RelationGetRelid, RowExclusiveLock, ScanKeyInit(), systable_beginscan(), systable_endscan(), systable_getnext(), HeapTupleData::t_self, table_close(), and table_open().

Referenced by ATExecDetachPartition().

MergeAttributes()

static List * MergeAttributes ( List *  columns, const List *  supers, char  relpersistence, bool  is_partition, List **  supconstr, List **  supnotnulls  )

static

Definition at line 2491 of file tablecmds.c.

{
    List       *inh_columns = NIL;
    List       *constraints = NIL;
    List       *nnconstraints = NIL;
    bool        have_bogus_defaults = false;
    int         child_attno;
    static Node bogus_marker = {0}; /* marks conflicting defaults */
    List       *saved_columns = NIL;
    ListCell   *lc;
 
    /*
     * Check for and reject tables with too many columns. We perform this
     * check relatively early for two reasons: (a) we don't run the risk of
     * overflowing an AttrNumber in subsequent code (b) an O(n^2) algorithm is
     * okay if we're processing <= 1600 columns, but could take minutes to
     * execute if the user attempts to create a table with hundreds of
     * thousands of columns.
     *
     * Note that we also need to check that we do not exceed this figure after
     * including columns from inherited relations.
     */
    if (list_length(columns) > MaxHeapAttributeNumber)
        ereport(ERROR,
                (errcode(ERRCODE_TOO_MANY_COLUMNS),
                 errmsg("tables can have at most %d columns",
                        MaxHeapAttributeNumber)));
 
    /*
     * Check for duplicate names in the explicit list of attributes.
     *
     * Although we might consider merging such entries in the same way that we
     * handle name conflicts for inherited attributes, it seems to make more
     * sense to assume such conflicts are errors.
     *
     * We don't use foreach() here because we have two nested loops over the
     * columns list, with possible element deletions in the inner one.  If we
     * used foreach_delete_current() it could only fix up the state of one of
     * the loops, so it seems cleaner to use looping over list indexes for
     * both loops.  Note that any deletion will happen beyond where the outer
     * loop is, so its index never needs adjustment.
     */
    for (int coldefpos = 0; coldefpos < list_length(columns); coldefpos++)
    {
        ColumnDef  *coldef = list_nth_node(ColumnDef, columns, coldefpos);
 
        if (!is_partition && coldef->typeName == NULL)
        {
            /*
             * Typed table column option that does not belong to a column from
             * the type.  This works because the columns from the type come
             * first in the list.  (We omit this check for partition column
             * lists; those are processed separately below.)
             */
            ereport(ERROR,
                    (errcode(ERRCODE_UNDEFINED_COLUMN),
                     errmsg("column \"%s\" does not exist",
                            coldef->colname)));
        }
 
        /* restpos scans all entries beyond coldef; incr is in loop body */
        for (int restpos = coldefpos + 1; restpos < list_length(columns);)
        {
            ColumnDef  *restdef = list_nth_node(ColumnDef, columns, restpos);
 
            if (strcmp(coldef->colname, restdef->colname) == 0)
            {
                if (coldef->is_from_type)
                {
                    /*
                     * merge the column options into the column from the type
                     */
                    coldef->is_not_null = restdef->is_not_null;
                    coldef->raw_default = restdef->raw_default;
                    coldef->cooked_default = restdef->cooked_default;
                    coldef->constraints = restdef->constraints;
                    coldef->is_from_type = false;
                    columns = list_delete_nth_cell(columns, restpos);
                }
                else
                    ereport(ERROR,
                            (errcode(ERRCODE_DUPLICATE_COLUMN),
                             errmsg("column \"%s\" specified more than once",
                                    coldef->colname)));
            }
            else
                restpos++;
        }
    }
 
    /*
     * In case of a partition, there are no new column definitions, only dummy
     * ColumnDefs created for column constraints.  Set them aside for now and
     * process them at the end.
     */
    if (is_partition)
    {
        saved_columns = columns;
        columns = NIL;
    }
 
    /*
     * Scan the parents left-to-right, and merge their attributes to form a
     * list of inherited columns (inh_columns).
     */
    child_attno = 0;
    foreach(lc, supers)
    {
        Oid         parent = lfirst_oid(lc);
        Relation    relation;
        TupleDesc   tupleDesc;
        TupleConstr *constr;
        AttrMap    *newattmap;
        List       *inherited_defaults;
        List       *cols_with_defaults;
        List       *nnconstrs;
        ListCell   *lc1;
        ListCell   *lc2;
        Bitmapset  *pkattrs;
        Bitmapset  *nncols = NULL;
 
        /* caller already got lock */
        relation = table_open(parent, NoLock);
 
        /*
         * Check for active uses of the parent partitioned table in the
         * current transaction, such as being used in some manner by an
         * enclosing command.
         */
        if (is_partition)
            CheckTableNotInUse(relation, "CREATE TABLE .. PARTITION OF");
 
        /*
         * We do not allow partitioned tables and partitions to participate in
         * regular inheritance.
         */
        if (relation->rd_rel->relkind == RELKIND_PARTITIONED_TABLE && !is_partition)
            ereport(ERROR,
                    (errcode(ERRCODE_WRONG_OBJECT_TYPE),
                     errmsg("cannot inherit from partitioned table \"%s\"",
                            RelationGetRelationName(relation))));
        if (relation->rd_rel->relispartition && !is_partition)
            ereport(ERROR,
                    (errcode(ERRCODE_WRONG_OBJECT_TYPE),
                     errmsg("cannot inherit from partition \"%s\"",
                            RelationGetRelationName(relation))));
 
        if (relation->rd_rel->relkind != RELKIND_RELATION &&
            relation->rd_rel->relkind != RELKIND_FOREIGN_TABLE &&
            relation->rd_rel->relkind != RELKIND_PARTITIONED_TABLE)
            ereport(ERROR,
                    (errcode(ERRCODE_WRONG_OBJECT_TYPE),
                     errmsg("inherited relation \"%s\" is not a table or foreign table",
                            RelationGetRelationName(relation))));
 
        /*
         * If the parent is permanent, so must be all of its partitions.  Note
         * that inheritance allows that case.
         */
        if (is_partition &&
            relation->rd_rel->relpersistence != RELPERSISTENCE_TEMP &&
            relpersistence == RELPERSISTENCE_TEMP)
            ereport(ERROR,
                    (errcode(ERRCODE_WRONG_OBJECT_TYPE),
                     errmsg("cannot create a temporary relation as partition of permanent relation \"%s\"",
                            RelationGetRelationName(relation))));
 
        /* Permanent rels cannot inherit from temporary ones */
        if (relpersistence != RELPERSISTENCE_TEMP &&
            relation->rd_rel->relpersistence == RELPERSISTENCE_TEMP)
            ereport(ERROR,
                    (errcode(ERRCODE_WRONG_OBJECT_TYPE),
                     errmsg(!is_partition
                            ? "cannot inherit from temporary relation \"%s\""
                            : "cannot create a permanent relation as partition of temporary relation \"%s\"",
                            RelationGetRelationName(relation))));
 
        /* If existing rel is temp, it must belong to this session */
        if (relation->rd_rel->relpersistence == RELPERSISTENCE_TEMP &&
            !relation->rd_islocaltemp)
            ereport(ERROR,
                    (errcode(ERRCODE_WRONG_OBJECT_TYPE),
                     errmsg(!is_partition
                            ? "cannot inherit from temporary relation of another session"
                            : "cannot create as partition of temporary relation of another session")));
 
        /*
         * We should have an UNDER permission flag for this, but for now,
         * demand that creator of a child table own the parent.
         */
        if (!object_ownercheck(RelationRelationId, RelationGetRelid(relation), GetUserId()))
            aclcheck_error(ACLCHECK_NOT_OWNER, get_relkind_objtype(relation->rd_rel->relkind),
                           RelationGetRelationName(relation));
 
        tupleDesc = RelationGetDescr(relation);
        constr = tupleDesc->constr;
 
        /*
         * newattmap->attnums[] will contain the child-table attribute numbers
         * for the attributes of this parent table.  (They are not the same
         * for parents after the first one, nor if we have dropped columns.)
         */
        newattmap = make_attrmap(tupleDesc->natts);
 
        /* We can't process inherited defaults until newattmap is complete. */
        inherited_defaults = cols_with_defaults = NIL;
 
        /*
         * All columns that are part of the parent's primary key need to be
         * NOT NULL; if partition just the attnotnull bit, otherwise a full
         * constraint (if they don't have one already).  Also, we request
         * attnotnull on columns that have a not-null constraint that's not
         * marked NO INHERIT.
         */
        pkattrs = RelationGetIndexAttrBitmap(relation,
                                             INDEX_ATTR_BITMAP_PRIMARY_KEY);
        nnconstrs = RelationGetNotNullConstraints(RelationGetRelid(relation), true);
        foreach(lc1, nnconstrs)
            nncols = bms_add_member(nncols,
                                    ((CookedConstraint *) lfirst(lc1))->attnum);
 
        for (AttrNumber parent_attno = 1; parent_attno <= tupleDesc->natts;
             parent_attno++)
        {
            Form_pg_attribute attribute = TupleDescAttr(tupleDesc,
                                                        parent_attno - 1);
            char       *attributeName = NameStr(attribute->attname);
            int         exist_attno;
            ColumnDef  *newdef;
            ColumnDef  *mergeddef;
 
            /*
             * Ignore dropped columns in the parent.
             */
            if (attribute->attisdropped)
                continue;       /* leave newattmap->attnums entry as zero */
 
            /*
             * Create new column definition
             */
            newdef = makeColumnDef(attributeName, attribute->atttypid,
                                   attribute->atttypmod, attribute->attcollation);
            newdef->storage = attribute->attstorage;
            newdef->generated = attribute->attgenerated;
            if (CompressionMethodIsValid(attribute->attcompression))
                newdef->compression =
                    pstrdup(GetCompressionMethodName(attribute->attcompression));
 
            /*
             * Regular inheritance children are independent enough not to
             * inherit identity columns.  But partitions are integral part of
             * a partitioned table and inherit identity column.
             */
            if (is_partition)
                newdef->identity = attribute->attidentity;
 
            /*
             * Does it match some previously considered column from another
             * parent?
             */
            exist_attno = findAttrByName(attributeName, inh_columns);
            if (exist_attno > 0)
            {
                /*
                 * Yes, try to merge the two column definitions.
                 */
                mergeddef = MergeInheritedAttribute(inh_columns, exist_attno, newdef);
 
                newattmap->attnums[parent_attno - 1] = exist_attno;
 
                /*
                 * Partitions have only one parent, so conflict should never
                 * occur.
                 */
                Assert(!is_partition);
            }
            else
            {
                /*
                 * No, create a new inherited column
                 */
                newdef->inhcount = 1;
                newdef->is_local = false;
                inh_columns = lappend(inh_columns, newdef);
 
                newattmap->attnums[parent_attno - 1] = ++child_attno;
 
                mergeddef = newdef;
            }
 
            /*
             * mark attnotnull if parent has it and it's not NO INHERIT
             */
            if (bms_is_member(parent_attno, nncols) ||
                bms_is_member(parent_attno - FirstLowInvalidHeapAttributeNumber,
                              pkattrs))
                mergeddef->is_not_null = true;
 
            /*
             * In regular inheritance, columns in the parent's primary key get
             * an extra not-null constraint.  Partitioning doesn't need this,
             * because the PK itself is going to be cloned to the partition.
             */
            if (!is_partition &&
                bms_is_member(parent_attno -
                              FirstLowInvalidHeapAttributeNumber,
                              pkattrs))
            {
                CookedConstraint *nn;
 
                nn = palloc(sizeof(CookedConstraint));
                nn->contype = CONSTR_NOTNULL;
                nn->conoid = InvalidOid;
                nn->name = NULL;
                nn->attnum = newattmap->attnums[parent_attno - 1];
                nn->expr = NULL;
                nn->skip_validation = false;
                nn->is_local = false;
                nn->inhcount = 1;
                nn->is_no_inherit = false;
 
                nnconstraints = lappend(nnconstraints, nn);
            }
 
            /*
             * Locate default/generation expression if any
             */
            if (attribute->atthasdef)
            {
                Node       *this_default;
 
                this_default = TupleDescGetDefault(tupleDesc, parent_attno);
                if (this_default == NULL)
                    elog(ERROR, "default expression not found for attribute %d of relation \"%s\"",
                         parent_attno, RelationGetRelationName(relation));
 
                /*
                 * If it's a GENERATED default, it might contain Vars that
                 * need to be mapped to the inherited column(s)' new numbers.
                 * We can't do that till newattmap is ready, so just remember
                 * all the inherited default expressions for the moment.
                 */
                inherited_defaults = lappend(inherited_defaults, this_default);
                cols_with_defaults = lappend(cols_with_defaults, mergeddef);
            }
        }
 
        /*
         * Now process any inherited default expressions, adjusting attnos
         * using the completed newattmap map.
         */
        forboth(lc1, inherited_defaults, lc2, cols_with_defaults)
        {
            Node       *this_default = (Node *) lfirst(lc1);
            ColumnDef  *def = (ColumnDef *) lfirst(lc2);
            bool        found_whole_row;
 
            /* Adjust Vars to match new table's column numbering */
            this_default = map_variable_attnos(this_default,
                                               1, 0,
                                               newattmap,
                                               InvalidOid, &found_whole_row);
 
            /*
             * For the moment we have to reject whole-row variables.  We could
             * convert them, if we knew the new table's rowtype OID, but that
             * hasn't been assigned yet.  (A variable could only appear in a
             * generation expression, so the error message is correct.)
             */
            if (found_whole_row)
                ereport(ERROR,
                        (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                         errmsg("cannot convert whole-row table reference"),
                         errdetail("Generation expression for column \"%s\" contains a whole-row reference to table \"%s\".",
                                   def->colname,
                                   RelationGetRelationName(relation))));
 
            /*
             * If we already had a default from some prior parent, check to
             * see if they are the same.  If so, no problem; if not, mark the
             * column as having a bogus default.  Below, we will complain if
             * the bogus default isn't overridden by the child columns.
             */
            Assert(def->raw_default == NULL);
            if (def->cooked_default == NULL)
                def->cooked_default = this_default;
            else if (!equal(def->cooked_default, this_default))
            {
                def->cooked_default = &bogus_marker;
                have_bogus_defaults = true;
            }
        }
 
        /*
         * Now copy the CHECK constraints of this parent, adjusting attnos
         * using the completed newattmap map.  Identically named constraints
         * are merged if possible, else we throw error.
         */
        if (constr && constr->num_check > 0)
        {
            ConstrCheck *check = constr->check;
 
            for (int i = 0; i < constr->num_check; i++)
            {
                char       *name = check[i].ccname;
                Node       *expr;
                bool        found_whole_row;
 
                /* ignore if the constraint is non-inheritable */
                if (check[i].ccnoinherit)
                    continue;
 
                /* Adjust Vars to match new table's column numbering */
                expr = map_variable_attnos(stringToNode(check[i].ccbin),
                                           1, 0,
                                           newattmap,
                                           InvalidOid, &found_whole_row);
 
                /*
                 * For the moment we have to reject whole-row variables. We
                 * could convert them, if we knew the new table's rowtype OID,
                 * but that hasn't been assigned yet.
                 */
                if (found_whole_row)
                    ereport(ERROR,
                            (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                             errmsg("cannot convert whole-row table reference"),
                             errdetail("Constraint \"%s\" contains a whole-row reference to table \"%s\".",
                                       name,
                                       RelationGetRelationName(relation))));
 
                constraints = MergeCheckConstraint(constraints, name, expr);
            }
        }
 
        /*
         * Also copy the not-null constraints from this parent.  The
         * attnotnull markings were already installed above.
         */
        foreach(lc1, nnconstrs)
        {
            CookedConstraint *nn = lfirst(lc1);
 
            Assert(nn->contype == CONSTR_NOTNULL);
 
            nn->attnum = newattmap->attnums[nn->attnum - 1];
            nn->is_local = false;
            nn->inhcount = 1;
 
            nnconstraints = lappend(nnconstraints, nn);
        }
 
        free_attrmap(newattmap);
 
        /*
         * Close the parent rel, but keep our lock on it until xact commit.
         * That will prevent someone else from deleting or ALTERing the parent
         * before the child is committed.
         */
        table_close(relation, NoLock);
    }
 
    /*
     * If we had no inherited attributes, the result columns are just the
     * explicitly declared columns.  Otherwise, we need to merge the declared
     * columns into the inherited column list.  Although, we never have any
     * explicitly declared columns if the table is a partition.
     */
    if (inh_columns != NIL)
    {
        int         newcol_attno = 0;
 
        foreach(lc, columns)
        {
            ColumnDef  *newdef = lfirst_node(ColumnDef, lc);
            char       *attributeName = newdef->colname;
            int         exist_attno;
 
            /*
             * Partitions have only one parent and have no column definitions
             * of their own, so conflict should never occur.
             */
            Assert(!is_partition);
 
            newcol_attno++;
 
            /*
             * Does it match some inherited column?
             */
            exist_attno = findAttrByName(attributeName, inh_columns);
            if (exist_attno > 0)
            {
                /*
                 * Yes, try to merge the two column definitions.
                 */
                MergeChildAttribute(inh_columns, exist_attno, newcol_attno, newdef);
            }
            else
            {
                /*
                 * No, attach new column unchanged to result columns.
                 */
                inh_columns = lappend(inh_columns, newdef);
            }
        }
 
        columns = inh_columns;
 
        /*
         * Check that we haven't exceeded the legal # of columns after merging
         * in inherited columns.
         */
        if (list_length(columns) > MaxHeapAttributeNumber)
            ereport(ERROR,
                    (errcode(ERRCODE_TOO_MANY_COLUMNS),
                     errmsg("tables can have at most %d columns",
                            MaxHeapAttributeNumber)));
    }
 
    /*
     * Now that we have the column definition list for a partition, we can
     * check whether the columns referenced in the column constraint specs
     * actually exist.  Also, merge column defaults.
     */
    if (is_partition)
    {
        foreach(lc, saved_columns)
        {
            ColumnDef  *restdef = lfirst(lc);
            bool        found = false;
            ListCell   *l;
 
            foreach(l, columns)
            {
                ColumnDef  *coldef = lfirst(l);
 
                if (strcmp(coldef->colname, restdef->colname) == 0)
                {
                    found = true;
 
                    /*
                     * Check for conflicts related to generated columns.
                     *
                     * Same rules as above: generated-ness has to match the
                     * parent, but the contents of the generation expression
                     * can be different.
                     */
                    if (coldef->generated)
                    {
                        if (restdef->raw_default && !restdef->generated)
                            ereport(ERROR,
                                    (errcode(ERRCODE_INVALID_COLUMN_DEFINITION),
                                     errmsg("column \"%s\" inherits from generated column but specifies default",
                                            restdef->colname)));
                        if (restdef->identity)
                            ereport(ERROR,
                                    (errcode(ERRCODE_INVALID_COLUMN_DEFINITION),
                                     errmsg("column \"%s\" inherits from generated column but specifies identity",
                                            restdef->colname)));
                    }
                    else
                    {
                        if (restdef->generated)
                            ereport(ERROR,
                                    (errcode(ERRCODE_INVALID_COLUMN_DEFINITION),
                                     errmsg("child column \"%s\" specifies generation expression",
                                            restdef->colname),
                                     errhint("A child table column cannot be generated unless its parent column is.")));
                    }
 
                    /*
                     * Override the parent's default value for this column
                     * (coldef->cooked_default) with the partition's local
                     * definition (restdef->raw_default), if there's one. It
                     * should be physically impossible to get a cooked default
                     * in the local definition or a raw default in the
                     * inherited definition, but make sure they're nulls, for
                     * future-proofing.
                     */
                    Assert(restdef->cooked_default == NULL);
                    Assert(coldef->raw_default == NULL);
                    if (restdef->raw_default)
                    {
                        coldef->raw_default = restdef->raw_default;
                        coldef->cooked_default = NULL;
                    }
                }
            }
 
            /* complain for constraints on columns not in parent */
            if (!found)
                ereport(ERROR,
                        (errcode(ERRCODE_UNDEFINED_COLUMN),
                         errmsg("column \"%s\" does not exist",
                                restdef->colname)));
        }
    }
 
    /*
     * If we found any conflicting parent default values, check to make sure
     * they were overridden by the child.
     */
    if (have_bogus_defaults)
    {
        foreach(lc, columns)
        {
            ColumnDef  *def = lfirst(lc);
 
            if (def->cooked_default == &bogus_marker)
            {
                if (def->generated)
                    ereport(ERROR,
                            (errcode(ERRCODE_INVALID_COLUMN_DEFINITION),
                             errmsg("column \"%s\" inherits conflicting generation expressions",
                                    def->colname),
                             errhint("To resolve the conflict, specify a generation expression explicitly.")));
                else
                    ereport(ERROR,
                            (errcode(ERRCODE_INVALID_COLUMN_DEFINITION),
                             errmsg("column \"%s\" inherits conflicting default values",
                                    def->colname),
                             errhint("To resolve the conflict, specify a default explicitly.")));
            }
        }
    }
 
    *supconstr = constraints;
    *supnotnulls = nnconstraints;
 
    return columns;
}

References aclcheck_error(), ACLCHECK_NOT_OWNER, Assert, CookedConstraint::attnum, attnum, AttrMap::attnums, bms_add_member(), bms_is_member(), ConstrCheck::ccname, TupleConstr::check, CheckTableNotInUse(), ColumnDef::colname, ColumnDef::compression, CompressionMethodIsValid, CookedConstraint::conoid, TupleDescData::constr, CONSTR_NOTNULL, ColumnDef::constraints, CookedConstraint::contype, ColumnDef::cooked_default, elog, equal(), ereport, errcode(), errdetail(), errhint(), errmsg(), ERROR, CookedConstraint::expr, findAttrByName(), FirstLowInvalidHeapAttributeNumber, forboth, free_attrmap(), ColumnDef::generated, get_relkind_objtype(), GetCompressionMethodName(), GetUserId(), i, ColumnDef::identity, INDEX_ATTR_BITMAP_PRIMARY_KEY, CookedConstraint::inhcount, ColumnDef::inhcount, InvalidOid, ColumnDef::is_from_type, CookedConstraint::is_local, ColumnDef::is_local, CookedConstraint::is_no_inherit, ColumnDef::is_not_null, lappend(), lfirst, lfirst_node, lfirst_oid, list_delete_nth_cell(), list_length(), list_nth_node, make_attrmap(), makeColumnDef(), map_variable_attnos(), MaxHeapAttributeNumber, MergeCheckConstraint(), MergeChildAttribute(), MergeInheritedAttribute(), name, CookedConstraint::name, NameStr, TupleDescData::natts, NIL, NoLock, TupleConstr::num_check, object_ownercheck(), palloc(), pstrdup(), ColumnDef::raw_default, RelationData::rd_islocaltemp, RelationData::rd_rel, RelationGetDescr, RelationGetIndexAttrBitmap(), RelationGetNotNullConstraints(), RelationGetRelationName, RelationGetRelid, CookedConstraint::skip_validation, ColumnDef::storage, stringToNode(), table_close(), table_open(), TupleDescAttr, TupleDescGetDefault(), and ColumnDef::typeName.

Referenced by DefineRelation().

MergeAttributesIntoExisting()

static void MergeAttributesIntoExisting ( Relation  child_rel, Relation  parent_rel, bool  ispartition  )

static

Definition at line 16408 of file tablecmds.c.

{
    Relation    attrrel;
    TupleDesc   parent_desc;
 
    attrrel = table_open(AttributeRelationId, RowExclusiveLock);
    parent_desc = RelationGetDescr(parent_rel);
 
    for (AttrNumber parent_attno = 1; parent_attno <= parent_desc->natts; parent_attno++)
    {
        Form_pg_attribute parent_att = TupleDescAttr(parent_desc, parent_attno - 1);
        char       *parent_attname = NameStr(parent_att->attname);
        HeapTuple   tuple;
 
        /* Ignore dropped columns in the parent. */
        if (parent_att->attisdropped)
            continue;
 
        /* Find same column in child (matching on column name). */
        tuple = SearchSysCacheCopyAttName(RelationGetRelid(child_rel), parent_attname);
        if (HeapTupleIsValid(tuple))
        {
            Form_pg_attribute child_att = (Form_pg_attribute) GETSTRUCT(tuple);
 
            if (parent_att->atttypid != child_att->atttypid ||
                parent_att->atttypmod != child_att->atttypmod)
                ereport(ERROR,
                        (errcode(ERRCODE_DATATYPE_MISMATCH),
                         errmsg("child table \"%s\" has different type for column \"%s\"",
                                RelationGetRelationName(child_rel), parent_attname)));
 
            if (parent_att->attcollation != child_att->attcollation)
                ereport(ERROR,
                        (errcode(ERRCODE_COLLATION_MISMATCH),
                         errmsg("child table \"%s\" has different collation for column \"%s\"",
                                RelationGetRelationName(child_rel), parent_attname)));
 
            /*
             * If the parent has a not-null constraint that's not NO INHERIT,
             * make sure the child has one too.
             *
             * Other constraints are checked elsewhere.
             */
            if (parent_att->attnotnull && !child_att->attnotnull)
            {
                HeapTuple   contup;
 
                contup = findNotNullConstraintAttnum(RelationGetRelid(parent_rel),
                                                     parent_att->attnum);
                if (HeapTupleIsValid(contup) &&
                    !((Form_pg_constraint) GETSTRUCT(contup))->connoinherit)
                    ereport(ERROR,
                            errcode(ERRCODE_DATATYPE_MISMATCH),
                            errmsg("column \"%s\" in child table must be marked NOT NULL",
                                   parent_attname));
            }
 
            /*
             * Child column must be generated if and only if parent column is.
             */
            if (parent_att->attgenerated && !child_att->attgenerated)
                ereport(ERROR,
                        (errcode(ERRCODE_DATATYPE_MISMATCH),
                         errmsg("column \"%s\" in child table must be a generated column", parent_attname)));
            if (child_att->attgenerated && !parent_att->attgenerated)
                ereport(ERROR,
                        (errcode(ERRCODE_DATATYPE_MISMATCH),
                         errmsg("column \"%s\" in child table must not be a generated column", parent_attname)));
 
            /*
             * Regular inheritance children are independent enough not to
             * inherit identity columns.  But partitions are integral part of
             * a partitioned table and inherit identity column.
             */
            if (ispartition)
                child_att->attidentity = parent_att->attidentity;
 
            /*
             * OK, bump the child column's inheritance count.  (If we fail
             * later on, this change will just roll back.)
             */
            child_att->attinhcount++;
            if (child_att->attinhcount < 0)
                ereport(ERROR,
                        errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
                        errmsg("too many inheritance parents"));
 
            /*
             * In case of partitions, we must enforce that value of attislocal
             * is same in all partitions. (Note: there are only inherited
             * attributes in partitions)
             */
            if (parent_rel->rd_rel->relkind == RELKIND_PARTITIONED_TABLE)
            {
                Assert(child_att->attinhcount == 1);
                child_att->attislocal = false;
            }
 
            CatalogTupleUpdate(attrrel, &tuple->t_self, tuple);
            heap_freetuple(tuple);
        }
        else
        {
            ereport(ERROR,
                    (errcode(ERRCODE_DATATYPE_MISMATCH),
                     errmsg("child table is missing column \"%s\"", parent_attname)));
        }
    }
 
    table_close(attrrel, RowExclusiveLock);
}

References Assert, CatalogTupleUpdate(), ereport, errcode(), errmsg(), ERROR, findNotNullConstraintAttnum(), GETSTRUCT, heap_freetuple(), HeapTupleIsValid, NameStr, TupleDescData::natts, RelationData::rd_rel, RelationGetDescr, RelationGetRelationName, RelationGetRelid, RowExclusiveLock, SearchSysCacheCopyAttName(), HeapTupleData::t_self, table_close(), table_open(), and TupleDescAttr.

Referenced by CreateInheritance().

MergeCheckConstraint()

static List * MergeCheckConstraint ( List *  constraints, const char *  name, Node *  expr  )

static

Definition at line 3141 of file tablecmds.c.

{
    ListCell   *lc;
    CookedConstraint *newcon;
 
    foreach(lc, constraints)
    {
        CookedConstraint *ccon = (CookedConstraint *) lfirst(lc);
 
        Assert(ccon->contype == CONSTR_CHECK);
 
        /* Non-matching names never conflict */
        if (strcmp(ccon->name, name) != 0)
            continue;
 
        if (equal(expr, ccon->expr))
        {
            /* OK to merge constraint with existing */
            ccon->inhcount++;
            if (ccon->inhcount < 0)
                ereport(ERROR,
                        errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
                        errmsg("too many inheritance parents"));
            return constraints;
        }
 
        ereport(ERROR,
                (errcode(ERRCODE_DUPLICATE_OBJECT),
                 errmsg("check constraint name \"%s\" appears multiple times but with different expressions",
                        name)));
    }
 
    /*
     * Constraint couldn't be merged with an existing one and also didn't
     * conflict with an existing one, so add it as a new one to the list.
     */
    newcon = palloc0_object(CookedConstraint);
    newcon->contype = CONSTR_CHECK;
    newcon->name = pstrdup(name);
    newcon->expr = expr;
    newcon->inhcount = 1;
    return lappend(constraints, newcon);
}

References Assert, CONSTR_CHECK, CookedConstraint::contype, equal(), ereport, errcode(), ERRCODE_DUPLICATE_OBJECT, errmsg(), ERROR, CookedConstraint::expr, CookedConstraint::inhcount, lappend(), lfirst, name, CookedConstraint::name, palloc0_object, and pstrdup().

Referenced by MergeAttributes().

MergeChildAttribute()

static void MergeChildAttribute ( List *  inh_columns, int  exist_attno, int  newcol_attno, const ColumnDef *  newdef  )

static

Definition at line 3207 of file tablecmds.c.

{
    char       *attributeName = newdef->colname;
    ColumnDef  *inhdef;
    Oid         inhtypeid,
                newtypeid;
    int32       inhtypmod,
                newtypmod;
    Oid         inhcollid,
                newcollid;
 
    if (exist_attno == newcol_attno)
        ereport(NOTICE,
                (errmsg("merging column \"%s\" with inherited definition",
                        attributeName)));
    else
        ereport(NOTICE,
                (errmsg("moving and merging column \"%s\" with inherited definition", attributeName),
                 errdetail("User-specified column moved to the position of the inherited column.")));
 
    inhdef = list_nth_node(ColumnDef, inh_columns, exist_attno - 1);
 
    /*
     * Must have the same type and typmod
     */
    typenameTypeIdAndMod(NULL, inhdef->typeName, &inhtypeid, &inhtypmod);
    typenameTypeIdAndMod(NULL, newdef->typeName, &newtypeid, &newtypmod);
    if (inhtypeid != newtypeid || inhtypmod != newtypmod)
        ereport(ERROR,
                (errcode(ERRCODE_DATATYPE_MISMATCH),
                 errmsg("column \"%s\" has a type conflict",
                        attributeName),
                 errdetail("%s versus %s",
                           format_type_with_typemod(inhtypeid, inhtypmod),
                           format_type_with_typemod(newtypeid, newtypmod))));
 
    /*
     * Must have the same collation
     */
    inhcollid = GetColumnDefCollation(NULL, inhdef, inhtypeid);
    newcollid = GetColumnDefCollation(NULL, newdef, newtypeid);
    if (inhcollid != newcollid)
        ereport(ERROR,
                (errcode(ERRCODE_COLLATION_MISMATCH),
                 errmsg("column \"%s\" has a collation conflict",
                        attributeName),
                 errdetail("\"%s\" versus \"%s\"",
                           get_collation_name(inhcollid),
                           get_collation_name(newcollid))));
 
    /*
     * Identity is never inherited by a regular inheritance child. Pick
     * child's identity definition if there's one.
     */
    inhdef->identity = newdef->identity;
 
    /*
     * Copy storage parameter
     */
    if (inhdef->storage == 0)
        inhdef->storage = newdef->storage;
    else if (newdef->storage != 0 && inhdef->storage != newdef->storage)
        ereport(ERROR,
                (errcode(ERRCODE_DATATYPE_MISMATCH),
                 errmsg("column \"%s\" has a storage parameter conflict",
                        attributeName),
                 errdetail("%s versus %s",
                           storage_name(inhdef->storage),
                           storage_name(newdef->storage))));
 
    /*
     * Copy compression parameter
     */
    if (inhdef->compression == NULL)
        inhdef->compression = newdef->compression;
    else if (newdef->compression != NULL)
    {
        if (strcmp(inhdef->compression, newdef->compression) != 0)
            ereport(ERROR,
                    (errcode(ERRCODE_DATATYPE_MISMATCH),
                     errmsg("column \"%s\" has a compression method conflict",
                            attributeName),
                     errdetail("%s versus %s", inhdef->compression, newdef->compression)));
    }
 
    /*
     * Merge of not-null constraints = OR 'em together
     */
    inhdef->is_not_null |= newdef->is_not_null;
 
    /*
     * Check for conflicts related to generated columns.
     *
     * If the parent column is generated, the child column will be made a
     * generated column if it isn't already.  If it is a generated column,
     * we'll take its generation expression in preference to the parent's.  We
     * must check that the child column doesn't specify a default value or
     * identity, which matches the rules for a single column in
     * parse_utilcmd.c.
     *
     * Conversely, if the parent column is not generated, the child column
     * can't be either.  (We used to allow that, but it results in being able
     * to override the generation expression via UPDATEs through the parent.)
     */
    if (inhdef->generated)
    {
        if (newdef->raw_default && !newdef->generated)
            ereport(ERROR,
                    (errcode(ERRCODE_INVALID_COLUMN_DEFINITION),
                     errmsg("column \"%s\" inherits from generated column but specifies default",
                            inhdef->colname)));
        if (newdef->identity)
            ereport(ERROR,
                    (errcode(ERRCODE_INVALID_COLUMN_DEFINITION),
                     errmsg("column \"%s\" inherits from generated column but specifies identity",
                            inhdef->colname)));
    }
    else
    {
        if (newdef->generated)
            ereport(ERROR,
                    (errcode(ERRCODE_INVALID_COLUMN_DEFINITION),
                     errmsg("child column \"%s\" specifies generation expression",
                            inhdef->colname),
                     errhint("A child table column cannot be generated unless its parent column is.")));
    }
 
    /*
     * If new def has a default, override previous default
     */
    if (newdef->raw_default != NULL)
    {
        inhdef->raw_default = newdef->raw_default;
        inhdef->cooked_default = newdef->cooked_default;
    }
 
    /* Mark the column as locally defined */
    inhdef->is_local = true;
}

References ColumnDef::colname, ColumnDef::compression, ColumnDef::cooked_default, ereport, errcode(), errdetail(), errhint(), errmsg(), ERROR, format_type_with_typemod(), ColumnDef::generated, get_collation_name(), GetColumnDefCollation(), ColumnDef::identity, ColumnDef::is_local, ColumnDef::is_not_null, list_nth_node, NOTICE, ColumnDef::raw_default, ColumnDef::storage, storage_name(), ColumnDef::typeName, and typenameTypeIdAndMod().

Referenced by MergeAttributes().

MergeConstraintsIntoExisting()

static void MergeConstraintsIntoExisting ( Relation  child_rel, Relation  parent_rel  )

static

Definition at line 16538 of file tablecmds.c.

{
    Relation    constraintrel;
    SysScanDesc parent_scan;
    ScanKeyData parent_key;
    HeapTuple   parent_tuple;
    Oid         parent_relid = RelationGetRelid(parent_rel);
 
    constraintrel = table_open(ConstraintRelationId, RowExclusiveLock);
 
    /* Outer loop scans through the parent's constraint definitions */
    ScanKeyInit(&parent_key,
                Anum_pg_constraint_conrelid,
                BTEqualStrategyNumber, F_OIDEQ,
                ObjectIdGetDatum(parent_relid));
    parent_scan = systable_beginscan(constraintrel, ConstraintRelidTypidNameIndexId,
                                     true, NULL, 1, &parent_key);
 
    while (HeapTupleIsValid(parent_tuple = systable_getnext(parent_scan)))
    {
        Form_pg_constraint parent_con = (Form_pg_constraint) GETSTRUCT(parent_tuple);
        SysScanDesc child_scan;
        ScanKeyData child_key;
        HeapTuple   child_tuple;
        bool        found = false;
 
        if (parent_con->contype != CONSTRAINT_CHECK &&
            parent_con->contype != CONSTRAINT_NOTNULL)
            continue;
 
        /* if the parent's constraint is marked NO INHERIT, it's not inherited */
        if (parent_con->connoinherit)
            continue;
 
        /* Search for a child constraint matching this one */
        ScanKeyInit(&child_key,
                    Anum_pg_constraint_conrelid,
                    BTEqualStrategyNumber, F_OIDEQ,
                    ObjectIdGetDatum(RelationGetRelid(child_rel)));
        child_scan = systable_beginscan(constraintrel, ConstraintRelidTypidNameIndexId,
                                        true, NULL, 1, &child_key);
 
        while (HeapTupleIsValid(child_tuple = systable_getnext(child_scan)))
        {
            Form_pg_constraint child_con = (Form_pg_constraint) GETSTRUCT(child_tuple);
            HeapTuple   child_copy;
 
            if (child_con->contype != parent_con->contype)
                continue;
 
            /*
             * CHECK constraint are matched by name, NOT NULL ones by
             * attribute number
             */
            if (child_con->contype == CONSTRAINT_CHECK)
            {
                if (strcmp(NameStr(parent_con->conname),
                           NameStr(child_con->conname)) != 0)
                    continue;
            }
            else if (child_con->contype == CONSTRAINT_NOTNULL)
            {
                AttrNumber  parent_attno = extractNotNullColumn(parent_tuple);
                AttrNumber  child_attno = extractNotNullColumn(child_tuple);
 
                if (strcmp(get_attname(parent_relid, parent_attno, false),
                           get_attname(RelationGetRelid(child_rel), child_attno,
                                       false)) != 0)
                    continue;
            }
 
            if (child_con->contype == CONSTRAINT_CHECK &&
                !constraints_equivalent(parent_tuple, child_tuple, RelationGetDescr(constraintrel)))
                ereport(ERROR,
                        (errcode(ERRCODE_DATATYPE_MISMATCH),
                         errmsg("child table \"%s\" has different definition for check constraint \"%s\"",
                                RelationGetRelationName(child_rel), NameStr(parent_con->conname))));
 
            /*
             * If the CHECK child constraint is "no inherit" then cannot
             * merge.
             *
             * This is not desirable for not-null constraints, mostly because
             * it breaks our pg_upgrade strategy, but it also makes sense on
             * its own: if a child has its own not-null constraint and then
             * acquires a parent with the same constraint, then we start to
             * enforce that constraint for all the descendants of that child
             * too, if any.
             */
            if (child_con->contype == CONSTRAINT_CHECK &&
                child_con->connoinherit)
                ereport(ERROR,
                        (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
                         errmsg("constraint \"%s\" conflicts with non-inherited constraint on child table \"%s\"",
                                NameStr(child_con->conname), RelationGetRelationName(child_rel))));
 
            /*
             * If the child constraint is "not valid" then cannot merge with a
             * valid parent constraint
             */
            if (parent_con->convalidated && !child_con->convalidated)
                ereport(ERROR,
                        (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
                         errmsg("constraint \"%s\" conflicts with NOT VALID constraint on child table \"%s\"",
                                NameStr(child_con->conname), RelationGetRelationName(child_rel))));
 
            /*
             * OK, bump the child constraint's inheritance count.  (If we fail
             * later on, this change will just roll back.)
             */
            child_copy = heap_copytuple(child_tuple);
            child_con = (Form_pg_constraint) GETSTRUCT(child_copy);
            child_con->coninhcount++;
            if (child_con->coninhcount < 0)
                ereport(ERROR,
                        errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
                        errmsg("too many inheritance parents"));
            if (child_con->contype == CONSTRAINT_NOTNULL &&
                child_con->connoinherit)
            {
                /*
                 * If the child has children, it's not possible to turn a NO
                 * INHERIT constraint into an inheritable one: we would need
                 * to recurse to create constraints in those children, but
                 * this is not a good place to do that.
                 */
                if (child_rel->rd_rel->relhassubclass)
                    ereport(ERROR,
                            errmsg("cannot add NOT NULL constraint to column \"%s\" of relation \"%s\" with inheritance children",
                                   get_attname(RelationGetRelid(child_rel),
                                               extractNotNullColumn(child_tuple),
                                               false),
                                   RelationGetRelationName(child_rel)),
                            errdetail("Existing constraint \"%s\" is marked NO INHERIT.",
                                      NameStr(child_con->conname)));
 
                child_con->connoinherit = false;
            }
 
            /*
             * In case of partitions, an inherited constraint must be
             * inherited only once since it cannot have multiple parents and
             * it is never considered local.
             */
            if (parent_rel->rd_rel->relkind == RELKIND_PARTITIONED_TABLE)
            {
                Assert(child_con->coninhcount == 1);
                child_con->conislocal = false;
            }
 
            CatalogTupleUpdate(constraintrel, &child_copy->t_self, child_copy);
            heap_freetuple(child_copy);
 
            found = true;
            break;
        }
 
        systable_endscan(child_scan);
 
        if (!found)
        {
            if (parent_con->contype == CONSTRAINT_NOTNULL)
                ereport(ERROR,
                        errcode(ERRCODE_DATATYPE_MISMATCH),
                        errmsg("column \"%s\" in child table must be marked NOT NULL",
                               get_attname(parent_relid,
                                           extractNotNullColumn(parent_tuple),
                                           false)));
 
            ereport(ERROR,
                    (errcode(ERRCODE_DATATYPE_MISMATCH),
                     errmsg("child table is missing constraint \"%s\"",
                            NameStr(parent_con->conname))));
        }
    }
 
    systable_endscan(parent_scan);
    table_close(constraintrel, RowExclusiveLock);
}

References Assert, BTEqualStrategyNumber, CatalogTupleUpdate(), constraints_equivalent(), ereport, errcode(), errdetail(), errmsg(), ERROR, extractNotNullColumn(), get_attname(), GETSTRUCT, heap_copytuple(), heap_freetuple(), HeapTupleIsValid, NameStr, ObjectIdGetDatum(), RelationData::rd_rel, RelationGetDescr, RelationGetRelationName, RelationGetRelid, RowExclusiveLock, ScanKeyInit(), systable_beginscan(), systable_endscan(), systable_getnext(), HeapTupleData::t_self, table_close(), and table_open().

Referenced by CreateInheritance().

MergeInheritedAttribute()

static ColumnDef * MergeInheritedAttribute ( List *  inh_columns, int  exist_attno, const ColumnDef *  newdef  )

static

Definition at line 3368 of file tablecmds.c.

{
    char       *attributeName = newdef->colname;
    ColumnDef  *prevdef;
    Oid         prevtypeid,
                newtypeid;
    int32       prevtypmod,
                newtypmod;
    Oid         prevcollid,
                newcollid;
 
    ereport(NOTICE,
            (errmsg("merging multiple inherited definitions of column \"%s\"",
                    attributeName)));
    prevdef = list_nth_node(ColumnDef, inh_columns, exist_attno - 1);
 
    /*
     * Must have the same type and typmod
     */
    typenameTypeIdAndMod(NULL, prevdef->typeName, &prevtypeid, &prevtypmod);
    typenameTypeIdAndMod(NULL, newdef->typeName, &newtypeid, &newtypmod);
    if (prevtypeid != newtypeid || prevtypmod != newtypmod)
        ereport(ERROR,
                (errcode(ERRCODE_DATATYPE_MISMATCH),
                 errmsg("inherited column \"%s\" has a type conflict",
                        attributeName),
                 errdetail("%s versus %s",
                           format_type_with_typemod(prevtypeid, prevtypmod),
                           format_type_with_typemod(newtypeid, newtypmod))));
 
    /*
     * Must have the same collation
     */
    prevcollid = GetColumnDefCollation(NULL, prevdef, prevtypeid);
    newcollid = GetColumnDefCollation(NULL, newdef, newtypeid);
    if (prevcollid != newcollid)
        ereport(ERROR,
                (errcode(ERRCODE_COLLATION_MISMATCH),
                 errmsg("inherited column \"%s\" has a collation conflict",
                        attributeName),
                 errdetail("\"%s\" versus \"%s\"",
                           get_collation_name(prevcollid),
                           get_collation_name(newcollid))));
 
    /*
     * Copy/check storage parameter
     */
    if (prevdef->storage == 0)
        prevdef->storage = newdef->storage;
    else if (prevdef->storage != newdef->storage)
        ereport(ERROR,
                (errcode(ERRCODE_DATATYPE_MISMATCH),
                 errmsg("inherited column \"%s\" has a storage parameter conflict",
                        attributeName),
                 errdetail("%s versus %s",
                           storage_name(prevdef->storage),
                           storage_name(newdef->storage))));
 
    /*
     * Copy/check compression parameter
     */
    if (prevdef->compression == NULL)
        prevdef->compression = newdef->compression;
    else if (strcmp(prevdef->compression, newdef->compression) != 0)
        ereport(ERROR,
                (errcode(ERRCODE_DATATYPE_MISMATCH),
                 errmsg("column \"%s\" has a compression method conflict",
                        attributeName),
                 errdetail("%s versus %s", prevdef->compression, newdef->compression)));
 
    /*
     * Check for GENERATED conflicts
     */
    if (prevdef->generated != newdef->generated)
        ereport(ERROR,
                (errcode(ERRCODE_DATATYPE_MISMATCH),
                 errmsg("inherited column \"%s\" has a generation conflict",
                        attributeName)));
 
    /*
     * Default and other constraints are handled by the caller.
     */
 
    prevdef->inhcount++;
    if (prevdef->inhcount < 0)
        ereport(ERROR,
                errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
                errmsg("too many inheritance parents"));
 
    return prevdef;
}

References ColumnDef::colname, ColumnDef::compression, ereport, errcode(), errdetail(), errmsg(), ERROR, format_type_with_typemod(), ColumnDef::generated, get_collation_name(), GetColumnDefCollation(), ColumnDef::inhcount, list_nth_node, NOTICE, ColumnDef::storage, storage_name(), ColumnDef::typeName, and typenameTypeIdAndMod().

Referenced by MergeAttributes().

moveMergedTablesRows()

static void moveMergedTablesRows ( Relation  rel, List *  mergingPartitionsList, Relation  newPartRel  )

static

Definition at line 21376 of file tablecmds.c.

{
    CommandId   mycid;
 
    /* The FSM is empty, so don't bother using it. */
    int         ti_options = TABLE_INSERT_SKIP_FSM;
    ListCell   *listptr;
    BulkInsertState bistate;    /* state of bulk inserts for partition */
    TupleTableSlot *dstslot;
 
    mycid = GetCurrentCommandId(true);
 
    /* Prepare a BulkInsertState for table_tuple_insert. */
    bistate = GetBulkInsertState();
 
    /* Create necessary tuple slot. */
    dstslot = MakeSingleTupleTableSlot(RelationGetDescr(newPartRel),
                                       table_slot_callbacks(newPartRel));
    ExecStoreAllNullTuple(dstslot);
 
    foreach(listptr, mergingPartitionsList)
    {
        Relation    mergingPartition = (Relation) lfirst(listptr);
        TupleTableSlot *srcslot;
        TupleConversionMap *tuple_map;
        TableScanDesc scan;
        Snapshot    snapshot;
 
        /* Create tuple slot for new partition. */
        srcslot = MakeSingleTupleTableSlot(RelationGetDescr(mergingPartition),
                                           table_slot_callbacks(mergingPartition));
 
        /*
         * Map computing for moving attributes of merged partition to new
         * partition.
         */
        tuple_map = convert_tuples_by_name(RelationGetDescr(mergingPartition),
                                           RelationGetDescr(newPartRel));
 
        /* Scan through the rows. */
        snapshot = RegisterSnapshot(GetLatestSnapshot());
        scan = table_beginscan(mergingPartition, snapshot, 0, NULL);
 
        while (table_scan_getnextslot(scan, ForwardScanDirection, srcslot))
        {
            TupleTableSlot *insertslot;
 
            /* Extract data from old tuple. */
            slot_getallattrs(srcslot);
 
            if (tuple_map)
            {
                /* Need to use map to copy attributes. */
                insertslot = execute_attr_map_slot(tuple_map->attrMap, srcslot, dstslot);
            }
            else
            {
                /* Copy attributes directly. */
                insertslot = dstslot;
 
                ExecClearTuple(insertslot);
 
                memcpy(insertslot->tts_values, srcslot->tts_values,
                       sizeof(Datum) * srcslot->tts_nvalid);
                memcpy(insertslot->tts_isnull, srcslot->tts_isnull,
                       sizeof(bool) * srcslot->tts_nvalid);
 
                ExecStoreVirtualTuple(insertslot);
            }
 
            /* Write the tuple out to the new relation. */
            table_tuple_insert(newPartRel, insertslot, mycid,
                               ti_options, bistate);
 
            CHECK_FOR_INTERRUPTS();
        }
 
        table_endscan(scan);
        UnregisterSnapshot(snapshot);
 
        if (tuple_map)
            free_conversion_map(tuple_map);
 
        ExecDropSingleTupleTableSlot(srcslot);
    }
 
    ExecDropSingleTupleTableSlot(dstslot);
    FreeBulkInsertState(bistate);
 
    table_finish_bulk_insert(newPartRel, ti_options);
}

References TupleConversionMap::attrMap, CHECK_FOR_INTERRUPTS, convert_tuples_by_name(), ExecClearTuple(), ExecDropSingleTupleTableSlot(), ExecStoreAllNullTuple(), ExecStoreVirtualTuple(), execute_attr_map_slot(), ForwardScanDirection, free_conversion_map(), FreeBulkInsertState(), GetBulkInsertState(), GetCurrentCommandId(), GetLatestSnapshot(), lfirst, MakeSingleTupleTableSlot(), RegisterSnapshot(), RelationGetDescr, slot_getallattrs(), table_beginscan(), table_endscan(), table_finish_bulk_insert(), TABLE_INSERT_SKIP_FSM, table_scan_getnextslot(), table_slot_callbacks(), table_tuple_insert(), TupleTableSlot::tts_isnull, TupleTableSlot::tts_nvalid, TupleTableSlot::tts_values, and UnregisterSnapshot().

Referenced by ATExecMergePartitions().

moveSplitTableRows()

static void moveSplitTableRows ( Relation  rel, Relation  splitRel, List *  partlist, List *  newPartRels, Oid  defaultPartOid  )

static

Definition at line 20996 of file tablecmds.c.

{
    /* The FSM is empty, so don't bother using it. */
    int         ti_options = TABLE_INSERT_SKIP_FSM;
    CommandId   mycid;
    EState     *estate;
    ListCell   *listptr,
               *listptr2;
    TupleTableSlot *srcslot;
    ExprContext *econtext;
    TableScanDesc scan;
    Snapshot    snapshot;
    MemoryContext oldCxt;
    List       *partContexts = NIL;
    TupleConversionMap *tuple_map;
    SplitPartitionContext *defaultPartCtx = NULL,
               *pc;
    bool        isOldDefaultPart = false;
 
    mycid = GetCurrentCommandId(true);
 
    estate = CreateExecutorState();
 
    forboth(listptr, partlist, listptr2, newPartRels)
    {
        SinglePartitionSpec *sps = (SinglePartitionSpec *) lfirst(listptr);
 
        pc = createSplitPartitionContext((Relation) lfirst(listptr2));
 
        if (sps->bound->is_default)
        {
            /* We should not create constraint for detached DEFAULT partition. */
            defaultPartCtx = pc;
        }
        else
        {
            List       *partConstraint;
 
            /* Build expression execution states for partition check quals. */
            partConstraint = get_qual_from_partbound(rel, sps->bound);
            partConstraint =
                (List *) eval_const_expressions(NULL,
                                                (Node *) partConstraint);
            /* Make boolean expression for ExecCheck(). */
            partConstraint = list_make1(make_ands_explicit(partConstraint));
 
            /*
             * Map the vars in the constraint expression from rel's attnos to
             * splitRel's.
             */
            partConstraint = map_partition_varattnos(partConstraint,
                                                     1, splitRel, rel);
 
            pc->partqualstate =
                ExecPrepareExpr((Expr *) linitial(partConstraint), estate);
            Assert(pc->partqualstate != NULL);
        }
 
        /* Store partition context into list. */
        partContexts = lappend(partContexts, pc);
    }
 
    /*
     * Create partition context for DEFAULT partition. We can insert values
     * into this partition in case spaces with values between new partitions.
     */
    if (!defaultPartCtx && OidIsValid(defaultPartOid))
    {
        /* Indicate that we allocate context for old DEFAULT partition */
        isOldDefaultPart = true;
        defaultPartCtx = createSplitPartitionContext(table_open(defaultPartOid, AccessExclusiveLock));
    }
 
    econtext = GetPerTupleExprContext(estate);
 
    /* Create necessary tuple slot. */
    srcslot = MakeSingleTupleTableSlot(RelationGetDescr(splitRel),
                                       table_slot_callbacks(splitRel));
 
    /*
     * Map computing for moving attributes of split partition to new partition
     * (for first new partition, but other new partitions can use the same
     * map).
     */
    pc = (SplitPartitionContext *) lfirst(list_head(partContexts));
    tuple_map = convert_tuples_by_name(RelationGetDescr(splitRel),
                                       RelationGetDescr(pc->partRel));
 
    /* Scan through the rows. */
    snapshot = RegisterSnapshot(GetLatestSnapshot());
    scan = table_beginscan(splitRel, snapshot, 0, NULL);
 
    /*
     * Switch to per-tuple memory context and reset it for each tuple
     * produced, so we don't leak memory.
     */
    oldCxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(estate));
 
    while (table_scan_getnextslot(scan, ForwardScanDirection, srcslot))
    {
        bool        found = false;
        TupleTableSlot *insertslot;
 
        /* Extract data from old tuple. */
        slot_getallattrs(srcslot);
 
        econtext->ecxt_scantuple = srcslot;
 
        /* Search partition for current slot srcslot. */
        foreach(listptr, partContexts)
        {
            pc = (SplitPartitionContext *) lfirst(listptr);
 
            if (pc->partqualstate /* skip DEFAULT partition */ &&
                ExecCheck(pc->partqualstate, econtext))
            {
                found = true;
                break;
            }
            ResetExprContext(econtext);
        }
        if (!found)
        {
            /* Use DEFAULT partition if it exists. */
            if (defaultPartCtx)
                pc = defaultPartCtx;
            else
                ereport(ERROR,
                        (errcode(ERRCODE_CHECK_VIOLATION),
                         errmsg("can not find partition for split partition row"),
                         errtable(splitRel)));
        }
 
        if (tuple_map)
        {
            /* Need to use map to copy attributes. */
            insertslot = execute_attr_map_slot(tuple_map->attrMap, srcslot, pc->dstslot);
        }
        else
        {
            /* Copy attributes directly. */
            insertslot = pc->dstslot;
 
            ExecClearTuple(insertslot);
 
            memcpy(insertslot->tts_values, srcslot->tts_values,
                   sizeof(Datum) * srcslot->tts_nvalid);
            memcpy(insertslot->tts_isnull, srcslot->tts_isnull,
                   sizeof(bool) * srcslot->tts_nvalid);
 
            ExecStoreVirtualTuple(insertslot);
        }
 
        /* Write the tuple out to the new relation. */
        table_tuple_insert(pc->partRel, insertslot, mycid,
                           ti_options, pc->bistate);
 
        ResetExprContext(econtext);
 
        CHECK_FOR_INTERRUPTS();
    }
 
    MemoryContextSwitchTo(oldCxt);
 
    table_endscan(scan);
    UnregisterSnapshot(snapshot);
 
    if (tuple_map)
        free_conversion_map(tuple_map);
 
    ExecDropSingleTupleTableSlot(srcslot);
 
    FreeExecutorState(estate);
 
    foreach(listptr, partContexts)
        deleteSplitPartitionContext((SplitPartitionContext *) lfirst(listptr), ti_options);
 
    /* Need to close table and free buffers for DEFAULT partition. */
    if (isOldDefaultPart)
    {
        Relation    defaultPartRel = defaultPartCtx->partRel;
 
        deleteSplitPartitionContext(defaultPartCtx, ti_options);
        /* Keep the lock until commit. */
        table_close(defaultPartRel, NoLock);
    }
}

References AccessExclusiveLock, Assert, TupleConversionMap::attrMap, SinglePartitionSpec::bound, CHECK_FOR_INTERRUPTS, convert_tuples_by_name(), CreateExecutorState(), createSplitPartitionContext(), deleteSplitPartitionContext(), ExprContext::ecxt_scantuple, ereport, errcode(), errmsg(), ERROR, errtable(), eval_const_expressions(), ExecCheck(), ExecClearTuple(), ExecDropSingleTupleTableSlot(), ExecPrepareExpr(), ExecStoreVirtualTuple(), execute_attr_map_slot(), forboth, ForwardScanDirection, free_conversion_map(), FreeExecutorState(), get_qual_from_partbound(), GetCurrentCommandId(), GetLatestSnapshot(), GetPerTupleExprContext, GetPerTupleMemoryContext, PartitionBoundSpec::is_default, lappend(), lfirst, linitial, list_head(), list_make1, make_ands_explicit(), MakeSingleTupleTableSlot(), map_partition_varattnos(), MemoryContextSwitchTo(), NIL, NoLock, OidIsValid, SplitPartitionContext::partRel, RegisterSnapshot(), RelationGetDescr, ResetExprContext, slot_getallattrs(), table_beginscan(), table_close(), table_endscan(), TABLE_INSERT_SKIP_FSM, table_open(), table_scan_getnextslot(), table_slot_callbacks(), table_tuple_insert(), TupleTableSlot::tts_isnull, TupleTableSlot::tts_nvalid, TupleTableSlot::tts_values, and UnregisterSnapshot().

Referenced by ATExecSplitPartition().

NotNullImpliedByRelConstraints()

static bool NotNullImpliedByRelConstraints ( Relation  rel, Form_pg_attribute  attr  )

static

Definition at line 8049 of file tablecmds.c.

{
    NullTest   *nnulltest = makeNode(NullTest);
 
    nnulltest->arg = (Expr *) makeVar(1,
                                      attr->attnum,
                                      attr->atttypid,
                                      attr->atttypmod,
                                      attr->attcollation,
                                      0);
    nnulltest->nulltesttype = IS_NOT_NULL;
 
    /*
     * argisrow = false is correct even for a composite column, because
     * attnotnull does not represent a SQL-spec IS NOT NULL test in such a
     * case, just IS DISTINCT FROM NULL.
     */
    nnulltest->argisrow = false;
    nnulltest->location = -1;
 
    if (ConstraintImpliedByRelConstraint(rel, list_make1(nnulltest), NIL))
    {
        ereport(DEBUG1,
                (errmsg_internal("existing constraints on column \"%s.%s\" are sufficient to prove that it does not contain nulls",
                                 RelationGetRelationName(rel), NameStr(attr->attname))));
        return true;
    }
 
    return false;
}

References NullTest::arg, ConstraintImpliedByRelConstraint(), DEBUG1, ereport, errmsg_internal(), IS_NOT_NULL, list_make1, NullTest::location, makeNode, makeVar(), NameStr, NIL, NullTest::nulltesttype, and RelationGetRelationName.

Referenced by set_attnotnull().

PartConstraintImpliedByRelConstraint()

bool PartConstraintImpliedByRelConstraint	(	Relation	scanrel,
		List *	partConstraint
	)

Definition at line 18963 of file tablecmds.c.

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

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

Referenced by check_default_partition_contents(), DetachAddConstraintIfNeeded(), and QueuePartitionConstraintValidation().

PreCommit_on_commit_actions()

void PreCommit_on_commit_actions

(

void

)

Definition at line 18240 of file tablecmds.c.

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

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

Referenced by CommitTransaction(), and PrepareTransaction().

QueuePartitionConstraintValidation()

static void QueuePartitionConstraintValidation ( List **  wqueue, Relation  scanrel, List *  partConstraint, bool  validate_default  )

static

Definition at line 19073 of file tablecmds.c.

{
    /*
     * Based on the table's existing constraints, determine whether or not we
     * may skip scanning the table.
     */
    if (PartConstraintImpliedByRelConstraint(scanrel, partConstraint))
    {
        if (!validate_default)
            ereport(DEBUG1,
                    (errmsg_internal("partition constraint for table \"%s\" is implied by existing constraints",
                                     RelationGetRelationName(scanrel))));
        else
            ereport(DEBUG1,
                    (errmsg_internal("updated partition constraint for default partition \"%s\" is implied by existing constraints",
                                     RelationGetRelationName(scanrel))));
        return;
    }
 
    /*
     * Constraints proved insufficient. For plain relations, queue a
     * validation item now; for partitioned tables, recurse to process each
     * partition.
     */
    if (scanrel->rd_rel->relkind == RELKIND_RELATION)
    {
        AlteredTableInfo *tab;
 
        /* Grab a work queue entry. */
        tab = ATGetQueueEntry(wqueue, scanrel);
        Assert(tab->partition_constraint == NULL);
        tab->partition_constraint = (Expr *) linitial(partConstraint);
        tab->validate_default = validate_default;
    }
    else if (scanrel->rd_rel->relkind == RELKIND_PARTITIONED_TABLE)
    {
        PartitionDesc partdesc = RelationGetPartitionDesc(scanrel, true);
        int         i;
 
        for (i = 0; i < partdesc->nparts; i++)
        {
            Relation    part_rel;
            List       *thisPartConstraint;
 
            /*
             * This is the minimum lock we need to prevent deadlocks.
             */
            part_rel = table_open(partdesc->oids[i], AccessExclusiveLock);
 
            /*
             * Adjust the constraint for scanrel so that it matches this
             * partition's attribute numbers.
             */
            thisPartConstraint =
                map_partition_varattnos(partConstraint, 1,
                                        part_rel, scanrel);
 
            QueuePartitionConstraintValidation(wqueue, part_rel,
                                               thisPartConstraint,
                                               validate_default);
            table_close(part_rel, NoLock);  /* keep lock till commit */
        }
    }
}

References AccessExclusiveLock, Assert, ATGetQueueEntry(), DEBUG1, ereport, errmsg_internal(), i, linitial, map_partition_varattnos(), NoLock, PartitionDescData::nparts, PartitionDescData::oids, PartConstraintImpliedByRelConstraint(), AlteredTableInfo::partition_constraint, RelationData::rd_rel, RelationGetPartitionDesc(), RelationGetRelationName, table_close(), table_open(), and AlteredTableInfo::validate_default.

Referenced by ATExecAttachPartition().

RangeVarCallbackForAlterRelation()

static void RangeVarCallbackForAlterRelation ( const RangeVar *  rv, Oid  relid, Oid  oldrelid, void *  arg  )

static

Definition at line 18506 of file tablecmds.c.

{
    Node       *stmt = (Node *) arg;
    ObjectType  reltype;
    HeapTuple   tuple;
    Form_pg_class classform;
    AclResult   aclresult;
    char        relkind;
 
    tuple = SearchSysCache1(RELOID, ObjectIdGetDatum(relid));
    if (!HeapTupleIsValid(tuple))
        return;                 /* concurrently dropped */
    classform = (Form_pg_class) GETSTRUCT(tuple);
    relkind = classform->relkind;
 
    /* Must own relation. */
    if (!object_ownercheck(RelationRelationId, relid, GetUserId()))
        aclcheck_error(ACLCHECK_NOT_OWNER, get_relkind_objtype(get_rel_relkind(relid)), rv->relname);
 
    /* No system table modifications unless explicitly allowed. */
    if (!allowSystemTableMods && IsSystemClass(relid, classform))
        ereport(ERROR,
                (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
                 errmsg("permission denied: \"%s\" is a system catalog",
                        rv->relname)));
 
    /*
     * Extract the specified relation type from the statement parse tree.
     *
     * Also, for ALTER .. RENAME, check permissions: the user must (still)
     * have CREATE rights on the containing namespace.
     */
    if (IsA(stmt, RenameStmt))
    {
        aclresult = object_aclcheck(NamespaceRelationId, classform->relnamespace,
                                    GetUserId(), ACL_CREATE);
        if (aclresult != ACLCHECK_OK)
            aclcheck_error(aclresult, OBJECT_SCHEMA,
                           get_namespace_name(classform->relnamespace));
        reltype = ((RenameStmt *) stmt)->renameType;
    }
    else if (IsA(stmt, AlterObjectSchemaStmt))
        reltype = ((AlterObjectSchemaStmt *) stmt)->objectType;
 
    else if (IsA(stmt, AlterTableStmt))
        reltype = ((AlterTableStmt *) stmt)->objtype;
    else
    {
        elog(ERROR, "unrecognized node type: %d", (int) nodeTag(stmt));
        reltype = OBJECT_TABLE; /* placate compiler */
    }
 
    /*
     * For compatibility with prior releases, we allow ALTER TABLE to be used
     * with most other types of relations (but not composite types). We allow
     * similar flexibility for ALTER INDEX in the case of RENAME, but not
     * otherwise.  Otherwise, the user must select the correct form of the
     * command for the relation at issue.
     */
    if (reltype == OBJECT_SEQUENCE && relkind != RELKIND_SEQUENCE)
        ereport(ERROR,
                (errcode(ERRCODE_WRONG_OBJECT_TYPE),
                 errmsg("\"%s\" is not a sequence", rv->relname)));
 
    if (reltype == OBJECT_VIEW && relkind != RELKIND_VIEW)
        ereport(ERROR,
                (errcode(ERRCODE_WRONG_OBJECT_TYPE),
                 errmsg("\"%s\" is not a view", rv->relname)));
 
    if (reltype == OBJECT_MATVIEW && relkind != RELKIND_MATVIEW)
        ereport(ERROR,
                (errcode(ERRCODE_WRONG_OBJECT_TYPE),
                 errmsg("\"%s\" is not a materialized view", rv->relname)));
 
    if (reltype == OBJECT_FOREIGN_TABLE && relkind != RELKIND_FOREIGN_TABLE)
        ereport(ERROR,
                (errcode(ERRCODE_WRONG_OBJECT_TYPE),
                 errmsg("\"%s\" is not a foreign table", rv->relname)));
 
    if (reltype == OBJECT_TYPE && relkind != RELKIND_COMPOSITE_TYPE)
        ereport(ERROR,
                (errcode(ERRCODE_WRONG_OBJECT_TYPE),
                 errmsg("\"%s\" is not a composite type", rv->relname)));
 
    if (reltype == OBJECT_INDEX && relkind != RELKIND_INDEX &&
        relkind != RELKIND_PARTITIONED_INDEX
        && !IsA(stmt, RenameStmt))
        ereport(ERROR,
                (errcode(ERRCODE_WRONG_OBJECT_TYPE),
                 errmsg("\"%s\" is not an index", rv->relname)));
 
    /*
     * Don't allow ALTER TABLE on composite types. We want people to use ALTER
     * TYPE for that.
     */
    if (reltype != OBJECT_TYPE && relkind == RELKIND_COMPOSITE_TYPE)
        ereport(ERROR,
                (errcode(ERRCODE_WRONG_OBJECT_TYPE),
                 errmsg("\"%s\" is a composite type", rv->relname),
        /* translator: %s is an SQL ALTER command */
                 errhint("Use %s instead.",
                         "ALTER TYPE")));
 
    /*
     * Don't allow ALTER TABLE .. SET SCHEMA on relations that can't be moved
     * to a different schema, such as indexes and TOAST tables.
     */
    if (IsA(stmt, AlterObjectSchemaStmt))
    {
        if (relkind == RELKIND_INDEX || relkind == RELKIND_PARTITIONED_INDEX)
            ereport(ERROR,
                    (errcode(ERRCODE_WRONG_OBJECT_TYPE),
                     errmsg("cannot change schema of index \"%s\"",
                            rv->relname),
                     errhint("Change the schema of the table instead.")));
        else if (relkind == RELKIND_COMPOSITE_TYPE)
            ereport(ERROR,
                    (errcode(ERRCODE_WRONG_OBJECT_TYPE),
                     errmsg("cannot change schema of composite type \"%s\"",
                            rv->relname),
            /* translator: %s is an SQL ALTER command */
                     errhint("Use %s instead.",
                             "ALTER TYPE")));
        else if (relkind == RELKIND_TOASTVALUE)
            ereport(ERROR,
                    (errcode(ERRCODE_WRONG_OBJECT_TYPE),
                     errmsg("cannot change schema of TOAST table \"%s\"",
                            rv->relname),
                     errhint("Change the schema of the table instead.")));
    }
 
    ReleaseSysCache(tuple);
}

References ACL_CREATE, aclcheck_error(), ACLCHECK_NOT_OWNER, ACLCHECK_OK, allowSystemTableMods, arg, elog, ereport, errcode(), errhint(), errmsg(), ERROR, get_namespace_name(), get_rel_relkind(), get_relkind_objtype(), GETSTRUCT, GetUserId(), HeapTupleIsValid, IsA, IsSystemClass(), nodeTag, object_aclcheck(), OBJECT_FOREIGN_TABLE, OBJECT_INDEX, OBJECT_MATVIEW, object_ownercheck(), OBJECT_SCHEMA, OBJECT_SEQUENCE, OBJECT_TABLE, OBJECT_TYPE, OBJECT_VIEW, ObjectIdGetDatum(), ReleaseSysCache(), RangeVar::relname, SearchSysCache1(), and stmt.

Referenced by AlterTableLookupRelation(), AlterTableNamespace(), and RenameRelation().

RangeVarCallbackForAttachIndex()

static void RangeVarCallbackForAttachIndex ( const RangeVar *  rv, Oid  relOid, Oid  oldRelOid, void *  arg  )

static

Definition at line 20398 of file tablecmds.c.

{
    struct AttachIndexCallbackState *state;
    Form_pg_class classform;
    HeapTuple   tuple;
 
    state = (struct AttachIndexCallbackState *) arg;
 
    if (!state->lockedParentTbl)
    {
        LockRelationOid(state->parentTblOid, AccessShareLock);
        state->lockedParentTbl = true;
    }
 
    /*
     * If we previously locked some other heap, and the name we're looking up
     * no longer refers to an index on that relation, release the now-useless
     * lock.  XXX maybe we should do *after* we verify whether the index does
     * not actually belong to the same relation ...
     */
    if (relOid != oldRelOid && OidIsValid(state->partitionOid))
    {
        UnlockRelationOid(state->partitionOid, AccessShareLock);
        state->partitionOid = InvalidOid;
    }
 
    /* Didn't find a relation, so no need for locking or permission checks. */
    if (!OidIsValid(relOid))
        return;
 
    tuple = SearchSysCache1(RELOID, ObjectIdGetDatum(relOid));
    if (!HeapTupleIsValid(tuple))
        return;                 /* concurrently dropped, so nothing to do */
    classform = (Form_pg_class) GETSTRUCT(tuple);
    if (classform->relkind != RELKIND_PARTITIONED_INDEX &&
        classform->relkind != RELKIND_INDEX)
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
                 errmsg("\"%s\" is not an index", rv->relname)));
    ReleaseSysCache(tuple);
 
    /*
     * Since we need only examine the heap's tupledesc, an access share lock
     * on it (preventing any DDL) is sufficient.
     */
    state->partitionOid = IndexGetRelation(relOid, false);
    LockRelationOid(state->partitionOid, AccessShareLock);
}

References AccessShareLock, arg, ereport, errcode(), errmsg(), ERROR, GETSTRUCT, HeapTupleIsValid, IndexGetRelation(), InvalidOid, LockRelationOid(), ObjectIdGetDatum(), OidIsValid, ReleaseSysCache(), RangeVar::relname, SearchSysCache1(), and UnlockRelationOid().

Referenced by ATExecAttachPartitionIdx().

RangeVarCallbackForDropRelation()

static void RangeVarCallbackForDropRelation ( const RangeVar *  rel, Oid  relOid, Oid  oldRelOid, void *  arg  )

static

Definition at line 1648 of file tablecmds.c.

{
    HeapTuple   tuple;
    struct DropRelationCallbackState *state;
    char        expected_relkind;
    bool        is_partition;
    Form_pg_class classform;
    LOCKMODE    heap_lockmode;
    bool        invalid_system_index = false;
 
    state = (struct DropRelationCallbackState *) arg;
    heap_lockmode = state->heap_lockmode;
 
    /*
     * If we previously locked some other index's heap, and the name we're
     * looking up no longer refers to that relation, release the now-useless
     * lock.
     */
    if (relOid != oldRelOid && OidIsValid(state->heapOid))
    {
        UnlockRelationOid(state->heapOid, heap_lockmode);
        state->heapOid = InvalidOid;
    }
 
    /*
     * Similarly, if we previously locked some other partition's heap, and the
     * name we're looking up no longer refers to that relation, release the
     * now-useless lock.
     */
    if (relOid != oldRelOid && OidIsValid(state->partParentOid))
    {
        UnlockRelationOid(state->partParentOid, AccessExclusiveLock);
        state->partParentOid = InvalidOid;
    }
 
    /* Didn't find a relation, so no need for locking or permission checks. */
    if (!OidIsValid(relOid))
        return;
 
    tuple = SearchSysCache1(RELOID, ObjectIdGetDatum(relOid));
    if (!HeapTupleIsValid(tuple))
        return;                 /* concurrently dropped, so nothing to do */
    classform = (Form_pg_class) GETSTRUCT(tuple);
    is_partition = classform->relispartition;
 
    /* Pass back some data to save lookups in RemoveRelations */
    state->actual_relkind = classform->relkind;
    state->actual_relpersistence = classform->relpersistence;
 
    /*
     * Both RELKIND_RELATION and RELKIND_PARTITIONED_TABLE are OBJECT_TABLE,
     * but RemoveRelations() can only pass one relkind for a given relation.
     * It chooses RELKIND_RELATION for both regular and partitioned tables.
     * That means we must be careful before giving the wrong type error when
     * the relation is RELKIND_PARTITIONED_TABLE.  An equivalent problem
     * exists with indexes.
     */
    if (classform->relkind == RELKIND_PARTITIONED_TABLE)
        expected_relkind = RELKIND_RELATION;
    else if (classform->relkind == RELKIND_PARTITIONED_INDEX)
        expected_relkind = RELKIND_INDEX;
    else
        expected_relkind = classform->relkind;
 
    if (state->expected_relkind != expected_relkind)
        DropErrorMsgWrongType(rel->relname, classform->relkind,
                              state->expected_relkind);
 
    /* Allow DROP to either table owner or schema owner */
    if (!object_ownercheck(RelationRelationId, relOid, GetUserId()) &&
        !object_ownercheck(NamespaceRelationId, classform->relnamespace, GetUserId()))
        aclcheck_error(ACLCHECK_NOT_OWNER,
                       get_relkind_objtype(classform->relkind),
                       rel->relname);
 
    /*
     * Check the case of a system index that might have been invalidated by a
     * failed concurrent process and allow its drop. For the time being, this
     * only concerns indexes of toast relations that became invalid during a
     * REINDEX CONCURRENTLY process.
     */
    if (IsSystemClass(relOid, classform) && classform->relkind == RELKIND_INDEX)
    {
        HeapTuple   locTuple;
        Form_pg_index indexform;
        bool        indisvalid;
 
        locTuple = SearchSysCache1(INDEXRELID, ObjectIdGetDatum(relOid));
        if (!HeapTupleIsValid(locTuple))
        {
            ReleaseSysCache(tuple);
            return;
        }
 
        indexform = (Form_pg_index) GETSTRUCT(locTuple);
        indisvalid = indexform->indisvalid;
        ReleaseSysCache(locTuple);
 
        /* Mark object as being an invalid index of system catalogs */
        if (!indisvalid)
            invalid_system_index = true;
    }
 
    /* In the case of an invalid index, it is fine to bypass this check */
    if (!invalid_system_index && !allowSystemTableMods && IsSystemClass(relOid, classform))
        ereport(ERROR,
                (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
                 errmsg("permission denied: \"%s\" is a system catalog",
                        rel->relname)));
 
    ReleaseSysCache(tuple);
 
    /*
     * In DROP INDEX, attempt to acquire lock on the parent table before
     * locking the index.  index_drop() will need this anyway, and since
     * regular queries lock tables before their indexes, we risk deadlock if
     * we do it the other way around.  No error if we don't find a pg_index
     * entry, though --- the relation may have been dropped.  Note that this
     * code will execute for either plain or partitioned indexes.
     */
    if (expected_relkind == RELKIND_INDEX &&
        relOid != oldRelOid)
    {
        state->heapOid = IndexGetRelation(relOid, true);
        if (OidIsValid(state->heapOid))
            LockRelationOid(state->heapOid, heap_lockmode);
    }
 
    /*
     * Similarly, if the relation is a partition, we must acquire lock on its
     * parent before locking the partition.  That's because queries lock the
     * parent before its partitions, so we risk deadlock if we do it the other
     * way around.
     */
    if (is_partition && relOid != oldRelOid)
    {
        state->partParentOid = get_partition_parent(relOid, true);
        if (OidIsValid(state->partParentOid))
            LockRelationOid(state->partParentOid, AccessExclusiveLock);
    }
}

References AccessExclusiveLock, aclcheck_error(), ACLCHECK_NOT_OWNER, allowSystemTableMods, arg, DropErrorMsgWrongType(), ereport, errcode(), errmsg(), ERROR, DropRelationCallbackState::expected_relkind, get_partition_parent(), get_relkind_objtype(), GETSTRUCT, GetUserId(), DropRelationCallbackState::heap_lockmode, HeapTupleIsValid, IndexGetRelation(), InvalidOid, IsSystemClass(), LockRelationOid(), object_ownercheck(), ObjectIdGetDatum(), OidIsValid, ReleaseSysCache(), RangeVar::relname, SearchSysCache1(), and UnlockRelationOid().

Referenced by RemoveRelations().

RangeVarCallbackForRenameAttribute()

static void RangeVarCallbackForRenameAttribute ( const RangeVar *  rv, Oid  relid, Oid  oldrelid, void *  arg  )

static

Definition at line 3922 of file tablecmds.c.

{
    HeapTuple   tuple;
    Form_pg_class form;
 
    tuple = SearchSysCache1(RELOID, ObjectIdGetDatum(relid));
    if (!HeapTupleIsValid(tuple))
        return;                 /* concurrently dropped */
    form = (Form_pg_class) GETSTRUCT(tuple);
    renameatt_check(relid, form, false);
    ReleaseSysCache(tuple);
}

References GETSTRUCT, HeapTupleIsValid, ObjectIdGetDatum(), ReleaseSysCache(), renameatt_check(), and SearchSysCache1().

Referenced by renameatt(), and RenameConstraint().

RangeVarCallbackForTruncate()

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

static

Definition at line 18450 of file tablecmds.c.

{
    HeapTuple   tuple;
 
    /* Nothing to do if the relation was not found. */
    if (!OidIsValid(relId))
        return;
 
    tuple = SearchSysCache1(RELOID, ObjectIdGetDatum(relId));
    if (!HeapTupleIsValid(tuple))   /* should not happen */
        elog(ERROR, "cache lookup failed for relation %u", relId);
 
    truncate_check_rel(relId, (Form_pg_class) GETSTRUCT(tuple));
    truncate_check_perms(relId, (Form_pg_class) GETSTRUCT(tuple));
 
    ReleaseSysCache(tuple);
}

References elog, ERROR, GETSTRUCT, HeapTupleIsValid, ObjectIdGetDatum(), OidIsValid, ReleaseSysCache(), SearchSysCache1(), truncate_check_perms(), and truncate_check_rel().

Referenced by ExecuteTruncate().

RangeVarCallbackMaintainsTable()

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

Definition at line 18414 of file tablecmds.c.

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

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

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

RangeVarCallbackOwnsRelation()

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

Definition at line 18474 of file tablecmds.c.

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

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

Referenced by AlterSequence(), and ProcessUtilitySlow().

RebuildConstraintComment()

static void RebuildConstraintComment ( AlteredTableInfo *  tab, AlterTablePass  pass, Oid  objid, Relation  rel, List *  domname, const char *  conname  )

static

Definition at line 14752 of file tablecmds.c.

{
    CommentStmt *cmd;
    char       *comment_str;
    AlterTableCmd *newcmd;
 
    /* Look for comment for object wanted, and leave if none */
    comment_str = GetComment(objid, ConstraintRelationId, 0);
    if (comment_str == NULL)
        return;
 
    /* Build CommentStmt node, copying all input data for safety */
    cmd = makeNode(CommentStmt);
    if (rel)
    {
        cmd->objtype = OBJECT_TABCONSTRAINT;
        cmd->object = (Node *)
            list_make3(makeString(get_namespace_name(RelationGetNamespace(rel))),
                       makeString(pstrdup(RelationGetRelationName(rel))),
                       makeString(pstrdup(conname)));
    }
    else
    {
        cmd->objtype = OBJECT_DOMCONSTRAINT;
        cmd->object = (Node *)
            list_make2(makeTypeNameFromNameList(copyObject(domname)),
                       makeString(pstrdup(conname)));
    }
    cmd->comment = comment_str;
 
    /* Append it to list of commands */
    newcmd = makeNode(AlterTableCmd);
    newcmd->subtype = AT_ReAddComment;
    newcmd->def = (Node *) cmd;
    tab->subcmds[pass] = lappend(tab->subcmds[pass], newcmd);
}

References AT_ReAddComment, CommentStmt::comment, copyObject, AlterTableCmd::def, get_namespace_name(), GetComment(), lappend(), list_make2, list_make3, makeNode, makeString(), makeTypeNameFromNameList(), CommentStmt::object, OBJECT_DOMCONSTRAINT, OBJECT_TABCONSTRAINT, CommentStmt::objtype, pstrdup(), RelationGetNamespace, RelationGetRelationName, AlteredTableInfo::subcmds, and AlterTableCmd::subtype.

Referenced by ATPostAlterTypeParse().

refuseDupeIndexAttach()

static void refuseDupeIndexAttach ( Relation  parentIdx, Relation  partIdx, Relation  partitionTbl  )

static

Definition at line 20614 of file tablecmds.c.

{
    Oid         existingIdx;
 
    existingIdx = index_get_partition(partitionTbl,
                                      RelationGetRelid(parentIdx));
    if (OidIsValid(existingIdx))
        ereport(ERROR,
                (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
                 errmsg("cannot attach index \"%s\" as a partition of index \"%s\"",
                        RelationGetRelationName(partIdx),
                        RelationGetRelationName(parentIdx)),
                 errdetail("Another index is already attached for partition \"%s\".",
                           RelationGetRelationName(partitionTbl))));
}

References ereport, errcode(), errdetail(), errmsg(), ERROR, index_get_partition(), OidIsValid, RelationGetRelationName, and RelationGetRelid.

Referenced by ATExecAttachPartitionIdx().

register_on_commit_action()

void register_on_commit_action	(	Oid	relid,
		OnCommitAction	action
	)

Definition at line 18181 of file tablecmds.c.

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

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

Referenced by heap_create_with_catalog().

relation_mark_replica_identity()

static void relation_mark_replica_identity ( Relation  rel, char  ri_type, Oid  indexOid, bool  is_internal  )

static

Definition at line 17341 of file tablecmds.c.

{
    Relation    pg_index;
    Relation    pg_class;
    HeapTuple   pg_class_tuple;
    HeapTuple   pg_index_tuple;
    Form_pg_class pg_class_form;
    Form_pg_index pg_index_form;
    ListCell   *index;
 
    /*
     * Check whether relreplident has changed, and update it if so.
     */
    pg_class = table_open(RelationRelationId, RowExclusiveLock);
    pg_class_tuple = SearchSysCacheCopy1(RELOID,
                                         ObjectIdGetDatum(RelationGetRelid(rel)));
    if (!HeapTupleIsValid(pg_class_tuple))
        elog(ERROR, "cache lookup failed for relation \"%s\"",
             RelationGetRelationName(rel));
    pg_class_form = (Form_pg_class) GETSTRUCT(pg_class_tuple);
    if (pg_class_form->relreplident != ri_type)
    {
        pg_class_form->relreplident = ri_type;
        CatalogTupleUpdate(pg_class, &pg_class_tuple->t_self, pg_class_tuple);
    }
    table_close(pg_class, RowExclusiveLock);
    heap_freetuple(pg_class_tuple);
 
    /*
     * Update the per-index indisreplident flags correctly.
     */
    pg_index = table_open(IndexRelationId, RowExclusiveLock);
    foreach(index, RelationGetIndexList(rel))
    {
        Oid         thisIndexOid = lfirst_oid(index);
        bool        dirty = false;
 
        pg_index_tuple = SearchSysCacheCopy1(INDEXRELID,
                                             ObjectIdGetDatum(thisIndexOid));
        if (!HeapTupleIsValid(pg_index_tuple))
            elog(ERROR, "cache lookup failed for index %u", thisIndexOid);
        pg_index_form = (Form_pg_index) GETSTRUCT(pg_index_tuple);
 
        if (thisIndexOid == indexOid)
        {
            /* Set the bit if not already set. */
            if (!pg_index_form->indisreplident)
            {
                dirty = true;
                pg_index_form->indisreplident = true;
            }
        }
        else
        {
            /* Unset the bit if set. */
            if (pg_index_form->indisreplident)
            {
                dirty = true;
                pg_index_form->indisreplident = false;
            }
        }
 
        if (dirty)
        {
            CatalogTupleUpdate(pg_index, &pg_index_tuple->t_self, pg_index_tuple);
            InvokeObjectPostAlterHookArg(IndexRelationId, thisIndexOid, 0,
                                         InvalidOid, is_internal);
 
            /*
             * Invalidate the relcache for the table, so that after we commit
             * all sessions will refresh the table's replica identity index
             * before attempting any UPDATE or DELETE on the table.  (If we
             * changed the table's pg_class row above, then a relcache inval
             * is already queued due to that; but we might not have.)
             */
            CacheInvalidateRelcache(rel);
        }
        heap_freetuple(pg_index_tuple);
    }
 
    table_close(pg_index, RowExclusiveLock);
}

References CacheInvalidateRelcache(), CatalogTupleUpdate(), elog, ERROR, GETSTRUCT, heap_freetuple(), HeapTupleIsValid, InvalidOid, InvokeObjectPostAlterHookArg, lfirst_oid, ObjectIdGetDatum(), RelationGetIndexList(), RelationGetRelationName, RelationGetRelid, RowExclusiveLock, SearchSysCacheCopy1, HeapTupleData::t_self, table_close(), and table_open().

Referenced by ATExecReplicaIdentity().

RememberAllDependentForRebuilding()

static void RememberAllDependentForRebuilding ( AlteredTableInfo *  tab, AlterTableType  subtype, Relation  rel, AttrNumber  attnum, const char *  colName  )

static

Definition at line 14026 of file tablecmds.c.

{
    Relation    depRel;
    ScanKeyData key[3];
    SysScanDesc scan;
    HeapTuple   depTup;
 
    Assert(subtype == AT_AlterColumnType || subtype == AT_SetExpression);
 
    depRel = table_open(DependRelationId, RowExclusiveLock);
 
    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)));
    ScanKeyInit(&key[2],
                Anum_pg_depend_refobjsubid,
                BTEqualStrategyNumber, F_INT4EQ,
                Int32GetDatum((int32) attnum));
 
    scan = systable_beginscan(depRel, DependReferenceIndexId, true,
                              NULL, 3, key);
 
    while (HeapTupleIsValid(depTup = systable_getnext(scan)))
    {
        Form_pg_depend foundDep = (Form_pg_depend) GETSTRUCT(depTup);
        ObjectAddress foundObject;
 
        foundObject.classId = foundDep->classid;
        foundObject.objectId = foundDep->objid;
        foundObject.objectSubId = foundDep->objsubid;
 
        switch (foundObject.classId)
        {
            case RelationRelationId:
                {
                    char        relKind = get_rel_relkind(foundObject.objectId);
 
                    if (relKind == RELKIND_INDEX ||
                        relKind == RELKIND_PARTITIONED_INDEX)
                    {
                        Assert(foundObject.objectSubId == 0);
                        RememberIndexForRebuilding(foundObject.objectId, tab);
                    }
                    else if (relKind == RELKIND_SEQUENCE)
                    {
                        /*
                         * This must be a SERIAL column's sequence.  We need
                         * not do anything to it.
                         */
                        Assert(foundObject.objectSubId == 0);
                    }
                    else
                    {
                        /* Not expecting any other direct dependencies... */
                        elog(ERROR, "unexpected object depending on column: %s",
                             getObjectDescription(&foundObject, false));
                    }
                    break;
                }
 
            case ConstraintRelationId:
                Assert(foundObject.objectSubId == 0);
                RememberConstraintForRebuilding(foundObject.objectId, tab);
                break;
 
            case RewriteRelationId:
                /* XXX someday see if we can cope with revising views */
                if (subtype == AT_AlterColumnType)
                    ereport(ERROR,
                            (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                             errmsg("cannot alter type of a column used by a view or rule"),
                             errdetail("%s depends on column \"%s\"",
                                       getObjectDescription(&foundObject, false),
                                       colName)));
                break;
 
            case TriggerRelationId:
 
                /*
                 * A trigger can depend on a column because the column is
                 * specified as an update target, or because the column is
                 * used in the trigger's WHEN condition.  The first case would
                 * not require any extra work, but the second case would
                 * require updating the WHEN expression, which will take a
                 * significant amount of new code.  Since we can't easily tell
                 * which case applies, we punt for both.  FIXME someday.
                 */
                if (subtype == AT_AlterColumnType)
                    ereport(ERROR,
                            (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                             errmsg("cannot alter type of a column used in a trigger definition"),
                             errdetail("%s depends on column \"%s\"",
                                       getObjectDescription(&foundObject, false),
                                       colName)));
                break;
 
            case PolicyRelationId:
 
                /*
                 * A policy can depend on a column because the column is
                 * specified in the policy's USING or WITH CHECK qual
                 * expressions.  It might be possible to rewrite and recheck
                 * the policy expression, but punt for now.  It's certainly
                 * easy enough to remove and recreate the policy; still, FIXME
                 * someday.
                 */
                if (subtype == AT_AlterColumnType)
                    ereport(ERROR,
                            (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                             errmsg("cannot alter type of a column used in a policy definition"),
                             errdetail("%s depends on column \"%s\"",
                                       getObjectDescription(&foundObject, false),
                                       colName)));
                break;
 
            case AttrDefaultRelationId:
                {
                    ObjectAddress col = GetAttrDefaultColumnAddress(foundObject.objectId);
 
                    if (col.objectId == RelationGetRelid(rel) &&
                        col.objectSubId == attnum)
                    {
                        /*
                         * Ignore the column's own default expression.  The
                         * caller deals with it.
                         */
                    }
                    else
                    {
                        /*
                         * This must be a reference from the expression of a
                         * generated column elsewhere in the same table.
                         * Changing the type/generated expression of a column
                         * that is used by a generated column is not allowed
                         * by SQL standard, so just punt for now.  It might be
                         * doable with some thinking and effort.
                         */
                        if (subtype == AT_AlterColumnType)
                            ereport(ERROR,
                                    (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                                     errmsg("cannot alter type of a column used by a generated column"),
                                     errdetail("Column \"%s\" is used by generated column \"%s\".",
                                               colName,
                                               get_attname(col.objectId,
                                                           col.objectSubId,
                                                           false))));
                    }
                    break;
                }
 
            case StatisticExtRelationId:
 
                /*
                 * Give the extended-stats machinery a chance to fix anything
                 * that this column type change would break.
                 */
                RememberStatisticsForRebuilding(foundObject.objectId, tab);
                break;
 
            default:
 
                /*
                 * We don't expect any other sorts of objects to depend on a
                 * column.
                 */
                elog(ERROR, "unexpected object depending on column: %s",
                     getObjectDescription(&foundObject, false));
                break;
        }
    }
 
    systable_endscan(scan);
    table_close(depRel, NoLock);
}

References Assert, AT_AlterColumnType, AT_SetExpression, attnum, BTEqualStrategyNumber, ObjectAddress::classId, elog, ereport, errcode(), errdetail(), errmsg(), ERROR, get_attname(), get_rel_relkind(), GetAttrDefaultColumnAddress(), getObjectDescription(), GETSTRUCT, HeapTupleIsValid, Int32GetDatum(), sort-test::key, NoLock, ObjectAddress::objectId, ObjectIdGetDatum(), ObjectAddress::objectSubId, RelationGetRelid, RememberConstraintForRebuilding(), RememberIndexForRebuilding(), RememberStatisticsForRebuilding(), RowExclusiveLock, ScanKeyInit(), systable_beginscan(), systable_endscan(), systable_getnext(), table_close(), and table_open().

Referenced by ATExecAlterColumnType(), and ATExecSetExpression().

RememberClusterOnForRebuilding()

static void RememberClusterOnForRebuilding ( Oid  indoid, AlteredTableInfo *  tab  )

static

Definition at line 14227 of file tablecmds.c.

{
    if (!get_index_isclustered(indoid))
        return;
 
    if (tab->clusterOnIndex)
        elog(ERROR, "relation %u has multiple clustered indexes", tab->relid);
 
    tab->clusterOnIndex = get_rel_name(indoid);
}

References AlteredTableInfo::clusterOnIndex, elog, ERROR, get_index_isclustered(), get_rel_name(), and AlteredTableInfo::relid.

Referenced by RememberConstraintForRebuilding(), and RememberIndexForRebuilding().

RememberConstraintForRebuilding()

static void RememberConstraintForRebuilding ( Oid  conoid, AlteredTableInfo *  tab  )

static

Definition at line 14243 of file tablecmds.c.

{
    /*
     * This de-duplication check is critical for two independent reasons: we
     * mustn't try to recreate the same constraint twice, and if a constraint
     * depends on more than one column whose type is to be altered, we must
     * capture its definition string before applying any of the column type
     * changes.  ruleutils.c will get confused if we ask again later.
     */
    if (!list_member_oid(tab->changedConstraintOids, conoid))
    {
        /* OK, capture the constraint's existing definition string */
        char       *defstring = pg_get_constraintdef_command(conoid);
        Oid         indoid;
 
        tab->changedConstraintOids = lappend_oid(tab->changedConstraintOids,
                                                 conoid);
        tab->changedConstraintDefs = lappend(tab->changedConstraintDefs,
                                             defstring);
 
        /*
         * For the index of a constraint, if any, remember if it is used for
         * the table's replica identity or if it is a clustered index, so that
         * ATPostAlterTypeCleanup() can queue up commands necessary to restore
         * those properties.
         */
        indoid = get_constraint_index(conoid);
        if (OidIsValid(indoid))
        {
            RememberReplicaIdentityForRebuilding(indoid, tab);
            RememberClusterOnForRebuilding(indoid, tab);
        }
    }
}

References AlteredTableInfo::changedConstraintDefs, AlteredTableInfo::changedConstraintOids, get_constraint_index(), lappend(), lappend_oid(), list_member_oid(), OidIsValid, pg_get_constraintdef_command(), RememberClusterOnForRebuilding(), and RememberReplicaIdentityForRebuilding().

Referenced by RememberAllDependentForRebuilding(), and RememberIndexForRebuilding().

RememberIndexForRebuilding()

static void RememberIndexForRebuilding ( Oid  indoid, AlteredTableInfo *  tab  )

static

Definition at line 14283 of file tablecmds.c.

{
    /*
     * This de-duplication check is critical for two independent reasons: we
     * mustn't try to recreate the same index twice, and if an index depends
     * on more than one column whose type is to be altered, we must capture
     * its definition string before applying any of the column type changes.
     * ruleutils.c will get confused if we ask again later.
     */
    if (!list_member_oid(tab->changedIndexOids, indoid))
    {
        /*
         * Before adding it as an index-to-rebuild, we'd better see if it
         * belongs to a constraint, and if so rebuild the constraint instead.
         * Typically this check fails, because constraint indexes normally
         * have only dependencies on their constraint.  But it's possible for
         * such an index to also have direct dependencies on table columns,
         * for example with a partial exclusion constraint.
         */
        Oid         conoid = get_index_constraint(indoid);
 
        if (OidIsValid(conoid))
        {
            RememberConstraintForRebuilding(conoid, tab);
        }
        else
        {
            /* OK, capture the index's existing definition string */
            char       *defstring = pg_get_indexdef_string(indoid);
 
            tab->changedIndexOids = lappend_oid(tab->changedIndexOids,
                                                indoid);
            tab->changedIndexDefs = lappend(tab->changedIndexDefs,
                                            defstring);
 
            /*
             * Remember if this index is used for the table's replica identity
             * or if it is a clustered index, so that ATPostAlterTypeCleanup()
             * can queue up commands necessary to restore those properties.
             */
            RememberReplicaIdentityForRebuilding(indoid, tab);
            RememberClusterOnForRebuilding(indoid, tab);
        }
    }
}

References AlteredTableInfo::changedIndexDefs, AlteredTableInfo::changedIndexOids, get_index_constraint(), lappend(), lappend_oid(), list_member_oid(), OidIsValid, pg_get_indexdef_string(), RememberClusterOnForRebuilding(), RememberConstraintForRebuilding(), and RememberReplicaIdentityForRebuilding().

Referenced by RememberAllDependentForRebuilding().

RememberReplicaIdentityForRebuilding()

static void RememberReplicaIdentityForRebuilding ( Oid  indoid, AlteredTableInfo *  tab  )

static

Definition at line 14212 of file tablecmds.c.

{
    if (!get_index_isreplident(indoid))
        return;
 
    if (tab->replicaIdentityIndex)
        elog(ERROR, "relation %u has multiple indexes marked as replica identity", tab->relid);
 
    tab->replicaIdentityIndex = get_rel_name(indoid);
}

References elog, ERROR, get_index_isreplident(), get_rel_name(), AlteredTableInfo::relid, and AlteredTableInfo::replicaIdentityIndex.

Referenced by RememberConstraintForRebuilding(), and RememberIndexForRebuilding().

RememberStatisticsForRebuilding()

static void RememberStatisticsForRebuilding ( Oid  stxoid, AlteredTableInfo *  tab  )

static

Definition at line 14334 of file tablecmds.c.

{
    /*
     * This de-duplication check is critical for two independent reasons: we
     * mustn't try to recreate the same statistics object twice, and if the
     * statistics object depends on more than one column whose type is to be
     * altered, we must capture its definition string before applying any of
     * the type changes. ruleutils.c will get confused if we ask again later.
     */
    if (!list_member_oid(tab->changedStatisticsOids, stxoid))
    {
        /* OK, capture the statistics object's existing definition string */
        char       *defstring = pg_get_statisticsobjdef_string(stxoid);
 
        tab->changedStatisticsOids = lappend_oid(tab->changedStatisticsOids,
                                                 stxoid);
        tab->changedStatisticsDefs = lappend(tab->changedStatisticsDefs,
                                             defstring);
    }
}

References AlteredTableInfo::changedStatisticsDefs, AlteredTableInfo::changedStatisticsOids, lappend(), lappend_oid(), list_member_oid(), and pg_get_statisticsobjdef_string().

Referenced by RememberAllDependentForRebuilding().

remove_on_commit_action()

void remove_on_commit_action

(

Oid

relid

)

Definition at line 18217 of file tablecmds.c.

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

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

Referenced by heap_drop_with_catalog().

RemoveInheritance()

static void RemoveInheritance ( Relation  child_rel, Relation  parent_rel, bool  expect_detached  )

static

Definition at line 16861 of file tablecmds.c.

{
    Relation    catalogRelation;
    SysScanDesc scan;
    ScanKeyData key[3];
    HeapTuple   attributeTuple,
                constraintTuple;
    List       *connames;
    List       *nncolumns;
    bool        found;
    bool        is_partitioning;
 
    is_partitioning = (parent_rel->rd_rel->relkind == RELKIND_PARTITIONED_TABLE);
 
    found = DeleteInheritsTuple(RelationGetRelid(child_rel),
                                RelationGetRelid(parent_rel),
                                expect_detached,
                                RelationGetRelationName(child_rel));
    if (!found)
    {
        if (is_partitioning)
            ereport(ERROR,
                    (errcode(ERRCODE_UNDEFINED_TABLE),
                     errmsg("relation \"%s\" is not a partition of relation \"%s\"",
                            RelationGetRelationName(child_rel),
                            RelationGetRelationName(parent_rel))));
        else
            ereport(ERROR,
                    (errcode(ERRCODE_UNDEFINED_TABLE),
                     errmsg("relation \"%s\" is not a parent of relation \"%s\"",
                            RelationGetRelationName(parent_rel),
                            RelationGetRelationName(child_rel))));
    }
 
    /*
     * Search through child columns looking for ones matching parent rel
     */
    catalogRelation = table_open(AttributeRelationId, RowExclusiveLock);
    ScanKeyInit(&key[0],
                Anum_pg_attribute_attrelid,
                BTEqualStrategyNumber, F_OIDEQ,
                ObjectIdGetDatum(RelationGetRelid(child_rel)));
    scan = systable_beginscan(catalogRelation, AttributeRelidNumIndexId,
                              true, NULL, 1, key);
    while (HeapTupleIsValid(attributeTuple = systable_getnext(scan)))
    {
        Form_pg_attribute att = (Form_pg_attribute) GETSTRUCT(attributeTuple);
 
        /* Ignore if dropped or not inherited */
        if (att->attisdropped)
            continue;
        if (att->attinhcount <= 0)
            continue;
 
        if (SearchSysCacheExistsAttName(RelationGetRelid(parent_rel),
                                        NameStr(att->attname)))
        {
            /* Decrement inhcount and possibly set islocal to true */
            HeapTuple   copyTuple = heap_copytuple(attributeTuple);
            Form_pg_attribute copy_att = (Form_pg_attribute) GETSTRUCT(copyTuple);
 
            copy_att->attinhcount--;
            if (copy_att->attinhcount == 0)
                copy_att->attislocal = true;
 
            CatalogTupleUpdate(catalogRelation, &copyTuple->t_self, copyTuple);
            heap_freetuple(copyTuple);
        }
    }
    systable_endscan(scan);
    table_close(catalogRelation, RowExclusiveLock);
 
    /*
     * Likewise, find inherited check constraints and disinherit them. To do
     * this, we first need a list of the names of the parent's check
     * constraints.  (We cheat a bit by only checking for name matches,
     * assuming that the expressions will match.)
     *
     * For NOT NULL columns, we store column numbers to match.
     */
    catalogRelation = table_open(ConstraintRelationId, RowExclusiveLock);
    ScanKeyInit(&key[0],
                Anum_pg_constraint_conrelid,
                BTEqualStrategyNumber, F_OIDEQ,
                ObjectIdGetDatum(RelationGetRelid(parent_rel)));
    scan = systable_beginscan(catalogRelation, ConstraintRelidTypidNameIndexId,
                              true, NULL, 1, key);
 
    connames = NIL;
    nncolumns = NIL;
 
    while (HeapTupleIsValid(constraintTuple = systable_getnext(scan)))
    {
        Form_pg_constraint con = (Form_pg_constraint) GETSTRUCT(constraintTuple);
 
        if (con->contype == CONSTRAINT_CHECK)
            connames = lappend(connames, pstrdup(NameStr(con->conname)));
        if (con->contype == CONSTRAINT_NOTNULL)
            nncolumns = lappend_int(nncolumns, extractNotNullColumn(constraintTuple));
    }
 
    systable_endscan(scan);
 
    /* Now scan the child's constraints */
    ScanKeyInit(&key[0],
                Anum_pg_constraint_conrelid,
                BTEqualStrategyNumber, F_OIDEQ,
                ObjectIdGetDatum(RelationGetRelid(child_rel)));
    scan = systable_beginscan(catalogRelation, ConstraintRelidTypidNameIndexId,
                              true, NULL, 1, key);
 
    while (HeapTupleIsValid(constraintTuple = systable_getnext(scan)))
    {
        Form_pg_constraint con = (Form_pg_constraint) GETSTRUCT(constraintTuple);
        bool        match = false;
        ListCell   *lc;
 
        /*
         * Match CHECK constraints by name, not-null constraints by column
         * number, and ignore all others.
         */
        if (con->contype == CONSTRAINT_CHECK)
        {
            foreach(lc, connames)
            {
                if (con->contype == CONSTRAINT_CHECK &&
                    strcmp(NameStr(con->conname), (char *) lfirst(lc)) == 0)
                {
                    match = true;
                    break;
                }
            }
        }
        else if (con->contype == CONSTRAINT_NOTNULL)
        {
            AttrNumber  child_attno = extractNotNullColumn(constraintTuple);
 
            foreach(lc, nncolumns)
            {
                if (lfirst_int(lc) == child_attno)
                {
                    match = true;
                    break;
                }
            }
        }
        else
            continue;
 
        if (match)
        {
            /* Decrement inhcount and possibly set islocal to true */
            HeapTuple   copyTuple = heap_copytuple(constraintTuple);
            Form_pg_constraint copy_con = (Form_pg_constraint) GETSTRUCT(copyTuple);
 
            if (copy_con->coninhcount <= 0) /* shouldn't happen */
                elog(ERROR, "relation %u has non-inherited constraint \"%s\"",
                     RelationGetRelid(child_rel), NameStr(copy_con->conname));
 
            copy_con->coninhcount--;
            if (copy_con->coninhcount == 0)
                copy_con->conislocal = true;
 
            CatalogTupleUpdate(catalogRelation, &copyTuple->t_self, copyTuple);
            heap_freetuple(copyTuple);
        }
    }
 
    systable_endscan(scan);
    table_close(catalogRelation, RowExclusiveLock);
 
    drop_parent_dependency(RelationGetRelid(child_rel),
                           RelationRelationId,
                           RelationGetRelid(parent_rel),
                           child_dependency_type(is_partitioning));
 
    /*
     * Post alter hook of this inherits. Since object_access_hook doesn't take
     * multiple object identifiers, we relay oid of parent relation using
     * auxiliary_id argument.
     */
    InvokeObjectPostAlterHookArg(InheritsRelationId,
                                 RelationGetRelid(child_rel), 0,
                                 RelationGetRelid(parent_rel), false);
}

References BTEqualStrategyNumber, CatalogTupleUpdate(), child_dependency_type, DeleteInheritsTuple(), drop_parent_dependency(), elog, ereport, errcode(), ERRCODE_UNDEFINED_TABLE, errmsg(), ERROR, extractNotNullColumn(), GETSTRUCT, heap_copytuple(), heap_freetuple(), HeapTupleIsValid, InvokeObjectPostAlterHookArg, sort-test::key, lappend(), lappend_int(), lfirst, lfirst_int, NameStr, NIL, ObjectIdGetDatum(), pstrdup(), RelationData::rd_rel, RelationGetRelationName, RelationGetRelid, RowExclusiveLock, ScanKeyInit(), SearchSysCacheExistsAttName(), systable_beginscan(), systable_endscan(), systable_getnext(), HeapTupleData::t_self, table_close(), and table_open().

Referenced by ATExecDetachPartition(), ATExecDropInherit(), ATExecMergePartitions(), ATExecSplitPartition(), and DetachPartitionFinalize().

RemoveRelations()

void RemoveRelations

(

DropStmt *

drop

)

Definition at line 1484 of file tablecmds.c.

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

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

Referenced by ExecDropStmt().

rename_constraint_internal()

static ObjectAddress rename_constraint_internal ( Oid  myrelid, Oid  mytypid, const char *  oldconname, const char *  newconname, bool  recurse, bool  recursing, int  expected_parents  )

static

Definition at line 3980 of file tablecmds.c.

{
    Relation    targetrelation = NULL;
    Oid         constraintOid;
    HeapTuple   tuple;
    Form_pg_constraint con;
    ObjectAddress address;
 
    Assert(!myrelid || !mytypid);
 
    if (mytypid)
    {
        constraintOid = get_domain_constraint_oid(mytypid, oldconname, false);
    }
    else
    {
        targetrelation = relation_open(myrelid, AccessExclusiveLock);
 
        /*
         * don't tell it whether we're recursing; we allow changing typed
         * tables here
         */
        renameatt_check(myrelid, RelationGetForm(targetrelation), false);
 
        constraintOid = get_relation_constraint_oid(myrelid, oldconname, false);
    }
 
    tuple = SearchSysCache1(CONSTROID, ObjectIdGetDatum(constraintOid));
    if (!HeapTupleIsValid(tuple))
        elog(ERROR, "cache lookup failed for constraint %u",
             constraintOid);
    con = (Form_pg_constraint) GETSTRUCT(tuple);
 
    if (myrelid &&
        (con->contype == CONSTRAINT_CHECK ||
         con->contype == CONSTRAINT_NOTNULL) &&
        !con->connoinherit)
    {
        if (recurse)
        {
            List       *child_oids,
                       *child_numparents;
            ListCell   *lo,
                       *li;
 
            child_oids = find_all_inheritors(myrelid, AccessExclusiveLock,
                                             &child_numparents);
 
            forboth(lo, child_oids, li, child_numparents)
            {
                Oid         childrelid = lfirst_oid(lo);
                int         numparents = lfirst_int(li);
 
                if (childrelid == myrelid)
                    continue;
 
                rename_constraint_internal(childrelid, InvalidOid, oldconname, newconname, false, true, numparents);
            }
        }
        else
        {
            if (expected_parents == 0 &&
                find_inheritance_children(myrelid, NoLock) != NIL)
                ereport(ERROR,
                        (errcode(ERRCODE_INVALID_TABLE_DEFINITION),
                         errmsg("inherited constraint \"%s\" must be renamed in child tables too",
                                oldconname)));
        }
 
        if (con->coninhcount > expected_parents)
            ereport(ERROR,
                    (errcode(ERRCODE_INVALID_TABLE_DEFINITION),
                     errmsg("cannot rename inherited constraint \"%s\"",
                            oldconname)));
    }
 
    if (con->conindid
        && (con->contype == CONSTRAINT_PRIMARY
            || con->contype == CONSTRAINT_UNIQUE
            || con->contype == CONSTRAINT_EXCLUSION))
        /* rename the index; this renames the constraint as well */
        RenameRelationInternal(con->conindid, newconname, false, true);
    else
        RenameConstraintById(constraintOid, newconname);
 
    ObjectAddressSet(address, ConstraintRelationId, constraintOid);
 
    ReleaseSysCache(tuple);
 
    if (targetrelation)
    {
        /*
         * Invalidate relcache so as others can see the new constraint name.
         */
        CacheInvalidateRelcache(targetrelation);
 
        relation_close(targetrelation, NoLock); /* close rel but keep lock */
    }
 
    return address;
}

References AccessExclusiveLock, Assert, CacheInvalidateRelcache(), elog, ereport, errcode(), errmsg(), ERROR, find_all_inheritors(), find_inheritance_children(), forboth, get_domain_constraint_oid(), get_relation_constraint_oid(), GETSTRUCT, HeapTupleIsValid, InvalidOid, lfirst_int, lfirst_oid, NIL, NoLock, ObjectAddressSet, ObjectIdGetDatum(), relation_close(), relation_open(), RelationGetForm, ReleaseSysCache(), renameatt_check(), RenameConstraintById(), RenameRelationInternal(), and SearchSysCache1().

Referenced by RenameConstraint().

renameatt()

ObjectAddress renameatt

(

RenameStmt *

stmt

)

Definition at line 3942 of file tablecmds.c.

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

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

Referenced by ExecRenameStmt().

renameatt_check()

static void renameatt_check ( Oid  myrelid, Form_pg_class  classform, bool  recursing  )

static

Definition at line 3728 of file tablecmds.c.

{
    char        relkind = classform->relkind;
 
    if (classform->reloftype && !recursing)
        ereport(ERROR,
                (errcode(ERRCODE_WRONG_OBJECT_TYPE),
                 errmsg("cannot rename column of typed table")));
 
    /*
     * Renaming the columns of sequences or toast tables doesn't actually
     * break anything from the system's point of view, since internal
     * references are by attnum.  But it doesn't seem right to allow users to
     * change names that are hardcoded into the system, hence the following
     * restriction.
     */
    if (relkind != RELKIND_RELATION &&
        relkind != RELKIND_VIEW &&
        relkind != RELKIND_MATVIEW &&
        relkind != RELKIND_COMPOSITE_TYPE &&
        relkind != RELKIND_INDEX &&
        relkind != RELKIND_PARTITIONED_INDEX &&
        relkind != RELKIND_FOREIGN_TABLE &&
        relkind != RELKIND_PARTITIONED_TABLE)
        ereport(ERROR,
                (errcode(ERRCODE_WRONG_OBJECT_TYPE),
                 errmsg("cannot rename columns of relation \"%s\"",
                        NameStr(classform->relname)),
                 errdetail_relkind_not_supported(relkind)));
 
    /*
     * permissions checking.  only the owner of a class can change its schema.
     */
    if (!object_ownercheck(RelationRelationId, myrelid, GetUserId()))
        aclcheck_error(ACLCHECK_NOT_OWNER, get_relkind_objtype(get_rel_relkind(myrelid)),
                       NameStr(classform->relname));
    if (!allowSystemTableMods && IsSystemClass(myrelid, classform))
        ereport(ERROR,
                (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
                 errmsg("permission denied: \"%s\" is a system catalog",
                        NameStr(classform->relname))));
}

References aclcheck_error(), ACLCHECK_NOT_OWNER, allowSystemTableMods, ereport, errcode(), errdetail_relkind_not_supported(), errmsg(), ERROR, get_rel_relkind(), get_relkind_objtype(), GetUserId(), IsSystemClass(), NameStr, and object_ownercheck().

Referenced by RangeVarCallbackForRenameAttribute(), rename_constraint_internal(), and renameatt_internal().

renameatt_internal()

static AttrNumber renameatt_internal ( Oid  myrelid, const char *  oldattname, const char *  newattname, bool  recurse, bool  recursing, int  expected_parents, DropBehavior  behavior  )

static

Definition at line 3777 of file tablecmds.c.

{
    Relation    targetrelation;
    Relation    attrelation;
    HeapTuple   atttup;
    Form_pg_attribute attform;
    AttrNumber  attnum;
 
    /*
     * Grab an exclusive lock on the target table, which we will NOT release
     * until end of transaction.
     */
    targetrelation = relation_open(myrelid, AccessExclusiveLock);
    renameatt_check(myrelid, RelationGetForm(targetrelation), recursing);
 
    /*
     * if the 'recurse' flag is set then we are supposed to rename this
     * attribute in all classes that inherit from 'relname' (as well as in
     * 'relname').
     *
     * any permissions or problems with duplicate attributes will cause the
     * whole transaction to abort, which is what we want -- all or nothing.
     */
    if (recurse)
    {
        List       *child_oids,
                   *child_numparents;
        ListCell   *lo,
                   *li;
 
        /*
         * we need the number of parents for each child so that the recursive
         * calls to renameatt() can determine whether there are any parents
         * outside the inheritance hierarchy being processed.
         */
        child_oids = find_all_inheritors(myrelid, AccessExclusiveLock,
                                         &child_numparents);
 
        /*
         * find_all_inheritors does the recursive search of the inheritance
         * hierarchy, so all we have to do is process all of the relids in the
         * list that it returns.
         */
        forboth(lo, child_oids, li, child_numparents)
        {
            Oid         childrelid = lfirst_oid(lo);
            int         numparents = lfirst_int(li);
 
            if (childrelid == myrelid)
                continue;
            /* note we need not recurse again */
            renameatt_internal(childrelid, oldattname, newattname, false, true, numparents, behavior);
        }
    }
    else
    {
        /*
         * If we are told not to recurse, there had better not be any child
         * tables; else the rename would put them out of step.
         *
         * expected_parents will only be 0 if we are not already recursing.
         */
        if (expected_parents == 0 &&
            find_inheritance_children(myrelid, NoLock) != NIL)
            ereport(ERROR,
                    (errcode(ERRCODE_INVALID_TABLE_DEFINITION),
                     errmsg("inherited column \"%s\" must be renamed in child tables too",
                            oldattname)));
    }
 
    /* rename attributes in typed tables of composite type */
    if (targetrelation->rd_rel->relkind == RELKIND_COMPOSITE_TYPE)
    {
        List       *child_oids;
        ListCell   *lo;
 
        child_oids = find_typed_table_dependencies(targetrelation->rd_rel->reltype,
                                                   RelationGetRelationName(targetrelation),
                                                   behavior);
 
        foreach(lo, child_oids)
            renameatt_internal(lfirst_oid(lo), oldattname, newattname, true, true, 0, behavior);
    }
 
    attrelation = table_open(AttributeRelationId, RowExclusiveLock);
 
    atttup = SearchSysCacheCopyAttName(myrelid, oldattname);
    if (!HeapTupleIsValid(atttup))
        ereport(ERROR,
                (errcode(ERRCODE_UNDEFINED_COLUMN),
                 errmsg("column \"%s\" does not exist",
                        oldattname)));
    attform = (Form_pg_attribute) GETSTRUCT(atttup);
 
    attnum = attform->attnum;
    if (attnum <= 0)
        ereport(ERROR,
                (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                 errmsg("cannot rename system column \"%s\"",
                        oldattname)));
 
    /*
     * if the attribute is inherited, forbid the renaming.  if this is a
     * top-level call to renameatt(), then expected_parents will be 0, so the
     * effect of this code will be to prohibit the renaming if the attribute
     * is inherited at all.  if this is a recursive call to renameatt(),
     * expected_parents will be the number of parents the current relation has
     * within the inheritance hierarchy being processed, so we'll prohibit the
     * renaming only if there are additional parents from elsewhere.
     */
    if (attform->attinhcount > expected_parents)
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_TABLE_DEFINITION),
                 errmsg("cannot rename inherited column \"%s\"",
                        oldattname)));
 
    /* new name should not already exist */
    (void) check_for_column_name_collision(targetrelation, newattname, false);
 
    /* apply the update */
    namestrcpy(&(attform->attname), newattname);
 
    CatalogTupleUpdate(attrelation, &atttup->t_self, atttup);
 
    InvokeObjectPostAlterHook(RelationRelationId, myrelid, attnum);
 
    heap_freetuple(atttup);
 
    table_close(attrelation, RowExclusiveLock);
 
    relation_close(targetrelation, NoLock); /* close rel but keep lock */
 
    return attnum;
}

References AccessExclusiveLock, attnum, CatalogTupleUpdate(), check_for_column_name_collision(), ereport, errcode(), errmsg(), ERROR, find_all_inheritors(), find_inheritance_children(), find_typed_table_dependencies(), forboth, GETSTRUCT, heap_freetuple(), HeapTupleIsValid, InvokeObjectPostAlterHook, lfirst_int, lfirst_oid, namestrcpy(), NIL, NoLock, RelationData::rd_rel, relation_close(), relation_open(), RelationGetForm, RelationGetRelationName, renameatt_check(), RowExclusiveLock, SearchSysCacheCopyAttName(), HeapTupleData::t_self, table_close(), and table_open().

Referenced by renameatt().

RenameConstraint()

ObjectAddress RenameConstraint

(

RenameStmt *

stmt

)

Definition at line 4089 of file tablecmds.c.

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

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

Referenced by ExecRenameStmt().

RenameRelation()

ObjectAddress RenameRelation

(

RenameStmt *

stmt

)

Definition at line 4139 of file tablecmds.c.

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

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

Referenced by ExecRenameStmt().

RenameRelationInternal()

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

Definition at line 4203 of file tablecmds.c.

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

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

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

ResetRelRewrite()

void ResetRelRewrite

(

Oid

myrelid

)

Definition at line 4293 of file tablecmds.c.

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

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

Referenced by finish_heap_swap().

set_attnotnull()

static bool set_attnotnull ( List **  wqueue, Relation  rel, AttrNumber  attnum, bool  recurse, LOCKMODE  lockmode  )

static

Definition at line 7732 of file tablecmds.c.

{
    HeapTuple   tuple;
    Form_pg_attribute attForm;
    bool        retval = false;
 
    /* Guard against stack overflow due to overly deep inheritance tree. */
    check_stack_depth();
 
    tuple = SearchSysCacheCopyAttNum(RelationGetRelid(rel), attnum);
    if (!HeapTupleIsValid(tuple))
        elog(ERROR, "cache lookup failed for attribute %d of relation %u",
             attnum, RelationGetRelid(rel));
    attForm = (Form_pg_attribute) GETSTRUCT(tuple);
    if (!attForm->attnotnull)
    {
        Relation    attr_rel;
 
        attr_rel = table_open(AttributeRelationId, RowExclusiveLock);
 
        attForm->attnotnull = true;
        CatalogTupleUpdate(attr_rel, &tuple->t_self, tuple);
 
        table_close(attr_rel, RowExclusiveLock);
 
        /*
         * And set up for existing values to be checked, unless another
         * constraint already proves this.
         */
        if (wqueue && !NotNullImpliedByRelConstraints(rel, attForm))
        {
            AlteredTableInfo *tab;
 
            tab = ATGetQueueEntry(wqueue, rel);
            tab->verify_new_notnull = true;
        }
 
        retval = true;
    }
 
    if (recurse)
    {
        List       *children;
        ListCell   *lc;
 
        /* Make above update visible, for multiple inheritance cases */
        if (retval)
            CommandCounterIncrement();
 
        children = find_inheritance_children(RelationGetRelid(rel), lockmode);
        foreach(lc, children)
        {
            Oid         childrelid = lfirst_oid(lc);
            Relation    childrel;
            AttrNumber  childattno;
 
            /* find_inheritance_children already got lock */
            childrel = table_open(childrelid, NoLock);
            CheckTableNotInUse(childrel, "ALTER TABLE");
 
            childattno = get_attnum(RelationGetRelid(childrel),
                                    get_attname(RelationGetRelid(rel), attnum,
                                                false));
            retval |= set_attnotnull(wqueue, childrel, childattno,
                                     recurse, lockmode);
            table_close(childrel, NoLock);
        }
    }
 
    return retval;
}

References ATGetQueueEntry(), attnum, CatalogTupleUpdate(), check_stack_depth(), CheckTableNotInUse(), CommandCounterIncrement(), elog, ERROR, find_inheritance_children(), get_attname(), get_attnum(), GETSTRUCT, HeapTupleIsValid, lfirst_oid, NoLock, NotNullImpliedByRelConstraints(), RelationGetRelid, RowExclusiveLock, SearchSysCacheCopyAttNum(), HeapTupleData::t_self, table_close(), table_open(), and AlteredTableInfo::verify_new_notnull.

Referenced by ATAddCheckNNConstraint(), ATExecSetAttNotNull(), ATExecSetNotNull(), AttachPartitionEnsureIndexes(), and DefineRelation().

SetIndexStorageProperties()

static void SetIndexStorageProperties ( Relation  rel, Relation  attrelation, AttrNumber  attnum, bool  setstorage, char  newstorage, bool  setcompression, char  newcompression, LOCKMODE  lockmode  )

static

Definition at line 9002 of file tablecmds.c.

{
    ListCell   *lc;
 
    foreach(lc, RelationGetIndexList(rel))
    {
        Oid         indexoid = lfirst_oid(lc);
        Relation    indrel;
        AttrNumber  indattnum = 0;
        HeapTuple   tuple;
 
        indrel = index_open(indexoid, lockmode);
 
        for (int i = 0; i < indrel->rd_index->indnatts; i++)
        {
            if (indrel->rd_index->indkey.values[i] == attnum)
            {
                indattnum = i + 1;
                break;
            }
        }
 
        if (indattnum == 0)
        {
            index_close(indrel, lockmode);
            continue;
        }
 
        tuple = SearchSysCacheCopyAttNum(RelationGetRelid(indrel), indattnum);
 
        if (HeapTupleIsValid(tuple))
        {
            Form_pg_attribute attrtuple = (Form_pg_attribute) GETSTRUCT(tuple);
 
            if (setstorage)
                attrtuple->attstorage = newstorage;
 
            if (setcompression)
                attrtuple->attcompression = newcompression;
 
            CatalogTupleUpdate(attrelation, &tuple->t_self, tuple);
 
            InvokeObjectPostAlterHook(RelationRelationId,
                                      RelationGetRelid(rel),
                                      attrtuple->attnum);
 
            heap_freetuple(tuple);
        }
 
        index_close(indrel, lockmode);
    }
}

References attnum, CatalogTupleUpdate(), GETSTRUCT, heap_freetuple(), HeapTupleIsValid, i, index_close(), index_open(), InvokeObjectPostAlterHook, lfirst_oid, RelationData::rd_index, RelationGetIndexList(), RelationGetRelid, SearchSysCacheCopyAttNum(), and HeapTupleData::t_self.

Referenced by ATExecSetCompression(), and ATExecSetStorage().

SetRelationHasSubclass()

void SetRelationHasSubclass	(	Oid	relationId,
		bool	relhassubclass
	)

Definition at line 3588 of file tablecmds.c.

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

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

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

SetRelationTableSpace()

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

Definition at line 3686 of file tablecmds.c.

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

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

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

storage_name()

static const char * storage_name ( char  c )

static

Definition at line 2407 of file tablecmds.c.

{
    switch (c)
    {
        case TYPSTORAGE_PLAIN:
            return "PLAIN";
        case TYPSTORAGE_EXTERNAL:
            return "EXTERNAL";
        case TYPSTORAGE_EXTENDED:
            return "EXTENDED";
        case TYPSTORAGE_MAIN:
            return "MAIN";
        default:
            return "???";
    }
}

Referenced by MergeChildAttribute(), and MergeInheritedAttribute().

StoreCatalogInheritance()

static void StoreCatalogInheritance ( Oid  relationId, List *  supers, bool  child_is_partition  )

static

Definition at line 3469 of file tablecmds.c.

{
    Relation    relation;
    int32       seqNumber;
    ListCell   *entry;
 
    /*
     * sanity checks
     */
    Assert(OidIsValid(relationId));
 
    if (supers == NIL)
        return;
 
    /*
     * Store INHERITS information in pg_inherits using direct ancestors only.
     * Also enter dependencies on the direct ancestors, and make sure they are
     * marked with relhassubclass = true.
     *
     * (Once upon a time, both direct and indirect ancestors were found here
     * and then entered into pg_ipl.  Since that catalog doesn't exist
     * anymore, there's no need to look for indirect ancestors.)
     */
    relation = table_open(InheritsRelationId, RowExclusiveLock);
 
    seqNumber = 1;
    foreach(entry, supers)
    {
        Oid         parentOid = lfirst_oid(entry);
 
        StoreCatalogInheritance1(relationId, parentOid, seqNumber, relation,
                                 child_is_partition);
        seqNumber++;
    }
 
    table_close(relation, RowExclusiveLock);
}

References Assert, lfirst_oid, NIL, OidIsValid, RowExclusiveLock, StoreCatalogInheritance1(), table_close(), and table_open().

Referenced by DefineRelation().

StoreCatalogInheritance1()

static void StoreCatalogInheritance1 ( Oid  relationId, Oid  parentOid, int32  seqNumber, Relation  inhRelation, bool  child_is_partition  )

static

Definition at line 3513 of file tablecmds.c.

{
    ObjectAddress childobject,
                parentobject;
 
    /* store the pg_inherits row */
    StoreSingleInheritance(relationId, parentOid, seqNumber);
 
    /*
     * Store a dependency too
     */
    parentobject.classId = RelationRelationId;
    parentobject.objectId = parentOid;
    parentobject.objectSubId = 0;
    childobject.classId = RelationRelationId;
    childobject.objectId = relationId;
    childobject.objectSubId = 0;
 
    recordDependencyOn(&childobject, &parentobject,
                       child_dependency_type(child_is_partition));
 
    /*
     * Post creation hook of this inheritance. Since object_access_hook
     * doesn't take multiple object identifiers, we relay oid of parent
     * relation using auxiliary_id argument.
     */
    InvokeObjectPostAlterHookArg(InheritsRelationId,
                                 relationId, 0,
                                 parentOid, false);
 
    /*
     * Mark the parent as having subclasses.
     */
    SetRelationHasSubclass(parentOid, true);
}

References child_dependency_type, ObjectAddress::classId, InvokeObjectPostAlterHookArg, ObjectAddress::objectId, ObjectAddress::objectSubId, recordDependencyOn(), SetRelationHasSubclass(), and StoreSingleInheritance().

Referenced by CreateInheritance(), and StoreCatalogInheritance().

transformColumnNameList()

static int transformColumnNameList ( Oid  relId, List *  colList, int16 *  attnums, Oid *  atttypids  )

static

Definition at line 12189 of file tablecmds.c.

{
    ListCell   *l;
    int         attnum;
 
    attnum = 0;
    foreach(l, colList)
    {
        char       *attname = strVal(lfirst(l));
        HeapTuple   atttuple;
        Form_pg_attribute attform;
 
        atttuple = SearchSysCacheAttName(relId, attname);
        if (!HeapTupleIsValid(atttuple))
            ereport(ERROR,
                    (errcode(ERRCODE_UNDEFINED_COLUMN),
                     errmsg("column \"%s\" referenced in foreign key constraint does not exist",
                            attname)));
        attform = (Form_pg_attribute) GETSTRUCT(atttuple);
        if (attform->attnum < 0)
            ereport(ERROR,
                    (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                     errmsg("system columns cannot be used in foreign keys")));
        if (attnum >= INDEX_MAX_KEYS)
            ereport(ERROR,
                    (errcode(ERRCODE_TOO_MANY_COLUMNS),
                     errmsg("cannot have more than %d keys in a foreign key",
                            INDEX_MAX_KEYS)));
        attnums[attnum] = attform->attnum;
        if (atttypids != NULL)
            atttypids[attnum] = attform->atttypid;
        ReleaseSysCache(atttuple);
        attnum++;
    }
 
    return attnum;
}

References attname, attnum, ereport, errcode(), errmsg(), ERROR, GETSTRUCT, HeapTupleIsValid, INDEX_MAX_KEYS, lfirst, ReleaseSysCache(), SearchSysCacheAttName(), and strVal.

Referenced by ATAddForeignKeyConstraint().

transformFkeyCheckAttrs()

static Oid transformFkeyCheckAttrs ( Relation  pkrel, int  numattrs, int16 *  attnums, bool  with_period, Oid *  opclasses, bool *  pk_has_without_overlaps  )

static

Definition at line 12344 of file tablecmds.c.

{
    Oid         indexoid = InvalidOid;
    bool        found = false;
    bool        found_deferrable = false;
    List       *indexoidlist;
    ListCell   *indexoidscan;
    int         i,
                j;
 
    /*
     * Reject duplicate appearances of columns in the referenced-columns list.
     * Such a case is forbidden by the SQL standard, and even if we thought it
     * useful to allow it, there would be ambiguity about how to match the
     * list to unique indexes (in particular, it'd be unclear which index
     * opclass goes with which FK column).
     */
    for (i = 0; i < numattrs; i++)
    {
        for (j = i + 1; j < numattrs; j++)
        {
            if (attnums[i] == attnums[j])
                ereport(ERROR,
                        (errcode(ERRCODE_INVALID_FOREIGN_KEY),
                         errmsg("foreign key referenced-columns list must not contain duplicates")));
        }
    }
 
    /*
     * Get the list of index OIDs for the table from the relcache, and look up
     * each one in the pg_index syscache, and match unique indexes to the list
     * of attnums we are given.
     */
    indexoidlist = RelationGetIndexList(pkrel);
 
    foreach(indexoidscan, indexoidlist)
    {
        HeapTuple   indexTuple;
        Form_pg_index indexStruct;
 
        indexoid = lfirst_oid(indexoidscan);
        indexTuple = SearchSysCache1(INDEXRELID, ObjectIdGetDatum(indexoid));
        if (!HeapTupleIsValid(indexTuple))
            elog(ERROR, "cache lookup failed for index %u", indexoid);
        indexStruct = (Form_pg_index) GETSTRUCT(indexTuple);
 
        /*
         * Must have the right number of columns; must be unique (or if
         * temporal then exclusion instead) and not a partial index; forget it
         * if there are any expressions, too. Invalid indexes are out as well.
         */
        if (indexStruct->indnkeyatts == numattrs &&
            (with_period ? indexStruct->indisexclusion : indexStruct->indisunique) &&
            indexStruct->indisvalid &&
            heap_attisnull(indexTuple, Anum_pg_index_indpred, NULL) &&
            heap_attisnull(indexTuple, Anum_pg_index_indexprs, NULL))
        {
            Datum       indclassDatum;
            oidvector  *indclass;
 
            /* Must get indclass the hard way */
            indclassDatum = SysCacheGetAttrNotNull(INDEXRELID, indexTuple,
                                                   Anum_pg_index_indclass);
            indclass = (oidvector *) DatumGetPointer(indclassDatum);
 
            /*
             * The given attnum list may match the index columns in any order.
             * Check for a match, and extract the appropriate opclasses while
             * we're at it.
             *
             * We know that attnums[] is duplicate-free per the test at the
             * start of this function, and we checked above that the number of
             * index columns agrees, so if we find a match for each attnums[]
             * entry then we must have a one-to-one match in some order.
             */
            for (i = 0; i < numattrs; i++)
            {
                found = false;
                for (j = 0; j < numattrs; j++)
                {
                    if (attnums[i] == indexStruct->indkey.values[j])
                    {
                        opclasses[i] = indclass->values[j];
                        found = true;
                        break;
                    }
                }
                if (!found)
                    break;
            }
            /* The last attribute in the index must be the PERIOD FK part */
            if (found && with_period)
            {
                int16       periodattnum = attnums[numattrs - 1];
 
                found = (periodattnum == indexStruct->indkey.values[numattrs - 1]);
            }
 
            /*
             * Refuse to use a deferrable unique/primary key.  This is per SQL
             * spec, and there would be a lot of interesting semantic problems
             * if we tried to allow it.
             */
            if (found && !indexStruct->indimmediate)
            {
                /*
                 * Remember that we found an otherwise matching index, so that
                 * we can generate a more appropriate error message.
                 */
                found_deferrable = true;
                found = false;
            }
 
            /* We need to know whether the index has WITHOUT OVERLAPS */
            if (found)
                *pk_has_without_overlaps = indexStruct->indisexclusion;
        }
        ReleaseSysCache(indexTuple);
        if (found)
            break;
    }
 
    if (!found)
    {
        if (found_deferrable)
            ereport(ERROR,
                    (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
                     errmsg("cannot use a deferrable unique constraint for referenced table \"%s\"",
                            RelationGetRelationName(pkrel))));
        else
            ereport(ERROR,
                    (errcode(ERRCODE_INVALID_FOREIGN_KEY),
                     errmsg("there is no unique constraint matching given keys for referenced table \"%s\"",
                            RelationGetRelationName(pkrel))));
    }
 
    list_free(indexoidlist);
 
    return indexoid;
}

References DatumGetPointer(), elog, ereport, errcode(), errmsg(), ERROR, GETSTRUCT, heap_attisnull(), HeapTupleIsValid, i, InvalidOid, j, lfirst_oid, list_free(), ObjectIdGetDatum(), RelationGetIndexList(), RelationGetRelationName, ReleaseSysCache(), SearchSysCache1(), SysCacheGetAttrNotNull(), and oidvector::values.

Referenced by ATAddForeignKeyConstraint().

transformFkeyGetPrimaryKey()

static int transformFkeyGetPrimaryKey ( Relation  pkrel, Oid *  indexOid, List **  attnamelist, int16 *  attnums, Oid *  atttypids, Oid *  opclasses, bool *  pk_has_without_overlaps  )

static

Definition at line 12242 of file tablecmds.c.

{
    List       *indexoidlist;
    ListCell   *indexoidscan;
    HeapTuple   indexTuple = NULL;
    Form_pg_index indexStruct = NULL;
    Datum       indclassDatum;
    oidvector  *indclass;
    int         i;
 
    /*
     * Get the list of index OIDs for the table from the relcache, and look up
     * each one in the pg_index syscache until we find one marked primary key
     * (hopefully there isn't more than one such).  Insist it's valid, too.
     */
    *indexOid = InvalidOid;
 
    indexoidlist = RelationGetIndexList(pkrel);
 
    foreach(indexoidscan, indexoidlist)
    {
        Oid         indexoid = lfirst_oid(indexoidscan);
 
        indexTuple = SearchSysCache1(INDEXRELID, ObjectIdGetDatum(indexoid));
        if (!HeapTupleIsValid(indexTuple))
            elog(ERROR, "cache lookup failed for index %u", indexoid);
        indexStruct = (Form_pg_index) GETSTRUCT(indexTuple);
        if (indexStruct->indisprimary && indexStruct->indisvalid)
        {
            /*
             * Refuse to use a deferrable primary key.  This is per SQL spec,
             * and there would be a lot of interesting semantic problems if we
             * tried to allow it.
             */
            if (!indexStruct->indimmediate)
                ereport(ERROR,
                        (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
                         errmsg("cannot use a deferrable primary key for referenced table \"%s\"",
                                RelationGetRelationName(pkrel))));
 
            *indexOid = indexoid;
            break;
        }
        ReleaseSysCache(indexTuple);
    }
 
    list_free(indexoidlist);
 
    /*
     * Check that we found it
     */
    if (!OidIsValid(*indexOid))
        ereport(ERROR,
                (errcode(ERRCODE_UNDEFINED_OBJECT),
                 errmsg("there is no primary key for referenced table \"%s\"",
                        RelationGetRelationName(pkrel))));
 
    /* Must get indclass the hard way */
    indclassDatum = SysCacheGetAttrNotNull(INDEXRELID, indexTuple,
                                           Anum_pg_index_indclass);
    indclass = (oidvector *) DatumGetPointer(indclassDatum);
 
    /*
     * Now build the list of PK attributes from the indkey definition (we
     * assume a primary key cannot have expressional elements)
     */
    *attnamelist = NIL;
    for (i = 0; i < indexStruct->indnkeyatts; i++)
    {
        int         pkattno = indexStruct->indkey.values[i];
 
        attnums[i] = pkattno;
        atttypids[i] = attnumTypeId(pkrel, pkattno);
        opclasses[i] = indclass->values[i];
        *attnamelist = lappend(*attnamelist,
                               makeString(pstrdup(NameStr(*attnumAttName(pkrel, pkattno)))));
    }
 
    *pk_has_without_overlaps = indexStruct->indisexclusion;
 
    ReleaseSysCache(indexTuple);
 
    return i;
}

References attnumAttName(), attnumTypeId(), DatumGetPointer(), elog, ereport, errcode(), errmsg(), ERROR, GETSTRUCT, HeapTupleIsValid, i, InvalidOid, lappend(), lfirst_oid, list_free(), makeString(), NameStr, NIL, ObjectIdGetDatum(), OidIsValid, pstrdup(), RelationGetIndexList(), RelationGetRelationName, ReleaseSysCache(), SearchSysCache1(), SysCacheGetAttrNotNull(), and oidvector::values.

Referenced by ATAddForeignKeyConstraint().

transformPartitionSpec()

static PartitionSpec * transformPartitionSpec ( Relation  rel, PartitionSpec *  partspec  )

static

Definition at line 18647 of file tablecmds.c.

{
    PartitionSpec *newspec;
    ParseState *pstate;
    ParseNamespaceItem *nsitem;
    ListCell   *l;
 
    newspec = makeNode(PartitionSpec);
 
    newspec->strategy = partspec->strategy;
    newspec->partParams = NIL;
    newspec->location = partspec->location;
 
    /* Check valid number of columns for strategy */
    if (partspec->strategy == PARTITION_STRATEGY_LIST &&
        list_length(partspec->partParams) != 1)
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
                 errmsg("cannot use \"list\" partition strategy with more than one column")));
 
    /*
     * Create a dummy ParseState and insert the target relation as its sole
     * rangetable entry.  We need a ParseState for transformExpr.
     */
    pstate = make_parsestate(NULL);
    nsitem = addRangeTableEntryForRelation(pstate, rel, AccessShareLock,
                                           NULL, false, true);
    addNSItemToQuery(pstate, nsitem, true, true, true);
 
    /* take care of any partition expressions */
    foreach(l, partspec->partParams)
    {
        PartitionElem *pelem = lfirst_node(PartitionElem, l);
 
        if (pelem->expr)
        {
            /* Copy, to avoid scribbling on the input */
            pelem = copyObject(pelem);
 
            /* Now do parse transformation of the expression */
            pelem->expr = transformExpr(pstate, pelem->expr,
                                        EXPR_KIND_PARTITION_EXPRESSION);
 
            /* we have to fix its collations too */
            assign_expr_collations(pstate, pelem->expr);
        }
 
        newspec->partParams = lappend(newspec->partParams, pelem);
    }
 
    return newspec;
}

References AccessShareLock, addNSItemToQuery(), addRangeTableEntryForRelation(), assign_expr_collations(), copyObject, ereport, errcode(), errmsg(), ERROR, PartitionElem::expr, EXPR_KIND_PARTITION_EXPRESSION, lappend(), lfirst_node, list_length(), PartitionSpec::location, make_parsestate(), makeNode, NIL, PARTITION_STRATEGY_LIST, PartitionSpec::partParams, PartitionSpec::strategy, and transformExpr().

Referenced by DefineRelation().

truncate_check_activity()

static void truncate_check_activity ( Relation  rel )

static

Definition at line 2384 of file tablecmds.c.

{
    /*
     * Don't allow truncate on temp tables of other backends ... their local
     * buffer manager is not going to cope.
     */
    if (RELATION_IS_OTHER_TEMP(rel))
        ereport(ERROR,
                (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                 errmsg("cannot truncate temporary tables of other sessions")));
 
    /*
     * Also check for active uses of the relation in the current transaction,
     * including open scans and pending AFTER trigger events.
     */
    CheckTableNotInUse(rel, "TRUNCATE");
}

References CheckTableNotInUse(), ereport, errcode(), errmsg(), ERROR, and RELATION_IS_OTHER_TEMP.

Referenced by ExecuteTruncate(), and ExecuteTruncateGuts().

truncate_check_perms()

static void truncate_check_perms ( Oid  relid, Form_pg_class  reltuple  )

static

Definition at line 2366 of file tablecmds.c.

{
    char       *relname = NameStr(reltuple->relname);
    AclResult   aclresult;
 
    /* Permissions checks */
    aclresult = pg_class_aclcheck(relid, GetUserId(), ACL_TRUNCATE);
    if (aclresult != ACLCHECK_OK)
        aclcheck_error(aclresult, get_relkind_objtype(reltuple->relkind),
                       relname);
}

References ACL_TRUNCATE, aclcheck_error(), ACLCHECK_OK, get_relkind_objtype(), GetUserId(), NameStr, pg_class_aclcheck(), and relname.

Referenced by ExecuteTruncateGuts(), and RangeVarCallbackForTruncate().

truncate_check_rel()

static void truncate_check_rel ( Oid  relid, Form_pg_class  reltuple  )

static

Definition at line 2318 of file tablecmds.c.

{
    char       *relname = NameStr(reltuple->relname);
 
    /*
     * Only allow truncate on regular tables, foreign tables using foreign
     * data wrappers supporting TRUNCATE and partitioned tables (although, the
     * latter are only being included here for the following checks; no
     * physical truncation will occur in their case.).
     */
    if (reltuple->relkind == RELKIND_FOREIGN_TABLE)
    {
        Oid         serverid = GetForeignServerIdByRelId(relid);
        FdwRoutine *fdwroutine = GetFdwRoutineByServerId(serverid);
 
        if (!fdwroutine->ExecForeignTruncate)
            ereport(ERROR,
                    (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                     errmsg("cannot truncate foreign table \"%s\"",
                            relname)));
    }
    else if (reltuple->relkind != RELKIND_RELATION &&
             reltuple->relkind != RELKIND_PARTITIONED_TABLE)
        ereport(ERROR,
                (errcode(ERRCODE_WRONG_OBJECT_TYPE),
                 errmsg("\"%s\" is not a table", relname)));
 
    /*
     * Most system catalogs can't be truncated at all, or at least not unless
     * allow_system_table_mods=on. As an exception, however, we allow
     * pg_largeobject to be truncated as part of pg_upgrade, because we need
     * to change its relfilenode to match the old cluster, and allowing a
     * TRUNCATE command to be executed is the easiest way of doing that.
     */
    if (!allowSystemTableMods && IsSystemClass(relid, reltuple)
        && (!IsBinaryUpgrade || relid != LargeObjectRelationId))
        ereport(ERROR,
                (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
                 errmsg("permission denied: \"%s\" is a system catalog",
                        relname)));
 
    InvokeObjectTruncateHook(relid);
}

References allowSystemTableMods, ereport, errcode(), errmsg(), ERROR, FdwRoutine::ExecForeignTruncate, GetFdwRoutineByServerId(), GetForeignServerIdByRelId(), InvokeObjectTruncateHook, IsBinaryUpgrade, IsSystemClass(), NameStr, and relname.

Referenced by ExecuteTruncate(), ExecuteTruncateGuts(), and RangeVarCallbackForTruncate().

tryAttachPartitionForeignKey()

static bool tryAttachPartitionForeignKey ( ForeignKeyCacheInfo *  fk, Oid  partRelid, Oid  parentConstrOid, int  numfks, AttrNumber *  mapped_conkey, AttrNumber *  confkey, Oid *  conpfeqop, Oid  parentInsTrigger, Oid  parentUpdTrigger, Relation  trigrel  )

static

Definition at line 11442 of file tablecmds.c.

{
    HeapTuple   parentConstrTup;
    Form_pg_constraint parentConstr;
    HeapTuple   partcontup;
    Form_pg_constraint partConstr;
    ScanKeyData key;
    SysScanDesc scan;
    HeapTuple   trigtup;
    Oid         insertTriggerOid,
                updateTriggerOid;
 
    parentConstrTup = SearchSysCache1(CONSTROID,
                                      ObjectIdGetDatum(parentConstrOid));
    if (!HeapTupleIsValid(parentConstrTup))
        elog(ERROR, "cache lookup failed for constraint %u", parentConstrOid);
    parentConstr = (Form_pg_constraint) GETSTRUCT(parentConstrTup);
 
    /*
     * Do some quick & easy initial checks.  If any of these fail, we cannot
     * use this constraint.
     */
    if (fk->confrelid != parentConstr->confrelid || fk->nkeys != numfks)
    {
        ReleaseSysCache(parentConstrTup);
        return false;
    }
    for (int i = 0; i < numfks; i++)
    {
        if (fk->conkey[i] != mapped_conkey[i] ||
            fk->confkey[i] != confkey[i] ||
            fk->conpfeqop[i] != conpfeqop[i])
        {
            ReleaseSysCache(parentConstrTup);
            return false;
        }
    }
 
    /*
     * Looks good so far; do some more extensive checks.  Presumably the check
     * for 'convalidated' could be dropped, since we don't really care about
     * that, but let's be careful for now.
     */
    partcontup = SearchSysCache1(CONSTROID,
                                 ObjectIdGetDatum(fk->conoid));
    if (!HeapTupleIsValid(partcontup))
        elog(ERROR, "cache lookup failed for constraint %u", fk->conoid);
    partConstr = (Form_pg_constraint) GETSTRUCT(partcontup);
    if (OidIsValid(partConstr->conparentid) ||
        !partConstr->convalidated ||
        partConstr->condeferrable != parentConstr->condeferrable ||
        partConstr->condeferred != parentConstr->condeferred ||
        partConstr->confupdtype != parentConstr->confupdtype ||
        partConstr->confdeltype != parentConstr->confdeltype ||
        partConstr->confmatchtype != parentConstr->confmatchtype)
    {
        ReleaseSysCache(parentConstrTup);
        ReleaseSysCache(partcontup);
        return false;
    }
 
    ReleaseSysCache(partcontup);
    ReleaseSysCache(parentConstrTup);
 
    /*
     * Looks good!  Attach this constraint.  The action triggers in the new
     * partition become redundant -- the parent table already has equivalent
     * ones, and those will be able to reach the partition.  Remove the ones
     * in the partition.  We identify them because they have our constraint
     * OID, as well as being on the referenced rel.
     */
    ScanKeyInit(&key,
                Anum_pg_trigger_tgconstraint,
                BTEqualStrategyNumber, F_OIDEQ,
                ObjectIdGetDatum(fk->conoid));
    scan = systable_beginscan(trigrel, TriggerConstraintIndexId, true,
                              NULL, 1, &key);
    while ((trigtup = systable_getnext(scan)) != NULL)
    {
        Form_pg_trigger trgform = (Form_pg_trigger) GETSTRUCT(trigtup);
        ObjectAddress trigger;
 
        if (trgform->tgconstrrelid != fk->conrelid)
            continue;
        if (trgform->tgrelid != fk->confrelid)
            continue;
 
        /*
         * The constraint is originally set up to contain this trigger as an
         * implementation object, so there's a dependency record that links
         * the two; however, since the trigger is no longer needed, we remove
         * the dependency link in order to be able to drop the trigger while
         * keeping the constraint intact.
         */
        deleteDependencyRecordsFor(TriggerRelationId,
                                   trgform->oid,
                                   false);
        /* make dependency deletion visible to performDeletion */
        CommandCounterIncrement();
        ObjectAddressSet(trigger, TriggerRelationId,
                         trgform->oid);
        performDeletion(&trigger, DROP_RESTRICT, 0);
        /* make trigger drop visible, in case the loop iterates */
        CommandCounterIncrement();
    }
 
    systable_endscan(scan);
 
    ConstraintSetParentConstraint(fk->conoid, parentConstrOid, partRelid);
 
    /*
     * Like the constraint, attach partition's "check" triggers to the
     * corresponding parent triggers.
     */
    GetForeignKeyCheckTriggers(trigrel,
                               fk->conoid, fk->confrelid, fk->conrelid,
                               &insertTriggerOid, &updateTriggerOid);
    Assert(OidIsValid(insertTriggerOid) && OidIsValid(parentInsTrigger));
    TriggerSetParentTrigger(trigrel, insertTriggerOid, parentInsTrigger,
                            partRelid);
    Assert(OidIsValid(updateTriggerOid) && OidIsValid(parentUpdTrigger));
    TriggerSetParentTrigger(trigrel, updateTriggerOid, parentUpdTrigger,
                            partRelid);
 
    CommandCounterIncrement();
    return true;
}

References Assert, BTEqualStrategyNumber, CommandCounterIncrement(), ForeignKeyCacheInfo::confrelid, ForeignKeyCacheInfo::conoid, ForeignKeyCacheInfo::conrelid, ConstraintSetParentConstraint(), deleteDependencyRecordsFor(), DROP_RESTRICT, elog, ERROR, GetForeignKeyCheckTriggers(), GETSTRUCT, HeapTupleIsValid, i, sort-test::key, ForeignKeyCacheInfo::nkeys, ObjectAddressSet, ObjectIdGetDatum(), OidIsValid, performDeletion(), ReleaseSysCache(), ScanKeyInit(), SearchSysCache1(), systable_beginscan(), systable_endscan(), systable_getnext(), and TriggerSetParentTrigger().

Referenced by addFkRecurseReferencing(), and CloneFkReferencing().

TryReuseForeignKey()

static void TryReuseForeignKey ( Oid  oldId, Constraint *  con  )

static

Definition at line 14825 of file tablecmds.c.

{
    HeapTuple   tup;
    Datum       adatum;
    ArrayType  *arr;
    Oid        *rawarr;
    int         numkeys;
    int         i;
 
    Assert(con->contype == CONSTR_FOREIGN);
    Assert(con->old_conpfeqop == NIL);  /* already prepared this node */
 
    tup = SearchSysCache1(CONSTROID, ObjectIdGetDatum(oldId));
    if (!HeapTupleIsValid(tup)) /* should not happen */
        elog(ERROR, "cache lookup failed for constraint %u", oldId);
 
    adatum = SysCacheGetAttrNotNull(CONSTROID, tup,
                                    Anum_pg_constraint_conpfeqop);
    arr = DatumGetArrayTypeP(adatum);   /* ensure not toasted */
    numkeys = ARR_DIMS(arr)[0];
    /* test follows the one in ri_FetchConstraintInfo() */
    if (ARR_NDIM(arr) != 1 ||
        ARR_HASNULL(arr) ||
        ARR_ELEMTYPE(arr) != OIDOID)
        elog(ERROR, "conpfeqop is not a 1-D Oid array");
    rawarr = (Oid *) ARR_DATA_PTR(arr);
 
    /* stash a List of the operator Oids in our Constraint node */
    for (i = 0; i < numkeys; i++)
        con->old_conpfeqop = lappend_oid(con->old_conpfeqop, rawarr[i]);
 
    ReleaseSysCache(tup);
}

References ARR_DATA_PTR, ARR_DIMS, ARR_ELEMTYPE, ARR_HASNULL, ARR_NDIM, Assert, CONSTR_FOREIGN, Constraint::contype, DatumGetArrayTypeP, elog, ERROR, HeapTupleIsValid, i, lappend_oid(), NIL, ObjectIdGetDatum(), Constraint::old_conpfeqop, ReleaseSysCache(), SearchSysCache1(), and SysCacheGetAttrNotNull().

Referenced by ATPostAlterTypeParse().

TryReuseIndex()

static void TryReuseIndex ( Oid  oldId, IndexStmt *  stmt  )

static

Definition at line 14796 of file tablecmds.c.

{
    if (CheckIndexCompatible(oldId,
                             stmt->accessMethod,
                             stmt->indexParams,
                             stmt->excludeOpNames,
                             stmt->iswithoutoverlaps))
    {
        Relation    irel = index_open(oldId, NoLock);
 
        /* If it's a partitioned index, there is no storage to share. */
        if (irel->rd_rel->relkind != RELKIND_PARTITIONED_INDEX)
        {
            stmt->oldNumber = irel->rd_locator.relNumber;
            stmt->oldCreateSubid = irel->rd_createSubid;
            stmt->oldFirstRelfilelocatorSubid = irel->rd_firstRelfilelocatorSubid;
        }
        index_close(irel, NoLock);
    }
}

References CheckIndexCompatible(), index_close(), index_open(), NoLock, RelationData::rd_createSubid, RelationData::rd_firstRelfilelocatorSubid, RelationData::rd_locator, RelationData::rd_rel, RelFileLocator::relNumber, and stmt.

Referenced by ATPostAlterTypeParse().

validateFkOnDeleteSetColumns()

void validateFkOnDeleteSetColumns ( int  numfks, const int16 *  fkattnums, int  numfksetcols, const int16 *  fksetcolsattnums, List *  fksetcols  )

static

Definition at line 10420 of file tablecmds.c.

{
    for (int i = 0; i < numfksetcols; i++)
    {
        int16       setcol_attnum = fksetcolsattnums[i];
        bool        seen = false;
 
        for (int j = 0; j < numfks; j++)
        {
            if (fkattnums[j] == setcol_attnum)
            {
                seen = true;
                break;
            }
        }
 
        if (!seen)
        {
            char       *col = strVal(list_nth(fksetcols, i));
 
            ereport(ERROR,
                    (errcode(ERRCODE_INVALID_COLUMN_REFERENCE),
                     errmsg("column \"%s\" referenced in ON DELETE SET action must be part of foreign key", col)));
        }
    }
}

References ereport, errcode(), errmsg(), ERROR, i, j, list_nth(), and strVal.

Referenced by ATAddForeignKeyConstraint().

validateForeignKeyConstraint()

static void validateForeignKeyConstraint ( char *  conname, Relation  rel, Relation  pkrel, Oid  pkindOid, Oid  constraintOid, bool  hasperiod  )

static

Definition at line 12553 of file tablecmds.c.

{
    TupleTableSlot *slot;
    TableScanDesc scan;
    Trigger     trig = {0};
    Snapshot    snapshot;
    MemoryContext oldcxt;
    MemoryContext perTupCxt;
 
    ereport(DEBUG1,
            (errmsg_internal("validating foreign key constraint \"%s\"", conname)));
 
    /*
     * Build a trigger call structure; we'll need it either way.
     */
    trig.tgoid = InvalidOid;
    trig.tgname = conname;
    trig.tgenabled = TRIGGER_FIRES_ON_ORIGIN;
    trig.tgisinternal = true;
    trig.tgconstrrelid = RelationGetRelid(pkrel);
    trig.tgconstrindid = pkindOid;
    trig.tgconstraint = constraintOid;
    trig.tgdeferrable = false;
    trig.tginitdeferred = false;
    /* we needn't fill in remaining fields */
 
    /*
     * See if we can do it with a single LEFT JOIN query.  A false result
     * indicates we must proceed with the fire-the-trigger method. We can't do
     * a LEFT JOIN for temporal FKs yet, but we can once we support temporal
     * left joins.
     */
    if (!hasperiod && RI_Initial_Check(&trig, rel, pkrel))
        return;
 
    /*
     * Scan through each tuple, calling RI_FKey_check_ins (insert trigger) as
     * if that tuple had just been inserted.  If any of those fail, it should
     * ereport(ERROR) and that's that.
     */
    snapshot = RegisterSnapshot(GetLatestSnapshot());
    slot = table_slot_create(rel, NULL);
    scan = table_beginscan(rel, snapshot, 0, NULL);
 
    perTupCxt = AllocSetContextCreate(CurrentMemoryContext,
                                      "validateForeignKeyConstraint",
                                      ALLOCSET_SMALL_SIZES);
    oldcxt = MemoryContextSwitchTo(perTupCxt);
 
    while (table_scan_getnextslot(scan, ForwardScanDirection, slot))
    {
        LOCAL_FCINFO(fcinfo, 0);
        TriggerData trigdata = {0};
 
        CHECK_FOR_INTERRUPTS();
 
        /*
         * Make a call to the trigger function
         *
         * No parameters are passed, but we do set a context
         */
        MemSet(fcinfo, 0, SizeForFunctionCallInfo(0));
 
        /*
         * We assume RI_FKey_check_ins won't look at flinfo...
         */
        trigdata.type = T_TriggerData;
        trigdata.tg_event = TRIGGER_EVENT_INSERT | TRIGGER_EVENT_ROW;
        trigdata.tg_relation = rel;
        trigdata.tg_trigtuple = ExecFetchSlotHeapTuple(slot, false, NULL);
        trigdata.tg_trigslot = slot;
        trigdata.tg_trigger = &trig;
 
        fcinfo->context = (Node *) &trigdata;
 
        RI_FKey_check_ins(fcinfo);
 
        MemoryContextReset(perTupCxt);
    }
 
    MemoryContextSwitchTo(oldcxt);
    MemoryContextDelete(perTupCxt);
    table_endscan(scan);
    UnregisterSnapshot(snapshot);
    ExecDropSingleTupleTableSlot(slot);
}

References ALLOCSET_SMALL_SIZES, AllocSetContextCreate, CHECK_FOR_INTERRUPTS, CurrentMemoryContext, DEBUG1, ereport, errmsg_internal(), ExecDropSingleTupleTableSlot(), ExecFetchSlotHeapTuple(), ForwardScanDirection, GetLatestSnapshot(), InvalidOid, LOCAL_FCINFO, MemoryContextDelete(), MemoryContextReset(), MemoryContextSwitchTo(), MemSet, RegisterSnapshot(), RelationGetRelid, RI_FKey_check_ins(), RI_Initial_Check(), SizeForFunctionCallInfo, table_beginscan(), table_endscan(), table_scan_getnextslot(), table_slot_create(), TriggerData::tg_event, TriggerData::tg_relation, TriggerData::tg_trigger, TriggerData::tg_trigslot, TriggerData::tg_trigtuple, Trigger::tgconstraint, Trigger::tgconstrindid, Trigger::tgconstrrelid, Trigger::tgdeferrable, Trigger::tgenabled, Trigger::tginitdeferred, Trigger::tgisinternal, Trigger::tgname, Trigger::tgoid, TRIGGER_EVENT_INSERT, TRIGGER_EVENT_ROW, TRIGGER_FIRES_ON_ORIGIN, TriggerData::type, and UnregisterSnapshot().

Referenced by ATRewriteTables().

validatePartitionedIndex()

static void validatePartitionedIndex ( Relation  partedIdx, Relation  partedTbl  )

static

Definition at line 20637 of file tablecmds.c.

{
    Relation    inheritsRel;
    SysScanDesc scan;
    ScanKeyData key;
    int         tuples = 0;
    HeapTuple   inhTup;
    bool        updated = false;
 
    Assert(partedIdx->rd_rel->relkind == RELKIND_PARTITIONED_INDEX);
 
    /*
     * Scan pg_inherits for this parent index.  Count each valid index we find
     * (verifying the pg_index entry for each), and if we reach the total
     * amount we expect, we can mark this parent index as valid.
     */
    inheritsRel = table_open(InheritsRelationId, AccessShareLock);
    ScanKeyInit(&key, Anum_pg_inherits_inhparent,
                BTEqualStrategyNumber, F_OIDEQ,
                ObjectIdGetDatum(RelationGetRelid(partedIdx)));
    scan = systable_beginscan(inheritsRel, InheritsParentIndexId, true,
                              NULL, 1, &key);
    while ((inhTup = systable_getnext(scan)) != NULL)
    {
        Form_pg_inherits inhForm = (Form_pg_inherits) GETSTRUCT(inhTup);
        HeapTuple   indTup;
        Form_pg_index indexForm;
 
        indTup = SearchSysCache1(INDEXRELID,
                                 ObjectIdGetDatum(inhForm->inhrelid));
        if (!HeapTupleIsValid(indTup))
            elog(ERROR, "cache lookup failed for index %u", inhForm->inhrelid);
        indexForm = (Form_pg_index) GETSTRUCT(indTup);
        if (indexForm->indisvalid)
            tuples += 1;
        ReleaseSysCache(indTup);
    }
 
    /* Done with pg_inherits */
    systable_endscan(scan);
    table_close(inheritsRel, AccessShareLock);
 
    /*
     * If we found as many inherited indexes as the partitioned table has
     * partitions, we're good; update pg_index to set indisvalid.
     */
    if (tuples == RelationGetPartitionDesc(partedTbl, true)->nparts)
    {
        Relation    idxRel;
        HeapTuple   indTup;
        Form_pg_index indexForm;
 
        idxRel = table_open(IndexRelationId, RowExclusiveLock);
        indTup = SearchSysCacheCopy1(INDEXRELID,
                                     ObjectIdGetDatum(RelationGetRelid(partedIdx)));
        if (!HeapTupleIsValid(indTup))
            elog(ERROR, "cache lookup failed for index %u",
                 RelationGetRelid(partedIdx));
        indexForm = (Form_pg_index) GETSTRUCT(indTup);
 
        indexForm->indisvalid = true;
        updated = true;
 
        CatalogTupleUpdate(idxRel, &indTup->t_self, indTup);
 
        table_close(idxRel, RowExclusiveLock);
        heap_freetuple(indTup);
    }
 
    /*
     * If this index is in turn a partition of a larger index, validating it
     * might cause the parent to become valid also.  Try that.
     */
    if (updated && partedIdx->rd_rel->relispartition)
    {
        Oid         parentIdxId,
                    parentTblId;
        Relation    parentIdx,
                    parentTbl;
 
        /* make sure we see the validation we just did */
        CommandCounterIncrement();
 
        parentIdxId = get_partition_parent(RelationGetRelid(partedIdx), false);
        parentTblId = get_partition_parent(RelationGetRelid(partedTbl), false);
        parentIdx = relation_open(parentIdxId, AccessExclusiveLock);
        parentTbl = relation_open(parentTblId, AccessExclusiveLock);
        Assert(!parentIdx->rd_index->indisvalid);
 
        validatePartitionedIndex(parentIdx, parentTbl);
 
        relation_close(parentIdx, AccessExclusiveLock);
        relation_close(parentTbl, AccessExclusiveLock);
    }
}

References AccessExclusiveLock, AccessShareLock, Assert, BTEqualStrategyNumber, CatalogTupleUpdate(), CommandCounterIncrement(), elog, ERROR, get_partition_parent(), GETSTRUCT, heap_freetuple(), HeapTupleIsValid, sort-test::key, ObjectIdGetDatum(), RelationData::rd_index, RelationData::rd_rel, relation_close(), relation_open(), RelationGetPartitionDesc(), RelationGetRelid, ReleaseSysCache(), RowExclusiveLock, ScanKeyInit(), SearchSysCache1(), SearchSysCacheCopy1, systable_beginscan(), systable_endscan(), systable_getnext(), HeapTupleData::t_self, table_close(), and table_open().

Referenced by ATExecAttachPartitionIdx().

verifyPartitionIndexNotNull()

static void verifyPartitionIndexNotNull ( IndexInfo *  iinfo, Relation  partIdx  )

static

Definition at line 20739 of file tablecmds.c.

{
    for (int i = 0; i < iinfo->ii_NumIndexKeyAttrs; i++)
    {
        Form_pg_attribute att = TupleDescAttr(RelationGetDescr(partition),
                                              iinfo->ii_IndexAttrNumbers[i] - 1);
 
        if (!att->attnotnull)
            ereport(ERROR,
                    errcode(ERRCODE_INVALID_TABLE_DEFINITION),
                    errmsg("invalid primary key definition"),
                    errdetail("Column \"%s\" of relation \"%s\" is not marked NOT NULL.",
                              NameStr(att->attname),
                              RelationGetRelationName(partition)));
    }
}

References ereport, errcode(), errdetail(), errmsg(), ERROR, i, IndexInfo::ii_IndexAttrNumbers, IndexInfo::ii_NumIndexKeyAttrs, NameStr, RelationGetDescr, RelationGetRelationName, and TupleDescAttr.

Referenced by ATExecAttachPartitionIdx().

Variable Documentation

dropmsgstringarray

const struct dropmsgstrings dropmsgstringarray[]

static

Definition at line 128 of file tablecmds.c.

Referenced by DropErrorMsgNonExistent(), and DropErrorMsgWrongType().

on_commits

List* on_commits = NIL

static

Definition at line 128 of file tablecmds.c.

Referenced by AtEOSubXact_on_commit_actions(), AtEOXact_on_commit_actions(), PreCommit_on_commit_actions(), register_on_commit_action(), and remove_on_commit_action().