Support value generation for converted types

Providers may need to be updated to support this.

Fixes #11597

src/EFCore.Cosmos/ValueGeneration/Internal/CosmosValueGeneratorSelector.cs

@@ -28,16 +28,14 @@ public CosmosValueGeneratorSelector(ValueGeneratorSelectorDependencies dependenc
     ///     any release. You should only use it directly in your code with extreme caution and knowing that
     ///     doing so can result in application failures when updating to a new Entity Framework Core release.
     /// </summary>
-    public override ValueGenerator Create(IProperty property, IEntityType entityType)
+    protected override ValueGenerator? FindForType(IProperty property, IEntityType entityType, Type clrType)
     {
-        var type = property.ClrType.UnwrapNullableType().UnwrapEnumType();
-
         if (property.GetJsonPropertyName() == ""
-            && type == typeof(int))
+            && clrType == typeof(int))
         {
             return new TemporaryNumberValueGeneratorFactory().Create(property, entityType);
         }
 
-        return base.Create(property, entityType);
+        return base.FindForType(property, entityType, clrType);
     }
 }

src/EFCore.Relational/Infrastructure/RelationalModelValidator.cs

@@ -1016,7 +1016,7 @@ private static bool IsIdentifyingPrincipal(IEntityType dependentEntityType, IEnt
         in StoreObjectIdentifier storeObject)
     {
         var value = property.GetDefaultValue(storeObject);
-        var converter = property.GetValueConverter() ?? property.FindRelationalTypeMapping(storeObject)?.Converter;
+        var converter = property.FindRelationalTypeMapping(storeObject)?.Converter;
 
         return converter != null
             ? converter.ConvertToProvider(value)

src/EFCore.Relational/Metadata/IColumn.cs

@@ -98,7 +98,7 @@ public virtual bool TryGetDefaultValue(out object? defaultValue)
                 continue;
             }
 
