Fix to #11502 - Allow to specify constraint name for default values

Adding model builder API to allow specifying explicit constraint name when adding default value (sql) to a column.
Also added switch on the model level (opt-in) to switch from system-generated constraints to generating them automatically by name and storing in the model.
This is opt-in because we don't want to cause unnecessary migrations.
Added de-duplication logic in the finalize model step, in case our generated names happen to clash with ones specified explicitly by user.

Model builder APIs are exposed on the SQL Server level, but a lot of piping is in relational so that providers who support named constraints can take advantage of the feature.

Also split temporal tables migration tests for SqlServer into a separate file - there were way to many tests in MigrationsSqlServerTest

Fixes #11502

Author: maumar

src/EFCore.Relational/Design/Internal/RelationalCSharpRuntimeAnnotationCodeGenerator.cs

@@ -751,7 +751,15 @@ private void Create(
     /// <param name="column">The column to which the annotations are applied.</param>
     /// <param name="parameters">Additional parameters used during code generation.</param>
     public virtual void Generate(IColumn column, CSharpRuntimeAnnotationCodeGeneratorParameters parameters)
-        => GenerateSimpleAnnotations(parameters);
+    {
+        if (!parameters.IsRuntime)
+        {
+            var annotations = parameters.Annotations;
+            annotations.Remove(RelationalAnnotationNames.DefaultConstraintName);
+        }
+
+        GenerateSimpleAnnotations(parameters);
+    }
 
     private void Create(
         IViewColumn column,

src/EFCore.Relational/Extensions/RelationalModelExtensions.cs

@@ -530,4 +530,48 @@ public static void SetCollation(this IMutableModel model, string? value)
         => model.FindAnnotation(RelationalAnnotationNames.Collation)?.GetConfigurationSource();
 
     #endregion Collation
+
+    #region UseNamedDefaultConstraints
+
+    /// <summary>
+    ///     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)
+        => (model is RuntimeModel)
+            ? throw new InvalidOperationException(CoreStrings.RuntimeModelMissingData)
+            : (bool?)model[RelationalAnnotationNames.UseNamedDefaultConstraints];
+
+    /// <summary>
+    ///     Sets the value indicating whether named default constraints should be used.
+    /// </summary>
+    /// <param name="model">The model to get the value for.</param>
+    /// <param name="value">The value to set.</param>
+    public static void UseNamedDefaultConstraints(this IMutableModel model, bool value)
+        => model.SetOrRemoveAnnotation(RelationalAnnotationNames.UseNamedDefaultConstraints, value);
+
+    /// <summary>
+    ///     Sets the value indicating whether named default constraints should be used.
+    /// </summary>
+    /// <param name="model">The model to get the value for.</param>
+    /// <param name="value">The value to set.</param>
+    /// <param name="fromDataAnnotation">Indicates whether the configuration was specified using a data annotation.</param>
+    public static bool? UseNamedDefaultConstraints(
+        this IConventionModel model,
+        bool value,
+        bool fromDataAnnotation = false)
+        => (bool?)model.SetOrRemoveAnnotation(
+            RelationalAnnotationNames.UseNamedDefaultConstraints,
+            value,
+            fromDataAnnotation)?.Value;
+
+    /// <summary>
+    ///     Returns the configuration source for the named default constraints setting.
+    /// </summary>
+    /// <param name="model">The model to find configuration source for.</param>
+    /// <returns>The configuration source for the named default constraints setting.</returns>
+    public static ConfigurationSource? UseNamedDefaultConstraintsConfigurationSource(this IConventionModel model)
+        => model.FindAnnotation(RelationalAnnotationNames.UseNamedDefaultConstraints)?.GetConfigurationSource();
+
+    #endregion
 }

src/EFCore.Relational/Extensions/RelationalPropertyExtensions.cs

@@ -2086,4 +2086,60 @@ public static void SetJsonPropertyName(this IMutableProperty property, string? n
     /// <returns>The <see cref="ConfigurationSource" /> for the JSON property name for a given entity property.</returns>
     public static ConfigurationSource? GetJsonPropertyNameConfigurationSource(this IConventionProperty property)
         => property.FindAnnotation(RelationalAnnotationNames.JsonPropertyName)?.GetConfigurationSource();
+
+    /// <summary>
+    ///     Gets the default constraint name.
+    /// </summary>
+    /// <param name="property">The property.</param>
+    public static string? GetDefaultConstraintName(this IReadOnlyProperty property)
+        => (property is RuntimeProperty)
+            ? throw new InvalidOperationException(CoreStrings.RuntimeModelMissingData)
+            : (string?)property[RelationalAnnotationNames.DefaultConstraintName];
+
+    /// <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>
+    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;
+    }
+
+    /// <summary>
+    ///     Sets the default constraint name.
+    /// </summary>
+    /// <param name="property">The property.</param>
+    /// <param name="defaultConstraintName">The name to be used.</param>
+    public static void SetDefaultConstraintName(this IMutableProperty property, string? defaultConstraintName)
+        => property.SetAnnotation(RelationalAnnotationNames.DefaultConstraintName, defaultConstraintName);
+
+    /// <summary>
+    ///     Sets the default constraint name.
+    /// </summary>
+    /// <param name="property">The property.</param>
+    /// <param name="defaultConstraintName">The name to be used.</param>
+    /// <param name="fromDataAnnotation">Indicates whether the configuration was specified using a data annotation.</param>
+    public static string? SetDefaultConstraintName(
+        this IConventionProperty property,
+        string? defaultConstraintName,
+        bool fromDataAnnotation = false)
+    {
+        property.SetAnnotation(
+            RelationalAnnotationNames.DefaultConstraintName,
+            defaultConstraintName,
+            fromDataAnnotation);
+
+        return defaultConstraintName;
+    }
+
+    /// <summary>
+    ///     Returns the configuration source for the default constraint name.
+    /// </summary>
+    /// <param name="property">The property.</param>
+    /// <returns>The configuration source for the default constraint name.</returns>
+    public static ConfigurationSource? GetDefaultConstraintNameConfigurationSource(this IConventionProperty property)
+        => property.FindAnnotation(RelationalAnnotationNames.DefaultConstraintName)?.GetConfigurationSource();
 }

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

