Default constraint name PR feedback:

�	Add model builder extention methods for other types of properties
�	Uniquify names using the established pattern in SharedTableConvention
�	Make GetDefaultConstraintName return the generated default constraint name if UseNamedDefaultConstraints was called

Author: AndriySvyryd

src/EFCore.Relational/Extensions/RelationalModelExtensions.cs

@@ -537,10 +537,10 @@ public static void SetCollation(this IMutableModel model, string? value)
     ///     Returns the value indicating whether named default constraints should be used.
     /// </summary>
     /// <param name="model">The model to get the value for.</param>
-    public static bool? AreNamedDefaultConstraintsUsed(this IReadOnlyModel model)
+    public static bool AreNamedDefaultConstraintsUsed(this IReadOnlyModel model)
         => (model is RuntimeModel)
             ? throw new InvalidOperationException(CoreStrings.RuntimeModelMissingData)
-            : (bool?)model[RelationalAnnotationNames.UseNamedDefaultConstraints];
+            : (bool?)model[RelationalAnnotationNames.UseNamedDefaultConstraints] ?? false;
 
     /// <summary>
     ///     Sets the value indicating whether named default constraints should be used.
@@ -558,7 +558,7 @@ public static void UseNamedDefaultConstraints(this IMutableModel model, bool val
     /// <param name="fromDataAnnotation">Indicates whether the configuration was specified using a data annotation.</param>
     public static bool? UseNamedDefaultConstraints(
         this IConventionModel model,
-        bool value,
+        bool? value,
         bool fromDataAnnotation = false)
         => (bool?)model.SetOrRemoveAnnotation(
             RelationalAnnotationNames.UseNamedDefaultConstraints,

src/EFCore.Relational/Extensions/RelationalPropertyExtensions.cs

@@ -2092,20 +2092,42 @@ public static void SetJsonPropertyName(this IMutableProperty property, string? n
     /// </summary>
     /// <param name="property">The property.</param>
     public static string? GetDefaultConstraintName(this IReadOnlyProperty property)
-        => (property is RuntimeProperty)
+        => property is RuntimeProperty
+            ? throw new InvalidOperationException(CoreStrings.RuntimeModelMissingData)
+            : (string?)property[RelationalAnnotationNames.DefaultConstraintName]
+                ?? (ShouldHaveDefaultConstraintName(property)
+                        && StoreObjectIdentifier.Create(property.DeclaringType, StoreObjectType.Table) is StoreObjectIdentifier table
+                        ? property.GenerateDefaultConstraintName(table)
+                        : null);
+
+    /// <summary>
+    ///     Gets the default constraint name.
+    /// </summary>
+    /// <param name="property">The property.</param>
+    /// <param name="storeObject">The store object identifier to generate the name for.</param>
+    public static string? GetDefaultConstraintName(this IReadOnlyProperty property, in StoreObjectIdentifier storeObject)
+        => property is RuntimeProperty
             ? throw new InvalidOperationException(CoreStrings.RuntimeModelMissingData)
-            : (string?)property[RelationalAnnotationNames.DefaultConstraintName];
+            : (string?)property[RelationalAnnotationNames.DefaultConstraintName]
+                ?? (ShouldHaveDefaultConstraintName(property)
+                    ? property.GenerateDefaultConstraintName(storeObject)
+                    : null);
+
+    private static bool ShouldHaveDefaultConstraintName(IReadOnlyProperty property)
+        => property.DeclaringType.Model.AreNamedDefaultConstraintsUsed()
+        && (property[RelationalAnnotationNames.DefaultValue] is not null
+                || property[RelationalAnnotationNames.DefaultValueSql] is not null);
 
     /// <summary>
     ///     Generates the default constraint name based on the table and column name.
     /// </summary>
     /// <param name="property">The property.</param>
-    /// <param name="storeObject">The store object identifier to generate the name from.</param>
+    /// <param name="storeObject">The store object identifier to generate the name for.</param>
     public static string GenerateDefaultConstraintName(this IReadOnlyProperty property, in StoreObjectIdentifier storeObject)
     {
         var candidate = $"DF_{storeObject.Name}_{property.GetColumnName(storeObject)}";
 
-        return candidate.Length > 120 ? candidate[..120] : candidate;
+        return Uniquifier.Truncate(candidate, property.DeclaringType.Model.GetMaxIdentifierLength());
     }
 
     /// <summary>

src/EFCore.Relational/Metadata/Conventions/Infrastructure/RelationalConventionSetBuilder.cs

@@ -89,12 +89,6 @@ public override ConventionSet CreateConventionSet()
         conventionSet.Replace<RuntimeModelConvention>(
             new RelationalRuntimeModelConvention(Dependencies, RelationalDependencies));
 
-        var defaultConstraintConvention = new RelationalDefaultConstraintConvention(Dependencies, RelationalDependencies);
-        ConventionSet.AddAfter(
-            conventionSet.ModelFinalizingConventions,
-            defaultConstraintConvention,
-            typeof(SharedTableConvention));
-
         return conventionSet;
     }
 }

src/EFCore.Relational/Metadata/Conventions/RelationalDefaultConstraintConvention.cs

@@ -51,6 +51,7 @@ public virtual void ProcessModelFinalizing(
         var foreignKeys = new Dictionary<string, (IConventionForeignKey, StoreObjectIdentifier)>();
         var indexes = new Dictionary<string, (IConventionIndex, StoreObjectIdentifier)>();
         var checkConstraints = new Dictionary<(string, string?), (IConventionCheckConstraint, StoreObjectIdentifier)>();
+        var defaultConstraints = new Dictionary<(string, string?), (IConventionProperty, StoreObjectIdentifier)>();
         var triggers = new Dictionary<string, (IConventionTrigger, StoreObjectIdentifier)>();
         foreach (var ((tableName, schema), conventionEntityTypes) in tables)
         {
@@ -76,6 +77,11 @@ public virtual void ProcessModelFinalizing(
                 checkConstraints.Clear();
             }
 
+            if (!DefaultConstraintsUniqueAcrossTables)
+            {
+                defaultConstraints.Clear();
+            }
+
             if (!TriggersUniqueAcrossTables)
             {
                 triggers.Clear();
@@ -89,6 +95,7 @@ public virtual void ProcessModelFinalizing(
                 UniquifyForeignKeyNames(entityType, foreignKeys, storeObject, maxLength);
                 UniquifyIndexNames(entityType, indexes, storeObject, maxLength);
                 UniquifyCheckConstraintNames(entityType, checkConstraints, storeObject, maxLength);
+                UniquifyDefaultConstraintNames(entityType, defaultConstraints, storeObject, maxLength);
                 UniquifyTriggerNames(entityType, triggers, storeObject, maxLength);
             }
         }
@@ -124,14 +131,19 @@ protected virtual bool CheckConstraintsUniqueAcrossTables
     protected virtual bool TriggersUniqueAcrossTables
         => true;
 
+    /// <summary>
+    ///     Gets a value indicating whether default constraint names should be unique across tables.
+    /// </summary>
+    protected virtual bool DefaultConstraintsUniqueAcrossTables
+        => false;
+
     private static void TryUniquifyTableNames(
         IConventionModel model,
         Dictionary<(string Name, string? Schema), List<IConventionEntityType>> tables,
         int maxLength)
     {
         Dictionary<(string Name, string? Schema), Dictionary<(string Name, string? Schema), List<IConventionEntityType>>>?
-            clashingTables
-                = null;
+            clashingTables = null;
         foreach (var entityType in model.GetEntityTypes())
         {
             var tableName = entityType.GetTableName();
@@ -646,6 +658,107 @@ protected virtual bool AreCompatible(
         return null;
     }
 
+    private void UniquifyDefaultConstraintNames(
+        IConventionEntityType entityType,
+        Dictionary<(string, string?), (IConventionProperty, StoreObjectIdentifier)> defaultConstraints,
+        in StoreObjectIdentifier storeObject,
+        int maxLength)
+    {
+        foreach (var property in entityType.GetProperties())
+        {
+            var constraintName = property.GetDefaultConstraintName(storeObject);
+            if (constraintName == null)
+            {
+                continue;
+            }
+
+            var columnName = property.GetColumnName(storeObject);
+            if (columnName == null)
+            {
+                continue;
+            }
+
+            if (!defaultConstraints.TryGetValue((constraintName, storeObject.Schema), out var otherPropertyPair))
+            {
+                defaultConstraints[(constraintName, storeObject.Schema)] = (property, storeObject);
+                continue;
+            }
+
+            var (otherProperty, otherStoreObject) = otherPropertyPair;
+            if (storeObject == otherStoreObject
+                && columnName == otherProperty.GetColumnName(storeObject)
+                && AreCompatibleDefaultConstraints(property, otherProperty, storeObject))
+            {
+                continue;
+            }
+
+            var newConstraintName = TryUniquifyDefaultConstraint(property, constraintName, storeObject.Schema, defaultConstraints, storeObject, maxLength);
+            if (newConstraintName != null)
+            {
+                defaultConstraints[(newConstraintName, storeObject.Schema)] = (property, storeObject);
+                continue;
+            }
+
+            var newOtherConstraintName = TryUniquifyDefaultConstraint(otherProperty, constraintName, storeObject.Schema, defaultConstraints, otherStoreObject, maxLength);
+            if (newOtherConstraintName != null)
+            {
+                defaultConstraints[(constraintName, storeObject.Schema)] = (property, storeObject);
+                defaultConstraints[(newOtherConstraintName, otherStoreObject.Schema)] = otherPropertyPair;
+            }
+        }
+    }
+
+    /// <summary>
+    ///     Gets a value indicating whether two default constraints with the same name are compatible.
+    /// </summary>
+    /// <param name="property">A property with a default constraint.</param>
+    /// <param name="duplicateProperty">Another property with a default constraint.</param>
+    /// <param name="storeObject">The identifier of the store object.</param>
+    /// <returns><see langword="true" /> if compatible</returns>
+    protected virtual bool AreCompatibleDefaultConstraints(
+        IReadOnlyProperty property,
+        IReadOnlyProperty duplicateProperty,
+        in StoreObjectIdentifier storeObject)
+        => property.GetDefaultValue(storeObject) == duplicateProperty.GetDefaultValue(storeObject)
+            && property.GetDefaultValueSql(storeObject) == duplicateProperty.GetDefaultValueSql(storeObject);
+
+    private static string? TryUniquifyDefaultConstraint(
+        IConventionProperty property,
+        string constraintName,
+        string? schema,
+        Dictionary<(string, string?), (IConventionProperty, StoreObjectIdentifier)> defaultConstraints,
+        in StoreObjectIdentifier storeObject,
+        int maxLength)
+    {
+        var mappedTables = property.GetMappedStoreObjects(StoreObjectType.Table);
+        if (mappedTables.Count() > 1)
+        {
+            // For TPC and some entity splitting scenarios we end up with multiple tables having to define the constraint.
+            // Since constraint name has to be unique, we can't keep the same name for all
+            // Disabling this scenario until we have better way to configure the constraint name
+            // see issue #27970
+            if (property.GetDefaultConstraintNameConfigurationSource() == null)
+            {
+                throw new InvalidOperationException(
+                    RelationalStrings.ImplicitDefaultNamesNotSupportedForTpcWhenNamesClash(constraintName));
+            }
+            else
+            {
+                throw new InvalidOperationException(
+                    RelationalStrings.ExplicitDefaultConstraintNamesNotSupportedForTpc(constraintName));
+            }
+        }
+
+        if (property.Builder.CanSetAnnotation(RelationalAnnotationNames.DefaultConstraintName, null))
+        {
+            constraintName = Uniquifier.Uniquify(constraintName, defaultConstraints, n => (n, schema), maxLength);
+            property.Builder.HasAnnotation(RelationalAnnotationNames.DefaultConstraintName, constraintName);
+            return constraintName;
+        }
+
+        return null;
+    }
+
     private void UniquifyTriggerNames(
         IConventionEntityType entityType,
         Dictionary<string, (IConventionTrigger, StoreObjectIdentifier)> triggers,