-            var converter = property.GetValueConverter() ?? PropertyMappings.First().TypeMapping.Converter;
+            var converter = PropertyMappings.First().TypeMapping.Converter;
 
             if (converter != null)
             {

src/EFCore.Relational/Migrations/Internal/MigrationsModelDiffer.cs

@@ -2455,7 +2455,7 @@ protected virtual IEnumerable<string> GetSchemas(IRelationalModel model)
                 : type.UnwrapNullableType().GetDefaultValue();
 
     private static ValueConverter? GetValueConverter(IProperty property, RelationalTypeMapping? typeMapping = null)
-        => property.GetValueConverter() ?? (property.FindRelationalTypeMapping() ?? typeMapping)?.Converter;
+        => (property.FindRelationalTypeMapping() ?? typeMapping)?.Converter;
 
     private static IEntityType GetMainType(ITable table)
         => table.EntityTypeMappings.First(t => t.IsSharedTablePrincipal).EntityType;

src/EFCore.Relational/ValueGeneration/RelationalValueGeneratorSelector.cs

@@ -40,58 +40,48 @@ public RelationalValueGeneratorSelector(ValueGeneratorSelectorDependencies depen
     {
     }
 
-    /// <summary>
-    ///     Creates a new value generator for the given property.
-    /// </summary>
-    /// <param name="property">The property to get the value generator for.</param>
-    /// <param name="entityType">
-    ///     The entity type that the value generator will be used for. When called on inherited properties on derived entity types,
-    ///     this entity type may be different from the declared entity type on <paramref name="property" />
-    /// </param>
-    /// <returns>The newly created value generator.</returns>
-    public override ValueGenerator Create(IProperty property, IEntityType entityType)
+    /// <inheritdoc />
+    protected override ValueGenerator? FindForType(IProperty property, IEntityType entityType, Type clrType)
     {
         if (property.ValueGenerated != ValueGenerated.Never)
         {
-            var propertyType = property.ClrType.UnwrapNullableType().UnwrapEnumType();
-
-            if (propertyType.IsInteger()
-                || propertyType == typeof(decimal)
-                || propertyType == typeof(float)
-                || propertyType == typeof(double))
+            if (clrType.IsInteger()
+                || clrType == typeof(decimal)
+                || clrType == typeof(float)
+                || clrType == typeof(double))
             {
                 return _numberFactory.Create(property, entityType);
             }
 
-            if (propertyType == typeof(DateTime))
+            if (clrType == typeof(DateTime))
             {
                 return new TemporaryDateTimeValueGenerator();
             }
 
-            if (propertyType == typeof(DateTimeOffset))
+            if (clrType == typeof(DateTimeOffset))
             {
                 return new TemporaryDateTimeOffsetValueGenerator();
             }
 
             if (property.GetDefaultValueSql() != null)
             {
-                if (propertyType == typeof(Guid))
+                if (clrType == typeof(Guid))
                 {
                     return new TemporaryGuidValueGenerator();
                 }
 
-                if (propertyType == typeof(string))
+                if (clrType == typeof(string))
                 {
                     return new TemporaryStringValueGenerator();
                 }
 
-                if (propertyType == typeof(byte[]))
+                if (clrType == typeof(byte[]))
                 {
                     return new TemporaryBinaryValueGenerator();
                 }
             }
         }
 
-        return base.Create(property, entityType);
+        return base.FindForType(property, entityType, clrType);
     }
 }

src/EFCore.SqlServer/ValueGeneration/Internal/ISqlServerSequenceValueGeneratorFactory.cs

@@ -19,8 +19,9 @@ public interface ISqlServerSequenceValueGeneratorFactory
     ///     any release. You should only use it directly in your code with extreme caution and knowing that
     ///     doing so can result in application failures when updating to a new Entity Framework Core release.
     /// </summary>
-    ValueGenerator Create(
+    ValueGenerator? TryCreate(
         IProperty property,
+        Type clrType,
         SqlServerSequenceValueGeneratorState generatorState,
         ISqlServerConnection connection,
         IRawSqlCommandBuilder rawSqlCommandBuilder,

src/EFCore.SqlServer/ValueGeneration/Internal/SqlServerSequenceValueGeneratorFactory.cs

@@ -34,15 +34,14 @@ public class SqlServerSequenceValueGeneratorFactory : ISqlServerSequenceValueGen
     ///     any release. You should only use it directly in your code with extreme caution and knowing that
     ///     doing so can result in application failures when updating to a new Entity Framework Core release.
     /// </summary>
-    public virtual ValueGenerator Create(
+    public virtual ValueGenerator? TryCreate(
         IProperty property,
+        Type type,
         SqlServerSequenceValueGeneratorState generatorState,
         ISqlServerConnection connection,
         IRawSqlCommandBuilder rawSqlCommandBuilder,
         IRelationalCommandDiagnosticsLogger commandLogger)
     {
-        var type = property.ClrType.UnwrapNullableType().UnwrapEnumType();
-
         if (type == typeof(long))
         {
             return new SqlServerSequenceHiLoValueGenerator<long>(
@@ -103,8 +102,6 @@ public class SqlServerSequenceValueGeneratorFactory : ISqlServerSequenceValueGen
                 rawSqlCommandBuilder, _sqlGenerator, generatorState, connection, commandLogger);
         }
 
-        throw new ArgumentException(
-            CoreStrings.InvalidValueGeneratorFactoryProperty(
-                nameof(SqlServerSequenceValueGeneratorFactory), property.Name, property.DeclaringEntityType.DisplayName()));
+        return null;
     }
 }

src/EFCore.SqlServer/ValueGeneration/Internal/SqlServerValueGeneratorSelector.cs

@@ -54,26 +54,61 @@ public new virtual ISqlServerValueGeneratorCache Cache
     ///     doing so can result in application failures when updating to a new Entity Framework Core release.
     /// </summary>
     public override ValueGenerator Select(IProperty property, IEntityType entityType)
-        => property.GetValueGeneratorFactory() == null
-            && property.GetValueGenerationStrategy() == SqlServerValueGenerationStrategy.SequenceHiLo
-                ? _sequenceFactory.Create(
-                    property,
-                    Cache.GetOrAddSequenceState(property, _connection),
-                    _connection,
-                    _rawSqlCommandBuilder,
-                    _commandLogger)
-                : base.Select(property, entityType);
+    {
+        if (property.GetValueGeneratorFactory() != null
+            || property.GetValueGenerationStrategy() != SqlServerValueGenerationStrategy.SequenceHiLo)
+        {
+            return base.Select(property, entityType);
+        }
+
+        var propertyType = property.ClrType.UnwrapNullableType().UnwrapEnumType();
+
+        var generator = _sequenceFactory.TryCreate(
+            property,
+            propertyType,
+            Cache.GetOrAddSequenceState(property, _connection),
+            _connection,
+            _rawSqlCommandBuilder,
+            _commandLogger);
+
+        if (generator != null)
+        {
+            return generator;
+        }
+
+        var converter = property.GetTypeMapping().Converter;
+        if (converter != null
+            && converter.ProviderClrType != propertyType)
+        {
+            generator = _sequenceFactory.TryCreate(
+                property,
+                converter.ProviderClrType,
+                Cache.GetOrAddSequenceState(property, _connection),
+                _connection,
+                _rawSqlCommandBuilder,
+                _commandLogger);
+
+            if (generator != null)
+            {
+                return generator.WithConverter(converter);
+            }
+        }
+
+        throw new ArgumentException(
+            CoreStrings.InvalidValueGeneratorFactoryProperty(
+                nameof(SqlServerSequenceValueGeneratorFactory), property.Name, property.DeclaringEntityType.DisplayName()));
+    }
 
     /// <summary>
     ///     This is an internal API that supports the Entity Framework Core infrastructure and not subject to
     ///     the same compatibility standards as public APIs. It may be changed or removed without notice in
     ///     any release. You should only use it directly in your code with extreme caution and knowing that
     ///     doing so can result in application failures when updating to a new Entity Framework Core release.
     /// </summary>
-    public override ValueGenerator Create(IProperty property, IEntityType entityType)
+    protected override ValueGenerator? FindForType(IProperty property, IEntityType entityType, Type clrType)
         => property.ClrType.UnwrapNullableType() == typeof(Guid)
             ? property.ValueGenerated == ValueGenerated.Never || property.GetDefaultValueSql() != null
                 ? new TemporaryGuidValueGenerator()
                 : new SequentialGuidValueGenerator()
-            : base.Create(property, entityType);
+            : base.FindForType(property, entityType, clrType);
 }

src/EFCore.Sqlite.Core/Metadata/Internal/SqliteAnnotationProvider.cs

@@ -69,5 +69,5 @@ public override IEnumerable<IAnnotation> For(IColumn column, bool designTime)
     }
 
     private static bool HasConverter(IProperty property)
-        => (property.GetValueConverter() ?? property.FindTypeMapping()?.Converter) != null;
+        => property.FindTypeMapping()?.Converter != null;
 }

