[rc2] SQLite: Make AUTOINCREMENT first-class and fix false pending model changes warning for value converters

src/EFCore.SqlServer/Extensions/SqlServerPropertyExtensions.cs

@@ -807,7 +807,6 @@ internal static SqlServerValueGenerationStrategy GetValueGenerationStrategy(
     private static SqlServerValueGenerationStrategy GetDefaultValueGenerationStrategy(IReadOnlyProperty property)
     {
         var modelStrategy = property.DeclaringType.Model.GetValueGenerationStrategy();
-
         if (modelStrategy is SqlServerValueGenerationStrategy.SequenceHiLo or SqlServerValueGenerationStrategy.Sequence
             && IsCompatibleWithValueGeneration(property))
         {
@@ -826,7 +825,6 @@ private static SqlServerValueGenerationStrategy GetDefaultValueGenerationStrateg
         ITypeMappingSource? typeMappingSource)
     {
         var modelStrategy = property.DeclaringType.Model.GetValueGenerationStrategy();
-
         if (modelStrategy is SqlServerValueGenerationStrategy.SequenceHiLo or SqlServerValueGenerationStrategy.Sequence
             && IsCompatibleWithValueGeneration(property, storeObject, typeMappingSource))
         {
@@ -979,9 +977,9 @@ private static bool IsCompatibleWithValueGeneration(
 
         var type = (valueConverter?.ProviderClrType ?? property.ClrType).UnwrapNullableType();
 
-        return (type.IsInteger()
+        return type.IsInteger()
             || type.IsEnum
-            || type == typeof(decimal));
+            || type == typeof(decimal);
     }
 
     /// <summary>

src/EFCore.SqlServer/Metadata/Conventions/SqlServerValueGenerationConvention.cs

@@ -96,27 +96,24 @@ public override void ProcessEntityTypeAnnotationChanged(
     /// <returns>The store value generation strategy to set for the given property.</returns>
     protected override ValueGenerated? GetValueGenerated(IConventionProperty property)
     {
-        // TODO: move to relational?
-        if (property.DeclaringType.IsMappedToJson()
+        var table = property.GetMappedStoreObjects(StoreObjectType.Table).FirstOrDefault();
+        return table.Name != null
+                ? GetValueGenerated(property, table, Dependencies.TypeMappingSource)
+                : property.DeclaringType.IsMappedToJson()
 #pragma warning disable EF1001 // Internal EF Core API usage.
-            && property.IsOrdinalKeyProperty()
+                && property.IsOrdinalKeyProperty()
 #pragma warning restore EF1001 // Internal EF Core API usage.
-            && (property.DeclaringType as IReadOnlyEntityType)?.FindOwnership()!.IsUnique == false)
-        {
-            return ValueGenerated.OnAdd;
-        }
-
-        var declaringTable = property.GetMappedStoreObjects(StoreObjectType.Table).FirstOrDefault();
-        if (declaringTable.Name == null)
-        {
-            return null;
-        }
-
-        // If the first mapping can be value generated then we'll consider all mappings to be value generated
-        // as this is a client-side configuration and can't be specified per-table.
-        return GetValueGenerated(property, declaringTable, Dependencies.TypeMappingSource);
+                && (property.DeclaringType as IReadOnlyEntityType)?.FindOwnership()!.IsUnique == false
+                    ? ValueGenerated.OnAddOrUpdate
+                    : property.GetMappedStoreObjects(StoreObjectType.InsertStoredProcedure).Any()
+                        ? GetValueGenerated((IReadOnlyProperty)property)
+                        : null;
     }
 
+    /// <inheritdoc/>
+    protected override bool MappingStrategyAllowsValueGeneration(IConventionProperty property, string? mappingStrategy)
+        => true;
+
     /// <summary>
     ///     Returns the store value generation strategy to set for the given property.
     /// </summary>

src/EFCore.Sqlite.Core/Design/Internal/SqliteAnnotationCodeGenerator.cs

@@ -0,0 +1,96 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System.Diagnostics.CodeAnalysis;
+using Microsoft.EntityFrameworkCore.Sqlite.Metadata.Internal;
+
+namespace Microsoft.EntityFrameworkCore.Sqlite.Design.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 SqliteAnnotationCodeGenerator : AnnotationCodeGenerator
+{
+    #region MethodInfos
+
+    private static readonly MethodInfo PropertyUseAutoincrementMethodInfo
+        = typeof(SqlitePropertyBuilderExtensions).GetRuntimeMethod(
+            nameof(SqlitePropertyBuilderExtensions.UseAutoincrement), [typeof(PropertyBuilder)])!;
+
+    private static readonly MethodInfo ComplexTypePropertyUseAutoincrementMethodInfo
+        = typeof(SqliteComplexTypePropertyBuilderExtensions).GetRuntimeMethod(
+            nameof(SqliteComplexTypePropertyBuilderExtensions.UseAutoincrement), [typeof(ComplexTypePropertyBuilder)])!;
+
+    #endregion MethodInfos
+
+    /// <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 SqliteAnnotationCodeGenerator(AnnotationCodeGeneratorDependencies dependencies)
+        : base(dependencies)
+    {
+    }
+
+    /// <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 IReadOnlyList<MethodCallCodeFragment> GenerateFluentApiCalls(
+        IProperty property,
+        IDictionary<string, IAnnotation> annotations)
+    {
+        var fragments = new List<MethodCallCodeFragment>(base.GenerateFluentApiCalls(property, annotations));
+
+        if (TryGetAndRemove<SqliteValueGenerationStrategy>(annotations, SqliteAnnotationNames.ValueGenerationStrategy, out var strategy)
+            && strategy == SqliteValueGenerationStrategy.Autoincrement)
+        {
+            var methodInfo = property.DeclaringType is IComplexType
+                ? ComplexTypePropertyUseAutoincrementMethodInfo
+                : PropertyUseAutoincrementMethodInfo;
+            fragments.Add(new MethodCallCodeFragment(methodInfo));
+        }
+
+        return fragments;
+    }
+
+    /// <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 bool IsHandledByConvention(IProperty property, IAnnotation annotation)
+    {
+        if (annotation.Name == SqliteAnnotationNames.ValueGenerationStrategy)
+        {
+            return (SqliteValueGenerationStrategy)annotation.Value! == property.GetDefaultValueGenerationStrategy();
+        }
+
+        return base.IsHandledByConvention(property, annotation);
+    }
+
+    private static bool TryGetAndRemove<T>(
+        IDictionary<string, IAnnotation> annotations,
+        string annotationName,
+        [NotNullWhen(true)] out T? annotationValue)
+    {
+        if (annotations.TryGetValue(annotationName, out var annotation)
+            && annotation.Value != null)
+        {
+            annotations.Remove(annotationName);
+            annotationValue = (T)annotation.Value;
+            return true;
+        }
+
+        annotationValue = default;
+        return false;
+    }
+}

src/EFCore.Sqlite.Core/Design/Internal/SqliteDesignTimeServices.cs

@@ -27,6 +27,7 @@ public virtual void ConfigureDesignTimeServices(IServiceCollection serviceCollec
         serviceCollection.AddEntityFrameworkSqlite();
 #pragma warning disable EF1001 // Internal EF Core API usage.
         new EntityFrameworkRelationalDesignServicesBuilder(serviceCollection)
+            .TryAdd<IAnnotationCodeGenerator, SqliteAnnotationCodeGenerator>()
             .TryAdd<ICSharpRuntimeAnnotationCodeGenerator, SqliteCSharpRuntimeAnnotationCodeGenerator>()
 #pragma warning restore EF1001 // Internal EF Core API usage.
             .TryAdd<IDatabaseModelFactory, SqliteDatabaseModelFactory>()

src/EFCore.Sqlite.Core/Diagnostics/ConflictingValueGenerationStrategiesEventData.cs

@@ -0,0 +1,52 @@
+// 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.Diagnostics;
+
+/// <summary>
+///     A <see cref="DiagnosticSource" /> event payload class for events that have
+///     conflicting value generation strategies.
+/// </summary>
+/// <remarks>
+///     See <see href="https://aka.ms/efcore-docs-diagnostics">Logging, events, and diagnostics</see>, and
+///     <see href="https://aka.ms/efcore-docs-sqlite">Accessing SQLite databases with EF Core</see>
+///     for more information and examples.
+/// </remarks>
+public class ConflictingValueGenerationStrategiesEventData : EventData
+{
+    /// <summary>
+    ///     Constructs the event payload.
+    /// </summary>
+    /// <param name="eventDefinition">The event definition.</param>
+    /// <param name="messageGenerator">A delegate that generates a log message for this event.</param>
+    /// <param name="sqliteValueGenerationStrategy">The SQLite value generation strategy.</param>
+    /// <param name="otherValueGenerationStrategy">The other value generation strategy.</param>
+    /// <param name="property">The property.</param>
+    public ConflictingValueGenerationStrategiesEventData(
+        EventDefinitionBase eventDefinition,
+        Func<EventDefinitionBase, EventData, string> messageGenerator,
+        SqliteValueGenerationStrategy sqliteValueGenerationStrategy,
+        string otherValueGenerationStrategy,
+        IReadOnlyProperty property)
+        : base(eventDefinition, messageGenerator)
+    {
+        SqliteValueGenerationStrategy = sqliteValueGenerationStrategy;
+        OtherValueGenerationStrategy = otherValueGenerationStrategy;
+        Property = property;
+    }
+
+    /// <summary>
+    ///     The SQLite value generation strategy.
+    /// </summary>
+    public virtual SqliteValueGenerationStrategy SqliteValueGenerationStrategy { get; }
+
+    /// <summary>
+    ///     The other value generation strategy.
+    /// </summary>
+    public virtual string OtherValueGenerationStrategy { get; }
+
+    /// <summary>
+    ///     The property.
+    /// </summary>
+    public virtual IReadOnlyProperty Property { get; }
+}

src/EFCore.Sqlite.Core/Diagnostics/Internal/SqliteLoggingDefinitions.cs

@@ -131,6 +131,14 @@ public class SqliteLoggingDefinitions : RelationalLoggingDefinitions
     /// </summary>
     public EventDefinitionBase? LogCompositeKeyWithValueGeneration;
 
+    /// <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 EventDefinitionBase? LogConflictingValueGenerationStrategies;
+
     /// <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

src/EFCore.Sqlite.Core/Diagnostics/SqliteEventId.cs

@@ -30,6 +30,7 @@ private enum Id
         SchemaConfiguredWarning = CoreEventId.ProviderBaseId,
         SequenceConfiguredWarning,
         CompositeKeyWithValueGeneration,
+        ConflictingValueGenerationStrategiesWarning,
 
         // Infrastructure events
         UnexpectedConnectionTypeWarning = CoreEventId.ProviderBaseId + 100,
@@ -98,6 +99,20 @@ private static EventId MakeValidationId(Id id)
     /// </remarks>
     public static readonly EventId CompositeKeyWithValueGeneration = MakeValidationId(Id.CompositeKeyWithValueGeneration);
 
+    /// <summary>
+    ///     Both the SqliteValueGenerationStrategy and another value generation configuration have been set on a property. 
+    ///     Configuring two strategies is usually unintentional and will likely result in a database error.
+    /// </summary>
+    /// <remarks>
+    ///     <para>
+    ///         This event is in the <see cref="DbLoggerCategory.Model.Validation" /> category.
+    ///     </para>
+    ///     <para>
+    ///         This event uses the <see cref="ConflictingValueGenerationStrategiesEventData" /> payload when used with a <see cref="DiagnosticSource" />.
+    ///     </para>
+    /// </remarks>
+    public static readonly EventId ConflictingValueGenerationStrategiesWarning = MakeValidationId(Id.ConflictingValueGenerationStrategiesWarning);
+
     private static readonly string InfraPrefix = DbLoggerCategory.Infrastructure.Name + ".";
 
     private static EventId MakeInfraId(Id id)

src/EFCore.Sqlite.Core/Extensions/Internal/SqliteLoggerExtensions.cs

@@ -414,6 +414,51 @@ private static string CompositeKeyWithValueGeneration(EventDefinitionBase defini
             p.Key.Properties.Format());
     }
 
+    /// <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 static void ConflictingValueGenerationStrategiesWarning(
+        this IDiagnosticsLogger<DbLoggerCategory.Model.Validation> diagnostics,
+        SqliteValueGenerationStrategy sqliteValueGenerationStrategy,
+        string otherValueGenerationStrategy,
+        IReadOnlyProperty property)
+    {
+        var definition = SqliteResources.LogConflictingValueGenerationStrategies(diagnostics);
+
+        if (diagnostics.ShouldLog(definition))
+        {
+            definition.Log(
+                diagnostics, sqliteValueGenerationStrategy.ToString(), otherValueGenerationStrategy,
+                property.Name, property.DeclaringType.DisplayName());
+        }
+
+        if (diagnostics.NeedsEventData(definition, out var diagnosticSourceEnabled, out var simpleLogEnabled))
+        {
+            var eventData = new ConflictingValueGenerationStrategiesEventData(
+                definition,
+                ConflictingValueGenerationStrategiesWarning,
+                sqliteValueGenerationStrategy,
+                otherValueGenerationStrategy,
+                property);
+
+            diagnostics.DispatchEventData(definition, eventData, diagnosticSourceEnabled, simpleLogEnabled);
+        }
+    }
+
+    private static string ConflictingValueGenerationStrategiesWarning(EventDefinitionBase definition, EventData payload)
+    {
+        var d = (EventDefinition<string, string, string, string>)definition;
+        var p = (ConflictingValueGenerationStrategiesEventData)payload;
+        return d.GenerateMessage(
+            p.SqliteValueGenerationStrategy.ToString(),
+            p.OtherValueGenerationStrategy,
+            p.Property.Name,
+            p.Property.DeclaringType.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

src/EFCore.Sqlite.Core/Extensions/SqliteComplexTypePropertyBuilderExtensions.cs

@@ -12,6 +12,37 @@ namespace Microsoft.EntityFrameworkCore;
 /// </remarks>
 public static class SqliteComplexTypePropertyBuilderExtensions
 {
+    /// <summary>
+    ///     Configures the property to use the SQLite AUTOINCREMENT feature to generate values for new entities, 
+    ///     when targeting SQLite. This method sets the property's value generation strategy to <see cref="SqliteValueGenerationStrategy.Autoincrement" />.
+    /// </summary>
+    /// <remarks>
+    ///     See <see href="https://aka.ms/efcore-docs-modeling">Modeling entity types and relationships</see>, and
+    ///     <see href="https://aka.ms/efcore-docs-sqlite">Accessing SQLite databases with EF Core</see> for more information and examples.
+    /// </remarks>
+    /// <param name="propertyBuilder">The builder for the property being configured.</param>
+    /// <returns>The same builder instance so that multiple calls can be chained.</returns>
+    public static ComplexTypePropertyBuilder UseAutoincrement(this ComplexTypePropertyBuilder propertyBuilder)
+    {
+        propertyBuilder.Metadata.SetValueGenerationStrategy(SqliteValueGenerationStrategy.Autoincrement);
+
+        return propertyBuilder;
+    }
+
+    /// <summary>
+    ///     Configures the property to use the SQLite AUTOINCREMENT feature to generate values for new entities, 
+    ///     when targeting SQLite. This method sets the property's value generation strategy to <see cref="SqliteValueGenerationStrategy.Autoincrement" />.
+    /// </summary>
+    /// <remarks>
+    ///     See <see href="https://aka.ms/efcore-docs-modeling">Modeling entity types and relationships</see>, and
+    ///     <see href="https://aka.ms/efcore-docs-sqlite">Accessing SQLite databases with EF Core</see> for more information and examples.
+    /// </remarks>
+    /// <param name="propertyBuilder">The builder for the property being configured.</param>
+    /// <returns>The same builder instance so that multiple calls can be chained.</returns>
+    public static ComplexTypePropertyBuilder<TProperty> UseAutoincrement<TProperty>(
+        this ComplexTypePropertyBuilder<TProperty> propertyBuilder)
+        => (ComplexTypePropertyBuilder<TProperty>)UseAutoincrement((ComplexTypePropertyBuilder)propertyBuilder);
+
     /// <summary>
     ///     Configures the SRID of the column that the property maps to when targeting SQLite.
     /// </summary>