@@ -89,6 +89,12 @@ 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

@@ -0,0 +1,150 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+namespace Microsoft.EntityFrameworkCore.Metadata.Conventions;
+
+/// <summary>
+///     A convention that manipulates names of default constraints to avoid clashes.
+/// </summary>
+/// <remarks>
+///     See <see href="https://aka.ms/efcore-docs-conventions">Model building conventions</see> for more information and examples.
+/// </remarks>
+public class RelationalDefaultConstraintConvention : IModelFinalizingConvention
+{
+    /// <summary>
+    ///     Creates a new instance of <see cref="RelationalDefaultConstraintConvention" />.
+    /// </summary>
+    /// <param name="dependencies">Parameter object containing dependencies for this convention.</param>
+    /// <param name="relationalDependencies">Parameter object containing relational dependencies for this convention.</param>
+    public RelationalDefaultConstraintConvention(
+        ProviderConventionSetBuilderDependencies dependencies,
+        RelationalConventionSetBuilderDependencies relationalDependencies)
+    {
+        Dependencies = dependencies;
+        RelationalDependencies = relationalDependencies;
+    }
+
+    /// <summary>
+    ///     Dependencies for this service.
+    /// </summary>
+    protected virtual ProviderConventionSetBuilderDependencies Dependencies { get; }
+
+    /// <summary>
+    ///     Relational provider-specific dependencies for this service.
+    /// </summary>
+    protected virtual RelationalConventionSetBuilderDependencies RelationalDependencies { get; }
+
+    /// <inheritdoc />
+    public void ProcessModelFinalizing(
+        IConventionModelBuilder modelBuilder,
+        IConventionContext<IConventionModelBuilder> context)
+    {
+        var explicitDefaultConstraintNames = new List<string>();
+
+        // store all explicit names first - we don't want to change those in case they conflict with implicit names
+        foreach (var entity in modelBuilder.Metadata.GetEntityTypes())
+        {
+            foreach (var property in entity.GetDeclaredProperties())
+            {
+                if (property.FindAnnotation(RelationalAnnotationNames.DefaultConstraintName) is IConventionAnnotation annotation
+                    && annotation.Value is string explicitDefaultConstraintName
+                    && annotation.GetConfigurationSource() == ConfigurationSource.Explicit)
+                {
+                    if (property.GetMappedStoreObjects(StoreObjectType.Table).Count() > 1)
+                    {
+                        // for TPC and some entity splitting scenarios (specifically composite key) we end up with multiple tables
+                        // having to define the constraint. Since constraint has to be unique, we can't keep the same name for all
+                        // Disabling this scenario until we have better place to configure the constraint name
+                        // see issue #27970
+                        throw new InvalidOperationException(
+                            RelationalStrings.ExplicitDefaultConstraintNamesNotSupportedForTpc(explicitDefaultConstraintName));
+                    }
+
+                    explicitDefaultConstraintNames.Add(explicitDefaultConstraintName);
+                }
+            }
+        }
+
+        var existingDefaultConstraintNames = new List<string>(explicitDefaultConstraintNames);
+        var useNamedDefaultConstraints = modelBuilder.Metadata.AreNamedDefaultConstraintsUsed() == true;
+
+        var suffixCounter = 1;
+        foreach (var entity in modelBuilder.Metadata.GetEntityTypes())
+        {
+            foreach (var property in entity.GetDeclaredProperties())
+            {
+                if (property.FindAnnotation(RelationalAnnotationNames.DefaultValue) is IConventionAnnotation defaultValueAnnotation
+                    || property.FindAnnotation(RelationalAnnotationNames.DefaultValueSql) is IConventionAnnotation defaultValueSqlAnnotation)
+                {
+                    var defaultConstraintNameAnnotation = property.FindAnnotation(RelationalAnnotationNames.DefaultConstraintName);
+                    if (defaultConstraintNameAnnotation != null && defaultConstraintNameAnnotation.GetConfigurationSource() != ConfigurationSource.Convention)
+                    {
+                        // explicit constraint name - we already stored those so nothing to do here
+                        continue;
+                    }
+
+                    if (useNamedDefaultConstraints)
+                    {
+                        var mappedTables = property.GetMappedStoreObjects(StoreObjectType.Table);
+                        var mappedTablesCount = mappedTables.Count();
+
+                        if (mappedTablesCount == 0)
+                        {
+                            continue;
+                        }
+
+                        if (mappedTablesCount == 1)
+                        {
+                            var constraintNameCandidate = property.GenerateDefaultConstraintName(mappedTables.First());
+                            if (!existingDefaultConstraintNames.Contains(constraintNameCandidate))
+                            {
+                                // name that we generate is unique - add it to the list of names but we don't need to store it as annotation
+                                existingDefaultConstraintNames.Add(constraintNameCandidate);
+                            }
+                            else
+                            {
+                                // conflict - generate name that is unique and store is as annotation
+                                while (existingDefaultConstraintNames.Contains(constraintNameCandidate + suffixCounter))
+                                {
+                                    suffixCounter++;
+                                }
+
+                                existingDefaultConstraintNames.Add(constraintNameCandidate + suffixCounter);
+                                property.SetDefaultConstraintName(constraintNameCandidate + suffixCounter);
+                            }
+
+                            continue;
+                        }
+
+                        // TPC or entity splitting - when column is mapped to multiple tables, we can deal with them
+                        // as long as there are no name clashes with some other constraints
+                        // by the time we actually need to generate the constraint name (to put it in the annotation for the migration op)
+                        // we will know which store object the property we are processing is mapped to, so can pick the right name based on that
+                        // here though, where we want to uniquefy the name duplicates, we work on the model level so can't pick the right de-duped name
+                        // so in case of conflict, we have to throw
+                        // see issue #27970
+                        var constraintNameCandidates = new List<string>();
+                        foreach (var mappedTable in mappedTables)
+                        {
+                            var constraintNameCandidate = property.GenerateDefaultConstraintName(mappedTable);
+                            if (constraintNameCandidate != null)
+                            {
+                                if (!existingDefaultConstraintNames.Contains(constraintNameCandidate))
+                                {
+                                    constraintNameCandidates.Add(constraintNameCandidate);
+                                }
+                                else
+                                {
+                                    throw new InvalidOperationException(
+                                        RelationalStrings.ImplicitDefaultNamesNotSupportedForTpcWhenNamesClash(constraintNameCandidate));
+                                }
+                            }
+                        }
+
+                        existingDefaultConstraintNames.AddRange(constraintNameCandidates);
+                    }
+                }
+            }
+        }
+    }
+}

