Merge the parent and child constraints with differing enforcibility.

If an ENFORCED parent constraint is attached to a NOT ENFORCED child
constraint, the child constraint will be made ENFORCED, with
validation applied if the parent constraint is validated as well.
Otherwise, a new ENFORCED constraint (with validation, if the parent
constraint is validated) would need to be created on the child table,
which would be unnecessary if a similar constraint already exists and
can be attached.

On the other hand, having a NOT ENFORCED parent constraint with an
ENFORCED child constraint does not cause any issues, and no changes
are required.

----
NOTE: This patch is intended to reduce the diff noise from the main
patch and is not meant to be committed separately. It should be
squashed with the main patch that adds ENFORCED/NOT ENFORCED.
----

Author: EDB-AmulSul

src/backend/commands/tablecmds.c

@@ -11589,23 +11589,6 @@ tryAttachPartitionForeignKey(List **wqueue,
 	if (!HeapTupleIsValid(partcontup))
 		elog(ERROR, "cache lookup failed for constraint %u", fk->conoid);
 	partConstr = (Form_pg_constraint) GETSTRUCT(partcontup);
-
-	/*
-	 * An error should be raised if the constraint enforceability is different.
-	 * Returning false without raising an error, as we do for other attributes,
-	 * could lead to a duplicate constraint with the same enforceability as the
-	 * parent. While this may be acceptable, it may not be ideal. Therefore,
-	 * it's better to raise an error and allow the user to correct the
-	 * enforceability before proceeding.
-	 */
-	if (partConstr->conenforced != parentConstr->conenforced)
-		ereport(ERROR,
-				(errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
-				 errmsg("constraint \"%s\" enforceability conflicts with constraint \"%s\" on relation \"%s\"",
-						NameStr(parentConstr->conname),
-						NameStr(partConstr->conname),
-						RelationGetRelationName(partition))));
-
 	if (OidIsValid(partConstr->conparentid) ||
 		partConstr->condeferrable != parentConstr->condeferrable ||
 		partConstr->condeferred != parentConstr->condeferred ||
@@ -11653,6 +11636,8 @@ AttachPartitionForeignKey(List **wqueue,
 	Oid			partConstrFrelid;
 	Oid			partConstrRelid;
 	bool		parentConstrIsEnforced;
+	bool		partConstrIsEnforced;
+	bool		partConstrParentIsSet;
 
 	/* Fetch the parent constraint tuple */
 	parentConstrTup = SearchSysCache1(CONSTROID,
@@ -11668,13 +11653,47 @@ AttachPartitionForeignKey(List **wqueue,
 	if (!HeapTupleIsValid(partcontup))
 		elog(ERROR, "cache lookup failed for constraint %u", partConstrOid);
 	partConstr = (Form_pg_constraint) GETSTRUCT(partcontup);
+	partConstrIsEnforced = partConstr->conenforced;
 	partConstrFrelid = partConstr->confrelid;
 	partConstrRelid = partConstr->conrelid;
 
+	/*
+	 * The case where the parent constraint is NOT ENFORCED and the child
+	 * constraint is ENFORCED is acceptable because the not enforced parent
+	 * constraint lacks triggers, eliminating any redundancy issues with the
+	 * enforced child constraint. In this scenario, the child constraint
+	 * remains enforced, and its trigger is retained, ensuring that
+	 * referential integrity checks for the child continue as before, even
+	 * with the parent constraint not enforced. The relationship between the
+	 * two constraints is preserved by setting the parent constraint, which
+	 * allows us to locate the child constraint. This becomes important if the
+	 * parent constraint is later changed to enforced, at which point the
+	 * necessary trigger will be created for the parent, and any redundancy
+	 * from these triggers will be appropriately handled.
+	 */
+	if (!parentConstrIsEnforced && partConstrIsEnforced)
+	{
+		ReleaseSysCache(partcontup);
+		ReleaseSysCache(parentConstrTup);
+
+		ConstraintSetParentConstraint(partConstrOid, parentConstrOid,
+									  RelationGetRelid(partition));
+		CommandCounterIncrement();
+
+		return;
+	}
+
 	/*
 	 * If the referenced table is partitioned, then the partition we're
 	 * attaching now has extra pg_constraint rows and action triggers that are
 	 * no longer needed.  Remove those.
+	 *
+	 * Note that this must be done beforehand, particularly in situations
+	 * where we might decide to change the constraint to an ENFORCED state
+	 * which will create the required triggers and add the child constraint to
+	 * the validation queue. To avoid generating unnecessary triggers and
+	 * adding them to the validation queue, it is crucial to eliminate any
+	 * redundant constraints beforehand.
 	 */
 	if (get_rel_relkind(partConstrFrelid) == RELKIND_PARTITIONED_TABLE)
 	{
@@ -11693,6 +11712,53 @@ AttachPartitionForeignKey(List **wqueue,
 	 */
 	queueValidation = parentConstr->convalidated && !partConstr->convalidated;
 
+	/*
+	 * The case where the parent constraint is ENFORCED and the child
+	 * constraint is NOT ENFORCED is not acceptable, as it would violate
+	 * referential integrity. In such cases, the child constraint will first
+	 * be enforced before merging it with the enforced parent constraint.
+	 * Subsequently, removing action triggers, setting up constraint triggers,
+	 * and handling check triggers for the parent will be managed in the usual
+	 * manner, similar to how two enforced constraints are merged.
+	 */
+	if (parentConstrIsEnforced && !partConstrIsEnforced)
+	{
+		ATAlterConstraint *cmdcon = makeNode(ATAlterConstraint);
+		Relation	conrel;
+
+		cmdcon->conname = NameStr(partConstr->conname);
+		cmdcon->deferrable = partConstr->condeferrable;
+		cmdcon->initdeferred = partConstr->condeferred;
+		cmdcon->alterEnforceability = true;
+		cmdcon->is_enforced = true;
+
+		conrel = table_open(ConstraintRelationId, RowExclusiveLock);
+
+		ATExecAlterConstrEnforceability(wqueue, cmdcon, conrel, trigrel,
+										partConstr->conrelid,
+										partConstr->confrelid,
+										partcontup, AccessExclusiveLock,
+										InvalidOid, InvalidOid, InvalidOid,
+										InvalidOid);
+
+		table_close(conrel, RowExclusiveLock);
+
+		CommandCounterIncrement();
+
+		/*
+		 * No further validation is needed, as changing the constraint to
+		 * enforced will implicitly trigger the same validation.
+		 */
+		queueValidation = false;
+	}
+
+	/*
+	 * The constraint parent shouldn't be set beforehand, or if it's already
+	 * set, it should be the specified parent.
+	 */
+	partConstrParentIsSet = OidIsValid(partConstr->conparentid);
+	Assert(!partConstrParentIsSet || partConstr->conparentid == parentConstrOid);
+
 	ReleaseSysCache(partcontup);
 	ReleaseSysCache(parentConstrTup);
 
@@ -11705,8 +11771,10 @@ AttachPartitionForeignKey(List **wqueue,
 	DropForeignKeyConstraintTriggers(trigrel, partConstrOid, partConstrFrelid,
 									 partConstrRelid);
 
-	ConstraintSetParentConstraint(partConstrOid, parentConstrOid,
-								  RelationGetRelid(partition));
+	/* Skip if the parent is already set */
+	if (!partConstrParentIsSet)
+		ConstraintSetParentConstraint(partConstrOid, parentConstrOid,
+									  RelationGetRelid(partition));
 
 	/*
 	 * Like the constraint, attach partition's "check" triggers to the
@@ -12306,6 +12374,17 @@ ATExecAlterConstrEnforceability(List **wqueue, ATAlterConstraint *cmdcon,
 
 		/* Drop all the triggers */
 		DropForeignKeyConstraintTriggers(tgrel, conoid, InvalidOid, InvalidOid);
+
+		/*
+		 * If the referenced table is partitioned, the child constraint we're
+		 * changing to NOT ENFORCED may have additional pg_constraint rows and
+		 * action triggers that remain untouched while this child constraint
+		 * is attached to the NOT ENFORCED parent. These must now be removed.
+		 * For more details, see AttachPartitionForeignKey().
+		 */
+		if (OidIsValid(currcon->conparentid) &&
+			get_rel_relkind(currcon->confrelid) == RELKIND_PARTITIONED_TABLE)
+			RemoveInheritedConstraint(conrel, tgrel, currcon->conrelid, conoid);
 	}
 	else if (changed)			/* Create triggers */
 	{
@@ -12631,13 +12710,40 @@ AlterConstrEnforceabilityRecurse(List **wqueue, ATAlterConstraint *cmdcon,
 							   true, NULL, 1, &pkey);
 
 	while (HeapTupleIsValid(childtup = systable_getnext(pscan)))
-		ATExecAlterConstrEnforceability(wqueue, cmdcon, conrel, tgrel, fkrelid,
-										pkrelid, childtup, lockmode,
-										ReferencedParentDelTrigger,
-										ReferencedParentUpdTrigger,
-										ReferencingParentInsTrigger,
-										ReferencingParentUpdTrigger);
+	{
+		Form_pg_constraint childcon;
+
+		childcon = (Form_pg_constraint) GETSTRUCT(childtup);
+
+		/*
+		 * When the parent constraint is modified to be ENFORCED, and the
+		 * child constraint is attached to the parent constraint (which is
+		 * already ENFORCED), some constraints and action triggers on the
+		 * child table may become redundant and need to be removed.
+		 */
+		if (cmdcon->is_enforced && childcon->conenforced)
+		{
+			if (currcon->confrelid == pkrelid)
+			{
+				Relation	rel = table_open(childcon->conrelid, lockmode);
 
+				AttachPartitionForeignKey(wqueue, rel, childcon->oid,
+										  conoid,
+										  ReferencingParentInsTrigger,
+										  ReferencingParentUpdTrigger,
+										  tgrel);
+
+				table_close(rel, NoLock);
+			}
+		}
+		else
+			ATExecAlterConstrEnforceability(wqueue, cmdcon, conrel, tgrel, fkrelid,
+											pkrelid, childtup, lockmode,
+											ReferencedParentDelTrigger,
+											ReferencedParentUpdTrigger,
+											ReferencingParentInsTrigger,
+											ReferencingParentUpdTrigger);
+	}
 	systable_endscan(pscan);
 }
 
@@ -20811,7 +20917,9 @@ DetachPartitionFinalize(Relation rel, Relation partRel, bool concurrent,
 	{
 		ForeignKeyCacheInfo *fk = lfirst(cell);
 		HeapTuple	contup;
+		HeapTuple	parentContup;
 		Form_pg_constraint conform;
+		Oid			parentConstrIsEnforced;
 
 		contup = SearchSysCache1(CONSTROID, ObjectIdGetDatum(fk->conoid));
 		if (!HeapTupleIsValid(contup))
@@ -20830,12 +20938,34 @@ DetachPartitionFinalize(Relation rel, Relation partRel, bool concurrent,
 			continue;
 		}
 
+		/* Get the enforcibility of the parent constraint */
+		parentContup = SearchSysCache1(CONSTROID,
+									   ObjectIdGetDatum(conform->conparentid));
+		if (!HeapTupleIsValid(parentContup))
+			elog(ERROR, "cache lookup failed for constraint %u",
+				 conform->conparentid);
+		parentConstrIsEnforced =
+			((Form_pg_constraint) GETSTRUCT(parentContup))->conenforced;
+		ReleaseSysCache(parentContup);
+
 		/*
 		 * The constraint on this table must be marked no longer a child of
 		 * the parent's constraint, as do its check triggers.
 		 */
 		ConstraintSetParentConstraint(fk->conoid, InvalidOid, InvalidOid);
 
+		/*
+		 * Unsetting the parent is sufficient when the parent constraint is
+		 * NOT ENFORCED and the child constraint is ENFORCED, as we link them
+		 * by setting the constraint parent, while leaving the rest unchanged.
+		 * For more details, see AttachPartitionForeignKey().
+		 */
+		if (!parentConstrIsEnforced && fk->conenforced)
+		{
+			ReleaseSysCache(contup);
+			continue;
+		}
+
 		/*
 		 * Also, look up the partition's "check" triggers corresponding to the
 		 * ENFORCED constraint being detached and detach them from the parent