Handle identity annotations for compiled models

Add runtime checks for identity seed/increment on compiled models, update annotation retrieval to avoid table-specific overloads for RuntimeProperty, and ensure complex type properties are annotated with ValueGenerationStrategy.None. Improve type mapping logic and set EF_TEST_REWRITE_BASELINES to 0 in test.runsettings.

Author: ChrisJollyAU

src/EFCore.Jet/Design/Internal/JetCSharpRuntimeAnnotationCodeGenerator.cs

@@ -69,7 +69,6 @@ public override void Generate(IColumn column, CSharpRuntimeAnnotationCodeGenerat
         if (!parameters.IsRuntime)
         {
             var annotations = parameters.Annotations;
-            //annotations.Remove(JetAnnotationNames.Identity);
         }
 
         base.Generate(column, parameters);

src/EFCore.Jet/Extensions/JetPropertyExtensions.cs

@@ -18,6 +18,10 @@ public static class JetPropertyExtensions
         /// <returns> The identity seed. </returns>
         public static int? GetJetIdentitySeed(this IReadOnlyProperty property)
         {
+            if (property.DeclaringType.Model is RuntimeModel)
+            {
+                throw new InvalidOperationException(CoreStrings.RuntimeModelMissingData);
+            }
             var annotation = property.FindAnnotation(JetAnnotationNames.IdentitySeed);
             return (int?)annotation?.Value;
         }
@@ -172,8 +176,14 @@ public static void SetJetIdentitySeed(this IMutableRelationalPropertyOverrides o
         /// <param name="property"> The property. </param>
         /// <returns> The identity increment. </returns>
         public static int? GetJetIdentityIncrement(this IReadOnlyProperty property)
-            => (int?)property[JetAnnotationNames.IdentityIncrement]
+        {
+            if (property.DeclaringType.Model is RuntimeModel)
+            {
+                throw new InvalidOperationException(CoreStrings.RuntimeModelMissingData);
+            }
+            return (int?)property[JetAnnotationNames.IdentityIncrement]
                 ?? property.DeclaringType.Model.GetJetIdentityIncrement();
+        }
 
         /// <summary>
         ///     Returns the identity increment.

src/EFCore.Jet/Metadata/Conventions/JetValueGenerationStrategyConvention.cs

@@ -1,6 +1,7 @@
 // Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
 
 using EntityFrameworkCore.Jet.Metadata;
+using EntityFrameworkCore.Jet.Metadata.Internal;
 
 // ReSharper disable once CheckNamespace
 namespace Microsoft.EntityFrameworkCore.Metadata.Conventions
@@ -75,6 +76,10 @@ public virtual void ProcessModelFinalizing(
                         property.Builder.HasValueGenerationStrategy(strategy);
                     }
                 }
+
+                // Complex type properties can never be identity columns; annotate them with None so
+                // the compiled model and runtime model both carry the annotation for comparison.
+                SetComplexTypePropertyStrategies(entityType);
             }
 
             static bool IsStrategyNoneNeeded(IReadOnlyProperty property, StoreObjectIdentifier storeObject)
@@ -88,12 +93,32 @@ static bool IsStrategyNoneNeeded(IReadOnlyProperty property, StoreObjectIdentifi
                     var providerClrType = (property.GetValueConverter() ?? property.FindRelationalTypeMapping(storeObject)?.Converter)
                         ?.ProviderClrType.UnwrapNullableType();
 
-                    return providerClrType != null
-                        && (providerClrType.IsInteger() || providerClrType == typeof(decimal));
+                    // Fall back to property CLR type when there is no converter (e.g. long? with no HasConversion).
+                    // Type mappings may not yet be applied during ProcessModelFinalizing, so FindRelationalTypeMapping
+                    // returns null and providerClrType would be null even for integer-CLR-typed properties.
+                    var clrType = providerClrType ?? property.ClrType.UnwrapNullableType();
+                    return clrType.IsInteger() || clrType == typeof(decimal);
                 }
 
                 return false;
             }
+
+            static void SetComplexTypePropertyStrategies(IConventionTypeBase typeBase)
+            {
+                foreach (var complexProperty in typeBase.GetComplexProperties())
+                {
+                    var complexType = complexProperty.ComplexType;
+                    foreach (var property in complexType.GetDeclaredProperties())
+                    {
+                        var declaringTable = property.GetMappedStoreObjects(StoreObjectType.Table).FirstOrDefault();
+                        if (declaringTable.Name != null)
+                        {
+                            property.SetAnnotation(JetAnnotationNames.ValueGenerationStrategy, JetValueGenerationStrategy.None, false);
+                        }
+                    }
+                    SetComplexTypePropertyStrategies(complexType);
+                }
+            }
         }
     }
 }

src/EFCore.Jet/Metadata/Internal/JetAnnotationProvider.cs

@@ -64,12 +64,6 @@ public override IEnumerable<IAnnotation> For(ITableIndex index, bool designTime)
         /// </summary>
         public override IEnumerable<IAnnotation> For(IColumn column, bool designTime)
         {
-            //Need to do this in both design and runtime
-            if (!designTime)
-            {
-                yield break;
-            }
-
             var table = StoreObjectIdentifier.Table(column.Table.Name, column.Table.Schema);
             var property = column.PropertyMappings
                 .Select(m => m.Property)
@@ -78,8 +72,22 @@ public override IEnumerable<IAnnotation> For(IColumn column, bool designTime)
                          == JetValueGenerationStrategy.IdentityColumn);
             if (property != null)
             {
-                var seed = property.GetJetIdentitySeed(table);
-                var increment = property.GetJetIdentityIncrement(table);
+                // RuntimeProperty (compiled model) throws on the table-specific overloads since
+                // per-table overrides aren't stored in the compiled model; fall back to model-level
+                // using direct annotation access to avoid the RuntimeModel guards on the extensions.
+                int? seed, increment;
+                if (property is RuntimeProperty)
+                {
+                    seed = (int?)property[JetAnnotationNames.IdentitySeed]
+                        ?? property.DeclaringType.Model.GetJetIdentitySeed();
+                    increment = (int?)property[JetAnnotationNames.IdentityIncrement]
+                        ?? property.DeclaringType.Model.GetJetIdentityIncrement();
+                }
+                else
+                {
+                    seed = property.GetJetIdentitySeed(table);
+                    increment = property.GetJetIdentityIncrement(table);
+                }
 
                 yield return new Annotation(
                     JetAnnotationNames.Identity,

test/EFCore.Jet.FunctionalTests/test.runsettings

@@ -4,7 +4,7 @@
   <RunConfiguration>
     <EnvironmentVariables>
       <!-- List of environment variables we want to set-->
-      <EF_TEST_REWRITE_BASELINES>1</EF_TEST_REWRITE_BASELINES>
+      <EF_TEST_REWRITE_BASELINES>0</EF_TEST_REWRITE_BASELINES>
     </EnvironmentVariables>
   </RunConfiguration>
 </RunSettings>