From 915ef30d4db031b05a7cb8acdc86049d554cb467 Mon Sep 17 00:00:00 2001 From: Alvaro Herrera Date: Fri, 25 Apr 2014 17:15:49 -0300 Subject: [PATCH 02/29] deparse/core: have ALTER TABLE return table OID and other data Currently, most if not all CREATE commands return the OID of the created object. This is useful for event triggers to try to figure out exactly what happened. This patch extends this idea a bit further to cover ALTER TABLE as well: auxilliary info such as a second OID or a column number are also returned for each subcommand of the ALTER TABLE. This OID or attnum can later be used to determine, for instance, which constraint was added by ALTER TABLE ADD CONSTRAINT, or which parent got dropped from the inherit-from parents list by NO INHERIT. This makes it possible to decode with precision exactly what happened during execution of any ALTER TABLE command. There is no user-visible change here; this patch makes the info available for later. --- src/backend/catalog/heap.c | 40 +++-- src/backend/catalog/index.c | 7 +- src/backend/catalog/pg_constraint.c | 2 + src/backend/commands/tablecmds.c | 307 ++++++++++++++++++++++++------------ src/include/catalog/heap.h | 3 +- src/include/catalog/index.h | 2 +- 6 files changed, 244 insertions(+), 117 deletions(-) diff --git a/src/backend/catalog/heap.c b/src/backend/catalog/heap.c index 5ce4395..9675d21 100644 --- a/src/backend/catalog/heap.c +++ b/src/backend/catalog/heap.c @@ -97,7 +97,7 @@ static ObjectAddress AddNewRelationType(const char *typeName, Oid new_row_type, Oid new_array_type); static void RelationRemoveInheritance(Oid relid); -static void StoreRelCheck(Relation rel, char *ccname, Node *expr, +static Oid StoreRelCheck(Relation rel, char *ccname, Node *expr, bool is_validated, bool is_local, int inhcount, bool is_no_inherit, bool is_internal); static void StoreConstraints(Relation rel, List *cooked_constraints, @@ -1853,7 +1853,7 @@ heap_drop_with_catalog(Oid relid) /* * Store a default expression for column attnum of relation rel. */ -void +Oid StoreAttrDefault(Relation rel, AttrNumber attnum, Node *expr, bool is_internal) { @@ -1958,6 +1958,8 @@ StoreAttrDefault(Relation rel, AttrNumber attnum, */ InvokeObjectPostCreateHookArg(AttrDefaultRelationId, RelationGetRelid(rel), attnum, is_internal); + + return attrdefOid; } /* @@ -1965,8 +1967,10 @@ StoreAttrDefault(Relation rel, AttrNumber attnum, * * Caller is responsible for updating the count of constraints * in the pg_class entry for the relation. + * + * The OID of the new constraint is returned. */ -static void +static Oid StoreRelCheck(Relation rel, char *ccname, Node *expr, bool is_validated, bool is_local, int inhcount, bool is_no_inherit, bool is_internal) @@ -1976,6 +1980,7 @@ StoreRelCheck(Relation rel, char *ccname, Node *expr, List *varList; int keycount; int16 *attNos; + Oid constrOid; /* * Flatten expression to string form for storage. @@ -2027,7 +2032,7 @@ StoreRelCheck(Relation rel, char *ccname, Node *expr, /* * Create the Check Constraint */ - CreateConstraintEntry(ccname, /* Constraint Name */ + constrOid = CreateConstraintEntry(ccname, /* Constraint Name */ RelationGetNamespace(rel), /* namespace */ CONSTRAINT_CHECK, /* Constraint Type */ false, /* Is Deferrable */ @@ -2058,11 +2063,15 @@ StoreRelCheck(Relation rel, char *ccname, Node *expr, pfree(ccbin); pfree(ccsrc); + + return constrOid; } /* * Store defaults and constraints (passed as a list of CookedConstraint). * + * Each CookedConstraint struct is modified to store the new catalog tuple OID. + * * NOTE: only pre-cooked expressions will be passed this way, which is to * say expressions inherited from an existing relation. Newly parsed * expressions can be added later, by direct calls to StoreAttrDefault @@ -2074,7 +2083,7 @@ StoreConstraints(Relation rel, List *cooked_constraints, bool is_internal) int numchecks = 0; ListCell *lc; - if (!cooked_constraints) + if (list_length(cooked_constraints) == 0) return; /* nothing to do */ /* @@ -2091,12 +2100,14 @@ StoreConstraints(Relation rel, List *cooked_constraints, bool is_internal) switch (con->contype) { case CONSTR_DEFAULT: - StoreAttrDefault(rel, con->attnum, con->expr, is_internal); + con->conoid = StoreAttrDefault(rel, con->attnum, con->expr, + is_internal); break; case CONSTR_CHECK: - StoreRelCheck(rel, con->name, con->expr, !con->skip_validation, - con->is_local, con->inhcount, - con->is_no_inherit, is_internal); + con->conoid = + StoreRelCheck(rel, con->name, con->expr, + !con->skip_validation, con->is_local, con->inhcount, + con->is_no_inherit, is_internal); numchecks++; break; default: @@ -2184,6 +2195,7 @@ AddRelationNewConstraints(Relation rel, { RawColumnDefault *colDef = (RawColumnDefault *) lfirst(cell); Form_pg_attribute atp = rel->rd_att->attrs[colDef->attnum - 1]; + Oid defOid; expr = cookDefault(pstate, colDef->raw_default, atp->atttypid, atp->atttypmod, @@ -2204,10 +2216,11 @@ AddRelationNewConstraints(Relation rel, (IsA(expr, Const) &&((Const *) expr)->constisnull)) continue; - StoreAttrDefault(rel, colDef->attnum, expr, is_internal); + defOid = StoreAttrDefault(rel, colDef->attnum, expr, is_internal); cooked = (CookedConstraint *) palloc(sizeof(CookedConstraint)); cooked->contype = CONSTR_DEFAULT; + cooked->conoid = defOid; cooked->name = NULL; cooked->attnum = colDef->attnum; cooked->expr = expr; @@ -2227,6 +2240,7 @@ AddRelationNewConstraints(Relation rel, { Constraint *cdef = (Constraint *) lfirst(cell); char *ccname; + Oid constrOid; if (cdef->contype != CONSTR_CHECK) continue; @@ -2336,13 +2350,15 @@ AddRelationNewConstraints(Relation rel, /* * OK, store it. */ - StoreRelCheck(rel, ccname, expr, !cdef->skip_validation, is_local, - is_local ? 0 : 1, cdef->is_no_inherit, is_internal); + constrOid = + StoreRelCheck(rel, ccname, expr, !cdef->skip_validation, is_local, + is_local ? 0 : 1, cdef->is_no_inherit, is_internal); numchecks++; cooked = (CookedConstraint *) palloc(sizeof(CookedConstraint)); cooked->contype = CONSTR_CHECK; + cooked->conoid = constrOid; cooked->name = ccname; cooked->attnum = 0; cooked->expr = expr; diff --git a/src/backend/catalog/index.c b/src/backend/catalog/index.c index f85ed93..5773298 100644 --- a/src/backend/catalog/index.c +++ b/src/backend/catalog/index.c @@ -1111,7 +1111,8 @@ index_create(Relation heapRelation, /* * index_constraint_create * - * Set up a constraint associated with an index + * Set up a constraint associated with an index. Return the new constraint's + * OID. * * heapRelation: table owning the index (must be suitably locked by caller) * indexRelationId: OID of the index @@ -1128,7 +1129,7 @@ index_create(Relation heapRelation, * allow_system_table_mods: allow table to be a system catalog * is_internal: index is constructed due to internal process */ -void +Oid index_constraint_create(Relation heapRelation, Oid indexRelationId, IndexInfo *indexInfo, @@ -1316,6 +1317,8 @@ index_constraint_create(Relation heapRelation, heap_freetuple(indexTuple); heap_close(pg_index, RowExclusiveLock); } + + return conOid; } /* diff --git a/src/backend/catalog/pg_constraint.c b/src/backend/catalog/pg_constraint.c index 77fe918..3c756f8 100644 --- a/src/backend/catalog/pg_constraint.c +++ b/src/backend/catalog/pg_constraint.c @@ -40,6 +40,8 @@ * Subsidiary records (such as triggers or indexes to implement the * constraint) are *not* created here. But we do make dependency links * from the constraint to the things it depends on. + * + * The new constraint's OID is returned. */ Oid CreateConstraintEntry(const char *constraintName, diff --git a/src/backend/commands/tablecmds.c b/src/backend/commands/tablecmds.c index 623e6bf..fc2c8a9 100644 --- a/src/backend/commands/tablecmds.c +++ b/src/backend/commands/tablecmds.c @@ -282,9 +282,9 @@ static void AlterIndexNamespaces(Relation classRel, Relation rel, static void AlterSeqNamespaces(Relation classRel, Relation rel, Oid oldNspOid, Oid newNspOid, ObjectAddresses *objsMoved, LOCKMODE lockmode); -static void ATExecAlterConstraint(Relation rel, AlterTableCmd *cmd, +static Oid ATExecAlterConstraint(Relation rel, AlterTableCmd *cmd, bool recurse, bool recursing, LOCKMODE lockmode); -static void ATExecValidateConstraint(Relation rel, char *constrName, +static Oid ATExecValidateConstraint(Relation rel, char *constrName, bool recurse, bool recursing, LOCKMODE lockmode); static int transformColumnNameList(Oid relId, List *colList, int16 *attnums, Oid *atttypids); @@ -326,26 +326,26 @@ 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); -static void ATExecAddColumn(List **wqueue, AlteredTableInfo *tab, Relation rel, - ColumnDef *colDef, bool isOid, +static AttrNumber ATExecAddColumn(List **wqueue, AlteredTableInfo *tab, + Relation rel, ColumnDef *colDef, bool isOid, bool recurse, bool recursing, LOCKMODE lockmode); static void check_for_column_name_collision(Relation rel, const char *colname); static void add_column_datatype_dependency(Oid relid, int32 attnum, Oid typid); static void add_column_collation_dependency(Oid relid, int32 attnum, Oid collid); static void ATPrepAddOids(List **wqueue, Relation rel, bool recurse, AlterTableCmd *cmd, LOCKMODE lockmode); -static void ATExecDropNotNull(Relation rel, const char *colName, LOCKMODE lockmode); -static void ATExecSetNotNull(AlteredTableInfo *tab, Relation rel, +static AttrNumber ATExecDropNotNull(Relation rel, const char *colName, LOCKMODE lockmode); +static AttrNumber ATExecSetNotNull(AlteredTableInfo *tab, Relation rel, const char *colName, LOCKMODE lockmode); -static void ATExecColumnDefault(Relation rel, const char *colName, +static AttrNumber ATExecColumnDefault(Relation rel, const char *colName, Node *newDefault, LOCKMODE lockmode); static void ATPrepSetStatistics(Relation rel, const char *colName, Node *newValue, LOCKMODE lockmode); -static void ATExecSetStatistics(Relation rel, const char *colName, +static AttrNumber ATExecSetStatistics(Relation rel, const char *colName, Node *newValue, LOCKMODE lockmode); -static void ATExecSetOptions(Relation rel, const char *colName, +static AttrNumber ATExecSetOptions(Relation rel, const char *colName, Node *options, bool isReset, LOCKMODE lockmode); -static void ATExecSetStorage(Relation rel, const char *colName, +static AttrNumber 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); @@ -353,20 +353,20 @@ static void ATExecDropColumn(List **wqueue, Relation rel, const char *colName, DropBehavior behavior, bool recurse, bool recursing, bool missing_ok, LOCKMODE lockmode); -static void ATExecAddIndex(AlteredTableInfo *tab, Relation rel, +static Oid ATExecAddIndex(AlteredTableInfo *tab, Relation rel, IndexStmt *stmt, bool is_rebuild, LOCKMODE lockmode); -static void ATExecAddConstraint(List **wqueue, +static Oid ATExecAddConstraint(List **wqueue, AlteredTableInfo *tab, Relation rel, Constraint *newConstraint, bool recurse, bool is_readd, LOCKMODE lockmode); -static void ATExecAddIndexConstraint(AlteredTableInfo *tab, Relation rel, +static Oid ATExecAddIndexConstraint(AlteredTableInfo *tab, Relation rel, IndexStmt *stmt, LOCKMODE lockmode); -static void ATAddCheckConstraint(List **wqueue, +static Oid ATAddCheckConstraint(List **wqueue, AlteredTableInfo *tab, Relation rel, Constraint *constr, bool recurse, bool recursing, bool is_readd, LOCKMODE lockmode); -static void ATAddForeignKeyConstraint(AlteredTableInfo *tab, Relation rel, +static Oid ATAddForeignKeyConstraint(AlteredTableInfo *tab, Relation rel, Constraint *fkconstraint, LOCKMODE lockmode); static void ATExecDropConstraint(Relation rel, const char *constrName, DropBehavior behavior, @@ -377,9 +377,9 @@ static void ATPrepAlterColumnType(List **wqueue, bool recurse, bool recursing, AlterTableCmd *cmd, LOCKMODE lockmode); static bool ATColumnChangeRequiresRewrite(Node *expr, AttrNumber varattno); -static void ATExecAlterColumnType(AlteredTableInfo *tab, Relation rel, +static AttrNumber ATExecAlterColumnType(AlteredTableInfo *tab, Relation rel, AlterTableCmd *cmd, LOCKMODE lockmode); -static void ATExecAlterColumnGenericOptions(Relation rel, const char *colName, +static AttrNumber ATExecAlterColumnGenericOptions(Relation rel, const char *colName, List *options, LOCKMODE lockmode); static void ATPostAlterTypeCleanup(List **wqueue, AlteredTableInfo *tab, LOCKMODE lockmode); @@ -392,7 +392,7 @@ 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 void ATExecClusterOn(Relation rel, const char *indexName, +static Oid ATExecClusterOn(Relation rel, const char *indexName, LOCKMODE lockmode); static void ATExecDropCluster(Relation rel, LOCKMODE lockmode); static bool ATPrepChangePersistence(Relation rel, bool toLogged); @@ -407,10 +407,10 @@ static void ATExecEnableDisableTrigger(Relation rel, char *trigname, static void ATExecEnableDisableRule(Relation rel, char *rulename, char fires_when, LOCKMODE lockmode); static void ATPrepAddInherit(Relation child_rel); -static void ATExecAddInherit(Relation child_rel, RangeVar *parent, LOCKMODE lockmode); -static void ATExecDropInherit(Relation rel, RangeVar *parent, LOCKMODE lockmode); +static Oid ATExecAddInherit(Relation child_rel, RangeVar *parent, LOCKMODE lockmode); +static Oid ATExecDropInherit(Relation rel, RangeVar *parent, LOCKMODE lockmode); static void drop_parent_dependency(Oid relid, Oid refclassid, Oid refobjid); -static void ATExecAddOf(Relation rel, const TypeName *ofTypename, LOCKMODE lockmode); +static Oid 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); @@ -623,6 +623,7 @@ DefineRelation(CreateStmt *stmt, char relkind, Oid ownerId, cooked = (CookedConstraint *) palloc(sizeof(CookedConstraint)); cooked->contype = CONSTR_DEFAULT; + cooked->conoid = InvalidOid; cooked->name = NULL; cooked->attnum = attnum; cooked->expr = colDef->cooked_default; @@ -1741,6 +1742,7 @@ MergeAttributes(List *schema, List *supers, char relpersistence, cooked = (CookedConstraint *) palloc(sizeof(CookedConstraint)); cooked->contype = CONSTR_CHECK; + cooked->conoid = InvalidOid; cooked->name = pstrdup(name); cooked->attnum = 0; /* not used for constraints */ cooked->expr = expr; @@ -3416,78 +3418,95 @@ static void ATExecCmd(List **wqueue, AlteredTableInfo *tab, Relation rel, AlterTableCmd *cmd, LOCKMODE lockmode) { + AttrNumber colno = InvalidAttrNumber; + Oid newoid = InvalidOid; + + /* temporary measure to silence unused-variable compiler warnings */ + (void) colno; + (void) newoid; + switch (cmd->subtype) { case AT_AddColumn: /* ADD COLUMN */ case AT_AddColumnToView: /* add column via CREATE OR REPLACE * VIEW */ - ATExecAddColumn(wqueue, tab, rel, (ColumnDef *) cmd->def, - false, false, false, lockmode); + colno = ATExecAddColumn(wqueue, tab, rel, (ColumnDef *) cmd->def, + false, false, false, lockmode); break; case AT_AddColumnRecurse: - ATExecAddColumn(wqueue, tab, rel, (ColumnDef *) cmd->def, - false, true, false, lockmode); + colno = ATExecAddColumn(wqueue, tab, rel, (ColumnDef *) cmd->def, + false, true, false, lockmode); break; case AT_ColumnDefault: /* ALTER COLUMN DEFAULT */ - ATExecColumnDefault(rel, cmd->name, cmd->def, lockmode); + colno = ATExecColumnDefault(rel, cmd->name, cmd->def, lockmode); break; case AT_DropNotNull: /* ALTER COLUMN DROP NOT NULL */ - ATExecDropNotNull(rel, cmd->name, lockmode); + colno = ATExecDropNotNull(rel, cmd->name, lockmode); break; case AT_SetNotNull: /* ALTER COLUMN SET NOT NULL */ - ATExecSetNotNull(tab, rel, cmd->name, lockmode); + colno = ATExecSetNotNull(tab, rel, cmd->name, lockmode); break; case AT_SetStatistics: /* ALTER COLUMN SET STATISTICS */ - ATExecSetStatistics(rel, cmd->name, cmd->def, lockmode); + colno = ATExecSetStatistics(rel, cmd->name, cmd->def, lockmode); break; case AT_SetOptions: /* ALTER COLUMN SET ( options ) */ - ATExecSetOptions(rel, cmd->name, cmd->def, false, lockmode); + colno = ATExecSetOptions(rel, cmd->name, cmd->def, false, lockmode); break; case AT_ResetOptions: /* ALTER COLUMN RESET ( options ) */ - ATExecSetOptions(rel, cmd->name, cmd->def, true, lockmode); + colno = ATExecSetOptions(rel, cmd->name, cmd->def, true, lockmode); break; case AT_SetStorage: /* ALTER COLUMN SET STORAGE */ - ATExecSetStorage(rel, cmd->name, cmd->def, lockmode); + colno = ATExecSetStorage(rel, cmd->name, cmd->def, lockmode); break; case AT_DropColumn: /* DROP COLUMN */ ATExecDropColumn(wqueue, rel, cmd->name, - cmd->behavior, false, false, cmd->missing_ok, lockmode); + cmd->behavior, false, false, + cmd->missing_ok, lockmode); break; case AT_DropColumnRecurse: /* DROP COLUMN with recursion */ ATExecDropColumn(wqueue, rel, cmd->name, - cmd->behavior, true, false, cmd->missing_ok, lockmode); + cmd->behavior, true, false, + cmd->missing_ok, lockmode); break; case AT_AddIndex: /* ADD INDEX */ - ATExecAddIndex(tab, rel, (IndexStmt *) cmd->def, false, lockmode); + newoid = ATExecAddIndex(tab, rel, (IndexStmt *) cmd->def, false, + lockmode); break; case AT_ReAddIndex: /* ADD INDEX */ - ATExecAddIndex(tab, rel, (IndexStmt *) cmd->def, true, lockmode); + newoid = ATExecAddIndex(tab, rel, (IndexStmt *) cmd->def, true, + lockmode); break; case AT_AddConstraint: /* ADD CONSTRAINT */ - ATExecAddConstraint(wqueue, tab, rel, (Constraint *) cmd->def, - false, false, lockmode); + newoid = + ATExecAddConstraint(wqueue, tab, rel, (Constraint *) cmd->def, + false, false, lockmode); break; case AT_AddConstraintRecurse: /* ADD CONSTRAINT with recursion */ - ATExecAddConstraint(wqueue, tab, rel, (Constraint *) cmd->def, - true, false, lockmode); + newoid = + ATExecAddConstraint(wqueue, tab, rel, (Constraint *) cmd->def, + true, false, lockmode); break; case AT_ReAddConstraint: /* Re-add pre-existing check * constraint */ - ATExecAddConstraint(wqueue, tab, rel, (Constraint *) cmd->def, - false, true, lockmode); + newoid = + ATExecAddConstraint(wqueue, tab, rel, (Constraint *) cmd->def, + false, true, lockmode); break; case AT_AddIndexConstraint: /* ADD CONSTRAINT USING INDEX */ - ATExecAddIndexConstraint(tab, rel, (IndexStmt *) cmd->def, lockmode); + newoid = ATExecAddIndexConstraint(tab, rel, (IndexStmt *) cmd->def, + lockmode); break; case AT_AlterConstraint: /* ALTER CONSTRAINT */ - ATExecAlterConstraint(rel, cmd, false, false, lockmode); + newoid = ATExecAlterConstraint(rel, cmd, false, false, lockmode); break; case AT_ValidateConstraint: /* VALIDATE CONSTRAINT */ - ATExecValidateConstraint(rel, cmd->name, false, false, lockmode); + newoid = ATExecValidateConstraint(rel, cmd->name, false, false, + lockmode); break; case AT_ValidateConstraintRecurse: /* VALIDATE CONSTRAINT with * recursion */ - ATExecValidateConstraint(rel, cmd->name, true, false, lockmode); + newoid = ATExecValidateConstraint(rel, cmd->name, true, false, + lockmode); break; case AT_DropConstraint: /* DROP CONSTRAINT */ ATExecDropConstraint(rel, cmd->name, cmd->behavior, @@ -3500,10 +3519,12 @@ ATExecCmd(List **wqueue, AlteredTableInfo *tab, Relation rel, cmd->missing_ok, lockmode); break; case AT_AlterColumnType: /* ALTER COLUMN TYPE */ - ATExecAlterColumnType(tab, rel, cmd, lockmode); + colno = ATExecAlterColumnType(tab, rel, cmd, lockmode); break; case AT_AlterColumnGenericOptions: /* ALTER COLUMN OPTIONS */ - ATExecAlterColumnGenericOptions(rel, cmd->name, (List *) cmd->def, lockmode); + colno = + ATExecAlterColumnGenericOptions(rel, cmd->name, + (List *) cmd->def, lockmode); break; case AT_ChangeOwner: /* ALTER OWNER */ ATExecChangeOwner(RelationGetRelid(rel), @@ -3511,7 +3532,7 @@ ATExecCmd(List **wqueue, AlteredTableInfo *tab, Relation rel, false, lockmode); break; case AT_ClusterOn: /* CLUSTER ON */ - ATExecClusterOn(rel, cmd->name, lockmode); + newoid = ATExecClusterOn(rel, cmd->name, lockmode); break; case AT_DropCluster: /* SET WITHOUT CLUSTER */ ATExecDropCluster(rel, lockmode); @@ -3600,19 +3621,20 @@ ATExecCmd(List **wqueue, AlteredTableInfo *tab, Relation rel, break; case AT_AddInherit: - ATExecAddInherit(rel, (RangeVar *) cmd->def, lockmode); + newoid = ATExecAddInherit(rel, (RangeVar *) cmd->def, lockmode); break; case AT_DropInherit: - ATExecDropInherit(rel, (RangeVar *) cmd->def, lockmode); + newoid = ATExecDropInherit(rel, (RangeVar *) cmd->def, lockmode); break; case AT_AddOf: - ATExecAddOf(rel, (TypeName *) cmd->def, lockmode); + newoid = ATExecAddOf(rel, (TypeName *) cmd->def, lockmode); break; case AT_DropOf: ATExecDropOf(rel, lockmode); break; case AT_ReplicaIdentity: - ATExecReplicaIdentity(rel, (ReplicaIdentityStmt *) cmd->def, lockmode); + ATExecReplicaIdentity(rel, (ReplicaIdentityStmt *) cmd->def, + lockmode); break; case AT_EnableRowSecurity: ATExecEnableRowSecurity(rel); @@ -4613,7 +4635,7 @@ ATPrepAddColumn(List **wqueue, Relation rel, bool recurse, bool recursing, cmd->subtype = AT_AddColumnRecurse; } -static void +static AttrNumber ATExecAddColumn(List **wqueue, AlteredTableInfo *tab, Relation rel, ColumnDef *colDef, bool isOid, bool recurse, bool recursing, LOCKMODE lockmode) @@ -4698,7 +4720,7 @@ ATExecAddColumn(List **wqueue, AlteredTableInfo *tab, Relation rel, colDef->colname, RelationGetRelationName(rel)))); heap_close(attrdesc, RowExclusiveLock); - return; + return InvalidAttrNumber; } } @@ -4944,6 +4966,8 @@ ATExecAddColumn(List **wqueue, AlteredTableInfo *tab, Relation rel, heap_close(childrel, NoLock); } + + return newattnum; } /* @@ -5058,7 +5082,7 @@ ATPrepAddOids(List **wqueue, Relation rel, bool recurse, AlterTableCmd *cmd, LOC /* * ALTER TABLE ALTER COLUMN DROP NOT NULL */ -static void +static AttrNumber ATExecDropNotNull(Relation rel, const char *colName, LOCKMODE lockmode) { HeapTuple tuple; @@ -5143,18 +5167,22 @@ ATExecDropNotNull(Relation rel, const char *colName, LOCKMODE lockmode) /* keep the system catalog indexes current */ CatalogUpdateIndexes(attr_rel, tuple); + + /* XXX should we return InvalidAttrNumber if there was no change? */ } InvokeObjectPostAlterHook(RelationRelationId, RelationGetRelid(rel), attnum); heap_close(attr_rel, RowExclusiveLock); + + return attnum; } /* * ALTER TABLE ALTER COLUMN SET NOT NULL */ -static void +static AttrNumber ATExecSetNotNull(AlteredTableInfo *tab, Relation rel, const char *colName, LOCKMODE lockmode) { @@ -5198,18 +5226,22 @@ ATExecSetNotNull(AlteredTableInfo *tab, Relation rel, /* Tell Phase 3 it needs to test the constraint */ tab->new_notnull = true; + + /* XXX should we return InvalidAttrNumber if there was no change? */ } InvokeObjectPostAlterHook(RelationRelationId, RelationGetRelid(rel), attnum); heap_close(attr_rel, RowExclusiveLock); + + return attnum; } /* * ALTER TABLE ALTER COLUMN SET/DROP DEFAULT */ -static void +static AttrNumber ATExecColumnDefault(Relation rel, const char *colName, Node *newDefault, LOCKMODE lockmode) { @@ -5260,6 +5292,8 @@ ATExecColumnDefault(Relation rel, const char *colName, AddRelationNewConstraints(rel, list_make1(rawEnt), NIL, false, true, false); } + + return attnum; } /* @@ -5289,13 +5323,14 @@ ATPrepSetStatistics(Relation rel, const char *colName, Node *newValue, LOCKMODE RelationGetRelationName(rel)); } -static void +static AttrNumber ATExecSetStatistics(Relation rel, const char *colName, Node *newValue, LOCKMODE lockmode) { int newtarget; Relation attrelation; HeapTuple tuple; Form_pg_attribute attrtuple; + AttrNumber attnum; Assert(IsA(newValue, Integer)); newtarget = intVal(newValue); @@ -5330,7 +5365,8 @@ ATExecSetStatistics(Relation rel, const char *colName, Node *newValue, LOCKMODE colName, RelationGetRelationName(rel)))); attrtuple = (Form_pg_attribute) GETSTRUCT(tuple); - if (attrtuple->attnum <= 0) + attnum = attrtuple->attnum; + if (attnum <= 0) ereport(ERROR, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), errmsg("cannot alter system column \"%s\"", @@ -5349,9 +5385,11 @@ ATExecSetStatistics(Relation rel, const char *colName, Node *newValue, LOCKMODE heap_freetuple(tuple); heap_close(attrelation, RowExclusiveLock); + + return attnum; } -static void +static AttrNumber ATExecSetOptions(Relation rel, const char *colName, Node *options, bool isReset, LOCKMODE lockmode) { @@ -5359,6 +5397,7 @@ ATExecSetOptions(Relation rel, const char *colName, Node *options, HeapTuple tuple, newtuple; Form_pg_attribute attrtuple; + AttrNumber attnum; Datum datum, newOptions; bool isnull; @@ -5377,7 +5416,8 @@ ATExecSetOptions(Relation rel, const char *colName, Node *options, colName, RelationGetRelationName(rel)))); attrtuple = (Form_pg_attribute) GETSTRUCT(tuple); - if (attrtuple->attnum <= 0) + attnum = attrtuple->attnum; + if (attnum <= 0) ereport(ERROR, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), errmsg("cannot alter system column \"%s\"", @@ -5416,12 +5456,14 @@ ATExecSetOptions(Relation rel, const char *colName, Node *options, ReleaseSysCache(tuple); heap_close(attrelation, RowExclusiveLock); + + return attnum; } /* * ALTER TABLE ALTER COLUMN SET STORAGE */ -static void +static AttrNumber ATExecSetStorage(Relation rel, const char *colName, Node *newValue, LOCKMODE lockmode) { char *storagemode; @@ -5429,6 +5471,7 @@ ATExecSetStorage(Relation rel, const char *colName, Node *newValue, LOCKMODE loc Relation attrelation; HeapTuple tuple; Form_pg_attribute attrtuple; + AttrNumber attnum; Assert(IsA(newValue, String)); storagemode = strVal(newValue); @@ -5461,7 +5504,8 @@ ATExecSetStorage(Relation rel, const char *colName, Node *newValue, LOCKMODE loc colName, RelationGetRelationName(rel)))); attrtuple = (Form_pg_attribute) GETSTRUCT(tuple); - if (attrtuple->attnum <= 0) + attnum = attrtuple->attnum; + if (attnum <= 0) ereport(ERROR, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), errmsg("cannot alter system column \"%s\"", @@ -5491,6 +5535,8 @@ ATExecSetStorage(Relation rel, const char *colName, Node *newValue, LOCKMODE loc heap_freetuple(tuple); heap_close(attrelation, RowExclusiveLock); + + return attnum; } @@ -5715,8 +5761,10 @@ ATExecDropColumn(List **wqueue, Relation rel, const char *colName, * There is no such command in the grammar, but parse_utilcmd.c converts * UNIQUE and PRIMARY KEY constraints into AT_AddIndex subcommands. This lets * us schedule creation of the index at the appropriate time during ALTER. + * + * Return value is the OID of the new index. */ -static void +static Oid ATExecAddIndex(AlteredTableInfo *tab, Relation rel, IndexStmt *stmt, bool is_rebuild, LOCKMODE lockmode) { @@ -5759,12 +5807,14 @@ ATExecAddIndex(AlteredTableInfo *tab, Relation rel, RelationPreserveStorage(irel->rd_node, true); index_close(irel, NoLock); } + + return address.objectId; } /* * ALTER TABLE ADD CONSTRAINT USING INDEX */ -static void +static Oid ATExecAddIndexConstraint(AlteredTableInfo *tab, Relation rel, IndexStmt *stmt, LOCKMODE lockmode) { @@ -5774,6 +5824,7 @@ ATExecAddIndexConstraint(AlteredTableInfo *tab, Relation rel, IndexInfo *indexInfo; char *constraintName; char constraintType; + Oid conOid; Assert(IsA(stmt, IndexStmt)); Assert(OidIsValid(index_oid)); @@ -5818,30 +5869,34 @@ ATExecAddIndexConstraint(AlteredTableInfo *tab, Relation rel, constraintType = CONSTRAINT_UNIQUE; /* Create the catalog entries for the constraint */ - index_constraint_create(rel, - index_oid, - indexInfo, - constraintName, - constraintType, - stmt->deferrable, - stmt->initdeferred, - stmt->primary, - true, /* update pg_index */ - true, /* remove old dependencies */ - allowSystemTableMods, - false); /* is_internal */ + conOid = index_constraint_create(rel, + index_oid, + indexInfo, + constraintName, + constraintType, + stmt->deferrable, + stmt->initdeferred, + stmt->primary, + true, /* update pg_index */ + true, /* remove old dependencies */ + allowSystemTableMods, + false); /* is_internal */ index_close(indexRel, NoLock); + + return conOid; } /* * ALTER TABLE ADD CONSTRAINT */ -static void +static Oid ATExecAddConstraint(List **wqueue, AlteredTableInfo *tab, Relation rel, Constraint *newConstraint, bool recurse, bool is_readd, LOCKMODE lockmode) { + Oid constrOid = InvalidOid; + Assert(IsA(newConstraint, Constraint)); /* @@ -5852,9 +5907,10 @@ ATExecAddConstraint(List **wqueue, AlteredTableInfo *tab, Relation rel, switch (newConstraint->contype) { case CONSTR_CHECK: - ATAddCheckConstraint(wqueue, tab, rel, - newConstraint, recurse, false, is_readd, - lockmode); + constrOid = + ATAddCheckConstraint(wqueue, tab, rel, + newConstraint, recurse, false, is_readd, + lockmode); break; case CONSTR_FOREIGN: @@ -5885,17 +5941,22 @@ ATExecAddConstraint(List **wqueue, AlteredTableInfo *tab, Relation rel, RelationGetNamespace(rel), NIL); - ATAddForeignKeyConstraint(tab, rel, newConstraint, lockmode); + constrOid = ATAddForeignKeyConstraint(tab, rel, newConstraint, + lockmode); break; default: elog(ERROR, "unrecognized constraint type: %d", (int) newConstraint->contype); } + + return constrOid; } /* - * Add a check constraint to a single table and its children + * Add a check constraint to a single table and its children. Returns the + * OID of the constraint added to the parent relation, if one gets added, + * or InvalidOid otherwise. * * Subroutine for ATExecAddConstraint. * @@ -5914,7 +5975,7 @@ ATExecAddConstraint(List **wqueue, AlteredTableInfo *tab, Relation rel, * "is_readd" flag for that; just setting recurse=false would result in an * error if there are child tables. */ -static void +static Oid ATAddCheckConstraint(List **wqueue, AlteredTableInfo *tab, Relation rel, Constraint *constr, bool recurse, bool recursing, bool is_readd, LOCKMODE lockmode) @@ -5923,6 +5984,7 @@ ATAddCheckConstraint(List **wqueue, AlteredTableInfo *tab, Relation rel, ListCell *lcon; List *children; ListCell *child; + Oid constrOid = InvalidOid; /* At top level, permission check was done in ATPrepCmd, else do it */ if (recursing) @@ -5965,6 +6027,13 @@ ATAddCheckConstraint(List **wqueue, AlteredTableInfo *tab, Relation rel, /* Save the actually assigned name if it was defaulted */ if (constr->conname == NULL) constr->conname = ccon->name; + + /* + * Save our return value. Note we don't expect more than one element in + * this list. + */ + Assert(constrOid == InvalidOid); + constrOid = ccon->conoid; } /* At this point we must have a locked-down name to use */ @@ -5980,7 +6049,7 @@ ATAddCheckConstraint(List **wqueue, AlteredTableInfo *tab, Relation rel, * incorrect value for coninhcount. */ if (newcons == NIL) - return; + return InvalidOid; /* * If adding a NO INHERIT constraint, no need to find our children. @@ -5988,7 +6057,7 @@ ATAddCheckConstraint(List **wqueue, AlteredTableInfo *tab, Relation rel, * handled at higher levels). */ if (constr->is_no_inherit || is_readd) - return; + return constrOid; /* * Propagate to children as appropriate. Unlike most other ALTER @@ -6026,16 +6095,19 @@ ATAddCheckConstraint(List **wqueue, AlteredTableInfo *tab, Relation rel, heap_close(childrel, NoLock); } + + return constrOid; } /* - * Add a foreign-key constraint to a single table + * Add a foreign-key constraint to a single table; return the new constraint's + * OID. * * Subroutine for ATExecAddConstraint. Must already hold exclusive * lock on the rel, and have done appropriate validity checks for it. * We do permissions checks here, however. */ -static void +static Oid ATAddForeignKeyConstraint(AlteredTableInfo *tab, Relation rel, Constraint *fkconstraint, LOCKMODE lockmode) { @@ -6434,6 +6506,8 @@ ATAddForeignKeyConstraint(AlteredTableInfo *tab, Relation rel, * Close pk table, but keep lock until we've committed. */ heap_close(pkrel, NoLock); + + return constrOid; } /* @@ -6446,7 +6520,7 @@ ATAddForeignKeyConstraint(AlteredTableInfo *tab, Relation rel, * recursion bit here, but we keep the API the same for when * other constraint types are supported. */ -static void +static Oid ATExecAlterConstraint(Relation rel, AlterTableCmd *cmd, bool recurse, bool recursing, LOCKMODE lockmode) { @@ -6457,6 +6531,7 @@ ATExecAlterConstraint(Relation rel, AlterTableCmd *cmd, Form_pg_constraint currcon = NULL; Constraint *cmdcon = NULL; bool found = false; + Oid constrOid = InvalidOid; Assert(IsA(cmd->def, Constraint)); cmdcon = (Constraint *) cmd->def; @@ -6516,6 +6591,8 @@ ATExecAlterConstraint(Relation rel, AlterTableCmd *cmd, simple_heap_update(conrel, ©Tuple->t_self, copyTuple); CatalogUpdateIndexes(conrel, copyTuple); + constrOid = HeapTupleGetOid(contuple); + InvokeObjectPostAlterHook(ConstraintRelationId, HeapTupleGetOid(contuple), 0); @@ -6563,6 +6640,8 @@ ATExecAlterConstraint(Relation rel, AlterTableCmd *cmd, systable_endscan(scan); heap_close(conrel, RowExclusiveLock); + + return constrOid; } /* @@ -6573,7 +6652,7 @@ ATExecAlterConstraint(Relation rel, AlterTableCmd *cmd, * no need to lock children in that case, yet we wouldn't be able to avoid * doing so at that level. */ -static void +static Oid ATExecValidateConstraint(Relation rel, char *constrName, bool recurse, bool recursing, LOCKMODE lockmode) { @@ -6583,6 +6662,7 @@ ATExecValidateConstraint(Relation rel, char *constrName, bool recurse, HeapTuple tuple; Form_pg_constraint con = NULL; bool found = false; + Oid constrOid = InvalidOid; conrel = heap_open(ConstraintRelationId, RowExclusiveLock); @@ -6624,9 +6704,10 @@ ATExecValidateConstraint(Relation rel, char *constrName, bool recurse, HeapTuple copyTuple; Form_pg_constraint copy_con; + constrOid = HeapTupleGetOid(tuple); + if (con->contype == CONSTRAINT_FOREIGN) { - Oid conid = HeapTupleGetOid(tuple); Relation refrel; /* @@ -6641,7 +6722,7 @@ ATExecValidateConstraint(Relation rel, char *constrName, bool recurse, validateForeignKeyConstraint(constrName, rel, refrel, con->conindid, - conid); + constrOid); heap_close(refrel, NoLock); /* @@ -6722,6 +6803,8 @@ ATExecValidateConstraint(Relation rel, char *constrName, bool recurse, systable_endscan(scan); heap_close(conrel, RowExclusiveLock); + + return constrOid; } @@ -7808,7 +7891,7 @@ ATColumnChangeRequiresRewrite(Node *expr, AttrNumber varattno) } } -static void +static AttrNumber ATExecAlterColumnType(AlteredTableInfo *tab, Relation rel, AlterTableCmd *cmd, LOCKMODE lockmode) { @@ -8202,9 +8285,11 @@ ATExecAlterColumnType(AlteredTableInfo *tab, Relation rel, /* Cleanup */ heap_freetuple(heapTup); + + return attnum; } -static void +static AttrNumber ATExecAlterColumnGenericOptions(Relation rel, const char *colName, List *options, @@ -8223,9 +8308,10 @@ ATExecAlterColumnGenericOptions(Relation rel, Datum datum; Form_pg_foreign_table fttableform; Form_pg_attribute atttableform; + AttrNumber attnum; if (options == NIL) - return; + return InvalidAttrNumber; /* First, determine FDW validator associated to the foreign table. */ ftrel = heap_open(ForeignTableRelationId, AccessShareLock); @@ -8252,7 +8338,8 @@ ATExecAlterColumnGenericOptions(Relation rel, /* Prevent them from altering a system attribute */ atttableform = (Form_pg_attribute) GETSTRUCT(tuple); - if (atttableform->attnum <= 0) + attnum = atttableform->attnum; + if (attnum <= 0) ereport(ERROR, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), errmsg("cannot alter system column \"%s\"", colName))); @@ -8301,6 +8388,8 @@ ATExecAlterColumnGenericOptions(Relation rel, heap_close(attrel, RowExclusiveLock); heap_freetuple(newtuple); + + return attnum; } /* @@ -8942,7 +9031,7 @@ change_owner_recurse_to_sequences(Oid relationOid, Oid newOwnerId, LOCKMODE lock * * The only thing we have to do is to change the indisclustered bits. */ -static void +static Oid ATExecClusterOn(Relation rel, const char *indexName, LOCKMODE lockmode) { Oid indexOid; @@ -8960,6 +9049,8 @@ ATExecClusterOn(Relation rel, const char *indexName, LOCKMODE lockmode) /* And do the work */ mark_index_clustered(rel, indexOid, false); + + return indexOid; } /* @@ -9660,11 +9751,12 @@ ATPrepAddInherit(Relation child_rel) errmsg("cannot change inheritance of typed table"))); } -static void +static Oid ATExecAddInherit(Relation child_rel, RangeVar *parent, LOCKMODE lockmode) { Relation parent_rel, catalogRelation; + Oid parent_oid; SysScanDesc scan; ScanKeyData key; HeapTuple inheritsTuple; @@ -9784,11 +9876,15 @@ ATExecAddInherit(Relation child_rel, RangeVar *parent, LOCKMODE lockmode) inhseqno + 1, catalogRelation); + parent_oid = RelationGetRelid(parent_rel); + /* Now we're done with pg_inherits */ heap_close(catalogRelation, RowExclusiveLock); /* keep our lock on the parent relation until commit */ heap_close(parent_rel, NoLock); + + return parent_oid; } /* @@ -10057,10 +10153,11 @@ MergeConstraintsIntoExisting(Relation child_rel, Relation parent_rel) * coninhcount and conislocal for inherited constraints are adjusted in * exactly the same way. */ -static void +static Oid ATExecDropInherit(Relation rel, RangeVar *parent, LOCKMODE lockmode) { Relation parent_rel; + Oid parent_oid; Relation catalogRelation; SysScanDesc scan; ScanKeyData key[3]; @@ -10229,6 +10326,8 @@ ATExecDropInherit(Relation rel, RangeVar *parent, LOCKMODE lockmode) } } + parent_oid = RelationGetRelid(parent_rel); + systable_endscan(scan); heap_close(catalogRelation, RowExclusiveLock); @@ -10247,6 +10346,8 @@ ATExecDropInherit(Relation rel, RangeVar *parent, LOCKMODE lockmode) /* keep our lock on the parent relation until commit */ heap_close(parent_rel, NoLock); + + return parent_oid; } /* @@ -10304,8 +10405,10 @@ drop_parent_dependency(Oid relid, Oid refclassid, Oid refobjid) * TABLE OF. All attname, atttypid, atttypmod and attcollation must match. The * subject table must not have inheritance parents. These restrictions ensure * that you cannot create a configuration impossible with CREATE TABLE OF alone. + * + * The OID of the type is returned. */ -static void +static Oid ATExecAddOf(Relation rel, const TypeName *ofTypename, LOCKMODE lockmode) { Oid relid = RelationGetRelid(rel); @@ -10434,6 +10537,8 @@ ATExecAddOf(Relation rel, const TypeName *ofTypename, LOCKMODE lockmode) heap_close(relationRelation, RowExclusiveLock); ReleaseSysCache(typetuple); + + return typeid; } /* diff --git a/src/include/catalog/heap.h b/src/include/catalog/heap.h index 573b2de..9a8fa1e 100644 --- a/src/include/catalog/heap.h +++ b/src/include/catalog/heap.h @@ -28,6 +28,7 @@ typedef struct RawColumnDefault typedef struct CookedConstraint { ConstrType contype; /* CONSTR_DEFAULT or CONSTR_CHECK */ + Oid conoid; /* OID of the new element */ char *name; /* name, or NULL if none */ AttrNumber attnum; /* which attr (only for DEFAULT) */ Node *expr; /* transformed default or check expr */ @@ -101,7 +102,7 @@ extern List *AddRelationNewConstraints(Relation rel, bool is_local, bool is_internal); -extern void StoreAttrDefault(Relation rel, AttrNumber attnum, +extern Oid StoreAttrDefault(Relation rel, AttrNumber attnum, Node *expr, bool is_internal); extern Node *cookDefault(ParseState *pstate, diff --git a/src/include/catalog/index.h b/src/include/catalog/index.h index e7cc7a0..e22ef8f 100644 --- a/src/include/catalog/index.h +++ b/src/include/catalog/index.h @@ -63,7 +63,7 @@ extern Oid index_create(Relation heapRelation, bool is_internal, bool if_not_exists); -extern void index_constraint_create(Relation heapRelation, +extern Oid index_constraint_create(Relation heapRelation, Oid indexRelationId, IndexInfo *indexInfo, const char *constraintName, -- 2.1.4