src/EFCore.Relational/Metadata/RelationalAnnotationNames.cs

@@ -52,6 +52,16 @@ public static class RelationalAnnotationNames
     /// </summary>
     public const string DefaultValue = Prefix + "DefaultValue";
 
+    /// <summary>
+    ///     The name for default constraint annotations.
+    /// </summary>
+    public const string DefaultConstraintName = Prefix + "DefaultConstraintName";
+
+    /// <summary>
+    ///     The name for using named default constraints annotations.
+    /// </summary>
+    public const string UseNamedDefaultConstraints = Prefix + "UseNamedDefaultConstraints";
+
     /// <summary>
     ///     The name for table name annotations.
     /// </summary>
@@ -360,6 +370,8 @@ public static class RelationalAnnotationNames
         ComputedColumnSql,
         IsStored,
         DefaultValue,
+        DefaultConstraintName,
+        UseNamedDefaultConstraints,
         TableName,
         Schema,
         ViewName,

src/EFCore.Relational/Properties/RelationalStrings.Designer.cs

@@ -427,6 +427,9 @@
   <data name="ExecuteUpdateSubqueryNotSupportedOverComplexTypes" xml:space="preserve">
     <value>ExecuteUpdate is being used over a LINQ operator which isn't natively supported by the database; this cannot be translated because complex type '{complexType}' is projected out. Rewrite your query to project out the containing entity type instead.</value>
   </data>
+  <data name="ExplicitDefaultConstraintNamesNotSupportedForTpc" xml:space="preserve">
+    <value>Can't use explicitly named default constraints with TPC inheritance or entity splitting. Constraint name: '{explicitDefaultConstraintName}'.</value>
+  </data>
   <data name="FromSqlMissingColumn" xml:space="preserve">
     <value>The required column '{column}' was not present in the results of a 'FromSql' operation.</value>
   </data>
@@ -439,6 +442,9 @@
   <data name="HasDataNotSupportedForEntitiesMappedToJson" xml:space="preserve">
     <value>Can't use HasData for entity type '{entity}'. HasData is not supported for entities mapped to JSON.</value>
   </data>
+  <data name="ImplicitDefaultNamesNotSupportedForTpcWhenNamesClash" xml:space="preserve">
+    <value>Named default constraints can't be used with TPC or entity splitting if they result in non-unique constraint name. Constraint name: '{constraintNameCandidate}'.</value>
+  </data>
   <data name="IncompatibleTableCommentMismatch" xml:space="preserve">
     <value>Cannot use table '{table}' for entity type '{entityType}' since it is being used for entity type '{otherEntityType}' and the comment '{comment}' does not match the comment '{otherComment}'.</value>
   </data>