CookedConstraint *nncooked;
AttrNumber colnum;
char *nnname;
+ int existing;
/* Determine which column to modify */
colnum = get_attnum(RelationGetRelid(rel), strVal(linitial(cdef->keys)));
strVal(linitial(cdef->keys)), RelationGetRelid(rel));
/*
- * If the column already has a not-null constraint, we need only
- * update its catalog status and we're done.
+ * If the column already has an inheritable not-null constraint,
+ * we need only adjust its inheritance status and we're done. If
+ * the constraint is there but marked NO INHERIT, then it is
+ * updated in the same way, but we also recurse to the children
+ * (if any) to add the constraint there as well.
*/
- if (AdjustNotNullInheritance1(RelationGetRelid(rel), colnum,
- cdef->inhcount, cdef->is_no_inherit))
+ existing = AdjustNotNullInheritance1(RelationGetRelid(rel), colnum,
+ cdef->inhcount, cdef->is_no_inherit);
+ if (existing == 1)
+ continue; /* all done! */
+ else if (existing == -1)
+ {
+ List *children;
+
+ children = find_inheritance_children(RelationGetRelid(rel), NoLock);
+ foreach_oid(childoid, children)
+ {
+ Relation childrel = table_open(childoid, NoLock);
+
+ AddRelationNewConstraints(childrel,
+ NIL,
+ list_make1(copyObject(cdef)),
+ allow_merge,
+ is_local,
+ is_internal,
+ queryString);
+ /* these constraints are not in the return list -- good? */
+
+ table_close(childrel, NoLock);
+ }
+
continue;
+ }
/*
* If a constraint name is specified, check that it isn't already
}
/*
- * Find and return the pg_constraint tuple that implements a validated
- * not-null constraint for the given column of the given relation.
+ * Find and return a copy of the pg_constraint tuple that implements a
+ * validated not-null constraint for the given column of the given relation.
*
* XXX This would be easier if we had pg_attribute.notnullconstr with the OID
* of the constraint that implements the not-null constraint for that column.
* AdjustNotNullInheritance1
* Adjust inheritance count for a single not-null constraint
*
- * Adjust inheritance count, and possibly islocal status, for the not-null
- * constraint row of the given column, if it exists, and return true.
- * If no not-null constraint is found for the column, return false.
+ * If no not-null constraint is found for the column, return 0.
+ * Caller can create one.
+ * If the constraint does exist and it's inheritable, adjust its
+ * inheritance count (and possibly islocal status) and return 1.
+ * No further action needs to be taken.
+ * If the constraint exists but is marked NO INHERIT, adjust it as above
+ * and reset connoinherit to false, and return -1. Caller is
+ * responsible for adding the same constraint to the children, if any.
*/
-bool
+int
AdjustNotNullInheritance1(Oid relid, AttrNumber attnum, int count,
bool is_no_inherit)
{
HeapTuple tup;
+ Assert(count >= 0);
+
tup = findNotNullConstraintAttnum(relid, attnum);
if (HeapTupleIsValid(tup))
{
Relation pg_constraint;
Form_pg_constraint conform;
+ int retval = 1;
pg_constraint = table_open(ConstraintRelationId, RowExclusiveLock);
conform = (Form_pg_constraint) GETSTRUCT(tup);
/*
- * Don't let the NO INHERIT status change (but don't complain
- * unnecessarily.) In the future it might be useful to let an
- * inheritable constraint replace a non-inheritable one, but we'd need
- * to recurse to children to get it added there.
+ * If we're asked for a NO INHERIT constraint and this relation
+ * already has an inheritable one, throw an error.
*/
- if (is_no_inherit != conform->connoinherit)
+ if (is_no_inherit && !conform->connoinherit)
ereport(ERROR,
errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
errmsg("cannot change NO INHERIT status of inherited NOT NULL constraint \"%s\" on relation \"%s\"",
NameStr(conform->conname), get_rel_name(relid)));
+ /*
+ * If the constraint already exists in this relation but it's marked
+ * NO INHERIT, we can just remove that flag, and instruct caller to
+ * recurse to add the constraint to children.
+ */
+ if (!is_no_inherit && conform->connoinherit)
+ {
+ conform->connoinherit = false;
+ retval = -1; /* caller must add constraint on child rels */
+ }
+
if (count > 0)
conform->coninhcount += count;
table_close(pg_constraint, RowExclusiveLock);
- return true;
+ return retval;
}
- return false;
+ return 0;
}
/*
{
List *children;
List *newconstrs = NIL;
- ListCell *lc;
IndexStmt *indexstmt;
/* No work if not creating a primary key */
!rel->rd_rel->relhassubclass)
return;
- children = find_inheritance_children(RelationGetRelid(rel), lockmode);
+ /*
+ * 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);
- foreach(lc, indexstmt->indexParams)
+ /*
+ * Construct the list of constraints that we need to add to each child
+ * relation.
+ */
+ foreach_node(IndexElem, elem, indexstmt->indexParams)
{
- IndexElem *elem = lfirst_node(IndexElem, lc);
Constraint *nnconstr;
Assert(elem->expr == NULL);
newconstrs = lappend(newconstrs, nnconstr);
}
- foreach(lc, children)
+ /* Finally, add AT subcommands to add each constraint to each child. */
+ children = find_inheritance_children(RelationGetRelid(rel), NoLock);
+ foreach_oid(childrelid, children)
{
- Oid childrelid = lfirst_oid(lc);
Relation childrel = table_open(childrelid, NoLock);
AlterTableCmd *newcmd = makeNode(AlterTableCmd);
ListCell *lc2;
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, ©tup->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,
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
* DetachAddConstraintIfNeeded
* Subroutine for ATExecDetachPartition. Create a constraint that
* takes the place of the partition constraint, but avoid creating
- * a dupe if an constraint already exists which implies the needed
+ * a dupe if a constraint already exists which implies the needed
* constraint.
*/
static void
}
else if (use_throwaway_notnull)
{
- tbinfo->notnull_constrs[j] =
- psprintf("pgdump_throwaway_notnull_%d", notnullcount++);
+ /*
+ * Decide on a name for this constraint. If it is not an
+ * inherited constraint, give it a throwaway name to avoid any
+ * possible conflicts, since we're going to drop it soon
+ * anyway. If it is inherited then try harder, because it may
+ * (but not necessarily) persist after the restore.
+ */
+ if (tbinfo->notnull_inh[j])
+ /* XXX maybe try harder if the name is overlength */
+ tbinfo->notnull_constrs[j] =
+ psprintf("%s_%s_not_null",
+ tbinfo->dobj.name, tbinfo->attnames[j]);
+ else
+ tbinfo->notnull_constrs[j] =
+ psprintf("pgdump_throwaway_notnull_%d", notnullcount++);
tbinfo->notnull_throwaway[j] = true;
tbinfo->notnull_inh[j] = false;
}
* similar code in dumpIndex!
*/
- /* Drop any not-null constraints that were added to support the PK */
+ /*
+ * Drop any not-null constraints that were added to support the PK,
+ * but leave them alone if they have a definition coming from their
+ * parent.
+ */
if (coninfo->contype == 'p')
for (int i = 0; i < tbinfo->numatts; i++)
- if (tbinfo->notnull_throwaway[i])
+ if (tbinfo->notnull_throwaway[i] &&
+ !tbinfo->notnull_inh[i])
appendPQExpBuffer(q, "\nALTER TABLE ONLY %s DROP CONSTRAINT %s;",
fmtQualifiedDumpable(tbinfo),
tbinfo->notnull_constrs[i]);
extern HeapTuple findNotNullConstraint(Oid relid, const char *colname);
extern HeapTuple findDomainNotNullConstraint(Oid typid);
extern AttrNumber extractNotNullColumn(HeapTuple constrTup);
-extern bool AdjustNotNullInheritance1(Oid relid, AttrNumber attnum, int count,
+extern int AdjustNotNullInheritance1(Oid relid, AttrNumber attnum, int count,
bool is_no_inherit);
extern void AdjustNotNullInheritance(Oid relid, Bitmapset *columns, int count);
extern List *RelationGetNotNullConstraints(Oid relid, bool cooked);
Inherits: atacc1
DROP TABLE ATACC1, ATACC2;
+-- overridding a no-inherit constraint with an inheritable one
+CREATE TABLE ATACC2 (a int, CONSTRAINT a_is_not_null NOT NULL a NO INHERIT);
+CREATE TABLE ATACC1 (a int);
+CREATE TABLE ATACC3 (a int) INHERITS (ATACC2);
+NOTICE: merging column "a" with inherited definition
+INSERT INTO ATACC3 VALUES (null); -- make sure we scan atacc3
+ALTER TABLE ATACC2 INHERIT ATACC1;
+ALTER TABLE ATACC1 ADD CONSTRAINT ditto NOT NULL a;
+ERROR: column "a" of relation "atacc3" contains null values
+DELETE FROM ATACC3;
+ALTER TABLE ATACC1 ADD CONSTRAINT ditto NOT NULL a;
+\d+ ATACC[123]
+ Table "public.atacc1"
+ Column | Type | Collation | Nullable | Default | Storage | Stats target | Description
+--------+---------+-----------+----------+---------+---------+--------------+-------------
+ a | integer | | not null | | plain | |
+Not-null constraints:
+ "ditto" NOT NULL "a"
+Child tables: atacc2
+
+ Table "public.atacc2"
+ Column | Type | Collation | Nullable | Default | Storage | Stats target | Description
+--------+---------+-----------+----------+---------+---------+--------------+-------------
+ a | integer | | not null | | plain | |
+Not-null constraints:
+ "a_is_not_null" NOT NULL "a" (local, inherited)
+Inherits: atacc1
+Child tables: atacc3
+
+ Table "public.atacc3"
+ Column | Type | Collation | Nullable | Default | Storage | Stats target | Description
+--------+---------+-----------+----------+---------+---------+--------------+-------------
+ a | integer | | not null | | plain | |
+Not-null constraints:
+ "ditto" NOT NULL "a" (inherited)
+Inherits: atacc2
+
+ALTER TABLE ATACC2 DROP CONSTRAINT a_is_not_null;
+ALTER TABLE ATACC1 DROP CONSTRAINT ditto;
+\d+ ATACC3
+ Table "public.atacc3"
+ Column | Type | Collation | Nullable | Default | Storage | Stats target | Description
+--------+---------+-----------+----------+---------+---------+--------------+-------------
+ a | integer | | | | plain | |
+Inherits: atacc2
+
+DROP TABLE ATACC1, ATACC2, ATACC3;
+-- The same cannot be achieved this way
+CREATE TABLE ATACC2 (a int, CONSTRAINT a_is_not_null NOT NULL a NO INHERIT);
+CREATE TABLE ATACC1 (a int, CONSTRAINT ditto NOT NULL a);
+CREATE TABLE ATACC3 (a int) INHERITS (ATACC2);
+NOTICE: merging column "a" with inherited definition
+ALTER TABLE ATACC2 INHERIT ATACC1;
+ERROR: cannot add NOT NULL constraint to column "a" of relation "atacc2" with inheritance children
+DETAIL: Existing constraint "a_is_not_null" is marked NO INHERIT.
+DROP TABLE ATACC1, ATACC2, ATACC3;
--
-- Check constraints on INSERT INTO
--
\d+ ATACC2
DROP TABLE ATACC1, ATACC2;
+-- overridding a no-inherit constraint with an inheritable one
+CREATE TABLE ATACC2 (a int, CONSTRAINT a_is_not_null NOT NULL a NO INHERIT);
+CREATE TABLE ATACC1 (a int);
+CREATE TABLE ATACC3 (a int) INHERITS (ATACC2);
+INSERT INTO ATACC3 VALUES (null); -- make sure we scan atacc3
+ALTER TABLE ATACC2 INHERIT ATACC1;
+ALTER TABLE ATACC1 ADD CONSTRAINT ditto NOT NULL a;
+DELETE FROM ATACC3;
+ALTER TABLE ATACC1 ADD CONSTRAINT ditto NOT NULL a;
+\d+ ATACC[123]
+ALTER TABLE ATACC2 DROP CONSTRAINT a_is_not_null;
+ALTER TABLE ATACC1 DROP CONSTRAINT ditto;
+\d+ ATACC3
+DROP TABLE ATACC1, ATACC2, ATACC3;
+
+-- The same cannot be achieved this way
+CREATE TABLE ATACC2 (a int, CONSTRAINT a_is_not_null NOT NULL a NO INHERIT);
+CREATE TABLE ATACC1 (a int, CONSTRAINT ditto NOT NULL a);
+CREATE TABLE ATACC3 (a int) INHERITS (ATACC2);
+ALTER TABLE ATACC2 INHERIT ATACC1;
+DROP TABLE ATACC1, ATACC2, ATACC3;
+
--
-- Check constraints on INSERT INTO
--
projects / thirdparty / postgresql.git / commitdiff