src/EFCore/Metadata/Internal/PropertyAccessorsFactory.cs

@@ -80,11 +80,16 @@ private static PropertyAccessors CreateGeneric<TProperty>(IPropertyBase property
         var storeGeneratedIndex = propertyBase.GetStoreGeneratedIndex();
         if (storeGeneratedIndex >= 0)
         {
+            var comparer = (propertyBase as IProperty)?.GetValueComparer()
+                ?? ValueComparer.CreateDefault(propertyBase.ClrType, favorStructuralComparisons: true);
+
             if (useStoreGeneratedValues)
             {
                 currentValueExpression = Expression.Condition(
-                    Expression.Equal(
-                        currentValueExpression,
+                    comparer.ExtractEqualsBody(
+                        comparer.Type != currentValueExpression.Type
+                            ? Expression.Convert(currentValueExpression, comparer.Type)
+                            : currentValueExpression,
                         Expression.Constant(default(TProperty), typeof(TProperty))),
                     Expression.Call(
                         entryParameter,
@@ -94,8 +99,10 @@ private static PropertyAccessors CreateGeneric<TProperty>(IPropertyBase property
             }
 
             currentValueExpression = Expression.Condition(
-                Expression.Equal(
-                    currentValueExpression,
+                comparer.ExtractEqualsBody(
+                    comparer.Type != currentValueExpression.Type
+                        ? Expression.Convert(currentValueExpression, comparer.Type)
+                        : currentValueExpression,
                     Expression.Constant(default(TProperty), typeof(TProperty))),
                 Expression.Call(
                     entryParameter,

src/EFCore/Properties/CoreStrings.resx

@@ -1472,9 +1472,6 @@
   <data name="ValueCannotBeNull" xml:space="preserve">
     <value>The value for property '{1_entityType}.{0_property}' cannot be set to null because its type is '{propertyType}' which is not a nullable type.</value>
   </data>
-  <data name="ValueGenWithConversion" xml:space="preserve">
-    <value>Value generation is not supported for property '{entityType}.{property}' because it has a '{converter}' converter configured. Configure the property to not use value generation using 'ValueGenerated.Never' or 'DatabaseGeneratedOption.None' and specify explicit values instead.</value>
-  </data>
   <data name="VisitIsNotAllowed" xml:space="preserve">
     <value>Calling '{visitMethodName}' is not allowed. Visit the expression manually for the relevant part in the visitor.</value>
   </data>

src/EFCore/ValueGeneration/Internal/ConvertedValueGenerator.cs

@@ -0,0 +1,66 @@
+// 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.ValueGeneration.Internal;
+
+/// <summary>
+///     This is an internal API that supports the Entity Framework Core infrastructure and not subject to
+///     the same compatibility standards as public APIs. It may be changed or removed without notice in
+///     any release. You should only use it directly in your code with extreme caution and knowing that
+///     doing so can result in application failures when updating to a new Entity Framework Core release.
+/// </summary>
+public class ConvertedValueGenerator : ValueGenerator
+{
+    private readonly ValueGenerator _providerGenerator;
+    private readonly ValueConverter _converter;
+
+    /// <summary>
+    ///     This is an internal API that supports the Entity Framework Core infrastructure and not subject to
+    ///     the same compatibility standards as public APIs. It may be changed or removed without notice in
+    ///     any release. You should only use it directly in your code with extreme caution and knowing that
+    ///     doing so can result in application failures when updating to a new Entity Framework Core release.
+    /// </summary>
+    public ConvertedValueGenerator(
+        ValueGenerator providerGenerator,
+        ValueConverter converter)
+    {
+        _providerGenerator = providerGenerator;
+        _converter = converter;
+    }
+
+    /// <summary>
+    ///     This is an internal API that supports the Entity Framework Core infrastructure and not subject to
+    ///     the same compatibility standards as public APIs. It may be changed or removed without notice in
+    ///     any release. You should only use it directly in your code with extreme caution and knowing that
+    ///     doing so can result in application failures when updating to a new Entity Framework Core release.
+    /// </summary>
+    protected override object? NextValue(EntityEntry entry)
+        => _converter.ConvertFromProvider(_providerGenerator.Next(entry));
+
+    /// <summary>
+    ///     This is an internal API that supports the Entity Framework Core infrastructure and not subject to
+    ///     the same compatibility standards as public APIs. It may be changed or removed without notice in
+    ///     any release. You should only use it directly in your code with extreme caution and knowing that
+    ///     doing so can result in application failures when updating to a new Entity Framework Core release.
+    /// </summary>
+    public override async ValueTask<object?> NextAsync(EntityEntry entry, CancellationToken cancellationToken = default)
+        => _converter.ConvertFromProvider(await _providerGenerator.NextAsync(entry, cancellationToken).ConfigureAwait(false));
+
+    /// <summary>
+    ///     This is an internal API that supports the Entity Framework Core infrastructure and not subject to
+    ///     the same compatibility standards as public APIs. It may be changed or removed without notice in
+    ///     any release. You should only use it directly in your code with extreme caution and knowing that
+    ///     doing so can result in application failures when updating to a new Entity Framework Core release.
+    /// </summary>
+    public override bool GeneratesTemporaryValues
+        => _providerGenerator.GeneratesTemporaryValues;
+
+    /// <summary>
+    ///     This is an internal API that supports the Entity Framework Core infrastructure and not subject to
+    ///     the same compatibility standards as public APIs. It may be changed or removed without notice in
+    ///     any release. You should only use it directly in your code with extreme caution and knowing that
+    ///     doing so can result in application failures when updating to a new Entity Framework Core release.
+    /// </summary>
+    public override bool GeneratesStableValues
+        => _providerGenerator.GeneratesStableValues;
+}

src/EFCore/ValueGeneration/TemporaryNumberValueGeneratorFactory.cs

@@ -27,7 +27,7 @@ public class TemporaryNumberValueGeneratorFactory : ValueGeneratorFactory
     /// <returns>The newly created value generator.</returns>
     public override ValueGenerator Create(IProperty property, IEntityType entityType)
     {
-        var type = property.ClrType.UnwrapNullableType().UnwrapEnumType();
+        var type = (property.GetValueConverter()?.ProviderClrType ?? property.GetTypeMapping().ClrType).UnwrapEnumType();
 
         if (type == typeof(int))
         {

src/EFCore/ValueGeneration/ValueGenerator.cs

@@ -1,6 +1,8 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
+using Microsoft.EntityFrameworkCore.ValueGeneration.Internal;
+
 namespace Microsoft.EntityFrameworkCore.ValueGeneration;
 
 /// <summary>
@@ -91,4 +93,12 @@ public abstract class ValueGenerator
     /// </remarks>
     public virtual bool GeneratesStableValues
         => false;
+
+    /// <summary>
+    ///     Wraps this <see cref="ValueGenerator" /> such that it processes values converted with the given <see cref="ValueConverter" />.
+    /// </summary>
+    /// <param name="converter"> The value converter. </param>
+    /// <returns> A new value generator that works with the converted values. </returns>
+    public virtual ValueGenerator WithConverter(ValueConverter converter)
+        => new ConvertedValueGenerator(this, converter);
 }