diff --git a/Dependencies.targets b/Dependencies.targets
index 110ba5897..b05de6291 100644
--- a/Dependencies.targets
+++ b/Dependencies.targets
@@ -1,6 +1,6 @@
 <Project>
   <PropertyGroup Label="Common Versions">
-    <EFCoreVersion>[8.0.0,8.0.999]</EFCoreVersion>
+    <EFCoreVersion>[8.0.1,8.0.999]</EFCoreVersion>
   </PropertyGroup>
 
   <ItemGroup Label="Dependencies">
@@ -12,16 +12,16 @@
     <PackageReference Update="SingleStoreConnector" Version="1.2.0" />
 
     <PackageReference Update="NetTopologySuite" Version="2.5.0" />
-    <PackageReference Update="System.Text.Json" Version="8.0.0" />
+    <PackageReference Update="System.Text.Json" Version="8.0.1" />
     <PackageReference Update="Newtonsoft.Json" Version="13.0.3" />
 
     <PackageReference Update="Castle.Core" Version="5.1.1" />
-    <PackageReference Update="Microsoft.AspNetCore.Identity.EntityFrameworkCore" Version="8.0.0" />
-    <PackageReference Update="Microsoft.AspNetCore.Mvc.NewtonsoftJson" Version="8.0.0" />
+    <PackageReference Update="Microsoft.AspNetCore.Identity.EntityFrameworkCore" Version="8.0.1" />
+    <PackageReference Update="Microsoft.AspNetCore.Mvc.NewtonsoftJson" Version="8.0.1" />
     <PackageReference Update="Microsoft.Bcl.AsyncInterfaces" Version="8.0.0" />
     <PackageReference Update="Microsoft.Bcl.HashCode" Version="1.1.1" />
     <PackageReference Update="Microsoft.Extensions.Caching.Memory" Version="8.0.0" />
-    <PackageReference Update="Microsoft.Extensions.Configuration.Binder" Version="8.0.0" />
+    <PackageReference Update="Microsoft.Extensions.Configuration.Binder" Version="8.0.1" />
     <PackageReference Update="Microsoft.Extensions.Configuration.EnvironmentVariables" Version="8.0.0" />
     <PackageReference Update="Microsoft.Extensions.Configuration.FileExtensions" Version="8.0.0" />
     <PackageReference Update="Microsoft.Extensions.Configuration.Json" Version="8.0.0" />
diff --git a/README.md b/README.md
index 3eff634d7..1f46c1e8f 100644
--- a/README.md
+++ b/README.md
@@ -6,6 +6,7 @@
 
 Milestone | Status               | Release Date
 ----------|----------------------|-------------
+8.0.1| released             | February 2026
 8.0.0| released             | July 2025
 7.0.1| released             | March 2025
 7.0.0| released             | November 2024
diff --git a/Version.props b/Version.props
index 9ba606ba6..3b74372dc 100644
--- a/Version.props
+++ b/Version.props
@@ -12,8 +12,8 @@
           - "rtm"       - EF Core release independent, code quality production ready, major release
           - "servicing" - EF Core release independent, code quality production ready, mainly bugfixes
     -->
-    <VersionPrefix>8.0.0</VersionPrefix>
-    <PreReleaseVersionLabel>rtm</PreReleaseVersionLabel>
+    <VersionPrefix>8.0.1</VersionPrefix>
+    <PreReleaseVersionLabel>servicing</PreReleaseVersionLabel>
 
     <!--
       The following properties will automatically be set by CI builds when appropriate:
diff --git a/dotnet-tools.json b/dotnet-tools.json
index e3cadb92f..fd9a39d87 100644
--- a/dotnet-tools.json
+++ b/dotnet-tools.json
@@ -3,7 +3,7 @@
   "isRoot": true,
   "tools": {
     "dotnet-ef": {
-      "version": "8.0.0",
+      "version": "8.0.1",
       "commands": [
         "dotnet-ef"
       ]
diff --git a/src/EFCore.SingleStore.NTS/Query/Internal/SingleStoreGeometryMethodTranslator.cs b/src/EFCore.SingleStore.NTS/Query/Internal/SingleStoreGeometryMethodTranslator.cs
index 6f3e67f81..3a902132c 100644
--- a/src/EFCore.SingleStore.NTS/Query/Internal/SingleStoreGeometryMethodTranslator.cs
+++ b/src/EFCore.SingleStore.NTS/Query/Internal/SingleStoreGeometryMethodTranslator.cs
@@ -128,7 +128,7 @@ public virtual SqlExpression Translate(SqlExpression instance, MethodInfo method
                                 _sqlExpressionFactory.Constant(1))
                         },
                         method.ReturnType,
-                        _typeMappingSource.FindMapping(method.ReturnType, storeType),
+                        _typeMappingSource.FindMapping(method.ReturnType),
                         false);
                 }
 
@@ -138,7 +138,7 @@ public virtual SqlExpression Translate(SqlExpression instance, MethodInfo method
                         instance,
                         arguments[0],
                         method.ReturnType,
-                        _typeMappingSource.FindMapping(method.ReturnType, storeType));
+                        _typeMappingSource.FindMapping(method.ReturnType));
                 }
 
                 if (Equals(method, _isWithinDistance))
diff --git a/src/EFCore.SingleStore.NTS/Storage/Internal/SingleStoreNetTopologySuiteTypeMappingSourcePlugin.cs b/src/EFCore.SingleStore.NTS/Storage/Internal/SingleStoreNetTopologySuiteTypeMappingSourcePlugin.cs
index 8a4e73ca5..700a20c97 100644
--- a/src/EFCore.SingleStore.NTS/Storage/Internal/SingleStoreNetTopologySuiteTypeMappingSourcePlugin.cs
+++ b/src/EFCore.SingleStore.NTS/Storage/Internal/SingleStoreNetTopologySuiteTypeMappingSourcePlugin.cs
@@ -13,6 +13,7 @@
 using NetTopologySuite.Geometries;
 using EntityFrameworkCore.SingleStore.Infrastructure.Internal;
 
+// TODO: once we have geometry support in our adapter -- grab latest changes for this file
 namespace EntityFrameworkCore.SingleStore.Storage.Internal
 {
     /// <summary>
diff --git a/src/EFCore.SingleStore/Design/Internal/SingleStoreAnnotationCodeGenerator.cs b/src/EFCore.SingleStore/Design/Internal/SingleStoreAnnotationCodeGenerator.cs
index 5ad376748..9ed684096 100644
--- a/src/EFCore.SingleStore/Design/Internal/SingleStoreAnnotationCodeGenerator.cs
+++ b/src/EFCore.SingleStore/Design/Internal/SingleStoreAnnotationCodeGenerator.cs
@@ -5,9 +5,9 @@
 using System;
 using System.Collections.Generic;
 using System.Diagnostics;
+using System.Diagnostics.CodeAnalysis;
 using System.Linq;
 using System.Reflection;
-using JetBrains.Annotations;
 using Microsoft.EntityFrameworkCore;
 using Microsoft.EntityFrameworkCore.Design;
 using Microsoft.EntityFrameworkCore.Infrastructure;
@@ -20,6 +20,11 @@ namespace EntityFrameworkCore.SingleStore.Design.Internal
 {
     public class SingleStoreAnnotationCodeGenerator : AnnotationCodeGenerator
     {
+        private static readonly MethodInfo _modelUseIdentityColumnsMethodInfo
+            = typeof(SingleStoreModelBuilderExtensions).GetRequiredRuntimeMethod(
+                nameof(SingleStoreModelBuilderExtensions.AutoIncrementColumns),
+                typeof(ModelBuilder));
+
         private static readonly MethodInfo _modelHasCharSetMethodInfo
             = typeof(SingleStoreModelBuilderExtensions).GetRequiredRuntimeMethod(
                 nameof(SingleStoreModelBuilderExtensions.HasCharSet),
@@ -40,6 +45,12 @@ private static readonly MethodInfo _modelUseGuidCollationMethodInfo
                 typeof(ModelBuilder),
                 typeof(string));
 
+        private static readonly MethodInfo _modelHasAnnotationMethodInfo
+            = typeof(ModelBuilder).GetRequiredRuntimeMethod(
+                nameof(ModelBuilder.HasAnnotation),
+                typeof(string),
+                typeof(object));
+
         private static readonly MethodInfo _entityTypeHasCharSetMethodInfo
             = typeof(SingleStoreEntityTypeBuilderExtensions).GetRequiredRuntimeMethod(
                 nameof(SingleStoreEntityTypeBuilderExtensions.HasCharSet),
@@ -54,13 +65,24 @@ private static readonly MethodInfo _entityTypeUseCollationMethodInfo
                 typeof(string),
                 typeof(DelegationModes?));
 
+        private static readonly MethodInfo _propertyUseIdentityColumnMethodInfo
+            = typeof(SingleStorePropertyBuilderExtensions).GetRequiredRuntimeMethod(
+                nameof(SingleStorePropertyBuilderExtensions.UseSingleStoreIdentityColumn),
+                typeof(PropertyBuilder));
+
+        private static readonly MethodInfo _propertyUseComputedColumnMethodInfo
+            = typeof(SingleStorePropertyBuilderExtensions).GetRequiredRuntimeMethod(
+                nameof(SingleStorePropertyBuilderExtensions.UseSingleStoreComputedColumn),
+                typeof(PropertyBuilder));
+
+
         private static readonly MethodInfo _propertyHasCharSetMethodInfo
             = typeof(SingleStorePropertyBuilderExtensions).GetRequiredRuntimeMethod(
                 nameof(SingleStorePropertyBuilderExtensions.HasCharSet),
                 typeof(PropertyBuilder),
                 typeof(string));
 
-        public SingleStoreAnnotationCodeGenerator([NotNull] AnnotationCodeGeneratorDependencies dependencies)
+        public SingleStoreAnnotationCodeGenerator([JetBrains.Annotations.NotNull] AnnotationCodeGeneratorDependencies dependencies)
             : base(dependencies)
         {
         }
@@ -95,7 +117,7 @@ protected override MethodCallCodeFragment GenerateFluentApi(IModel model, IAnnot
                 var delegationModes = model[SingleStoreAnnotationNames.CharSetDelegation] as DelegationModes?;
                 return new MethodCallCodeFragment(
                     _modelHasCharSetMethodInfo,
-                    new[] {annotation.Value}
+                    new[] { annotation.Value }
                         .AppendIfTrue(delegationModes.HasValue, delegationModes)
                         .ToArray());
             }
@@ -116,7 +138,7 @@ protected override MethodCallCodeFragment GenerateFluentApi(IModel model, IAnnot
                 var delegationModes = model[SingleStoreAnnotationNames.CollationDelegation] as DelegationModes?;
                 return new MethodCallCodeFragment(
                     _modelUseCollationMethodInfo,
-                    new[] {annotation.Value}
+                    new[] { annotation.Value }
                         .AppendIfTrue(delegationModes.HasValue, delegationModes)
                         .ToArray());
             }
@@ -147,7 +169,7 @@ protected override MethodCallCodeFragment GenerateFluentApi(IEntityType entityTy
                 var delegationModes = entityType[SingleStoreAnnotationNames.CharSetDelegation] as DelegationModes?;
                 return new MethodCallCodeFragment(
                     _entityTypeHasCharSetMethodInfo,
-                    new[] {annotation.Value}
+                    new[] { annotation.Value }
                         .AppendIfTrue(delegationModes.HasValue, delegationModes)
                         .ToArray());
             }
@@ -166,7 +188,7 @@ protected override MethodCallCodeFragment GenerateFluentApi(IEntityType entityTy
                 var delegationModes = entityType[SingleStoreAnnotationNames.CollationDelegation] as DelegationModes?;
                 return new MethodCallCodeFragment(
                     _entityTypeUseCollationMethodInfo,
-                    new[] {annotation.Value}
+                    new[] { annotation.Value }
                         .AppendIfTrue(delegationModes.HasValue, delegationModes)
                         .ToArray());
             }
@@ -193,7 +215,7 @@ protected override AttributeCodeFragment GenerateDataAnnotation(IEntityType enti
                 var delegationModes = entityType[SingleStoreAnnotationNames.CharSetDelegation] as DelegationModes?;
                 return new AttributeCodeFragment(
                     typeof(SingleStoreCharSetAttribute),
-                    new[] {annotation.Value}
+                    new[] { annotation.Value }
                         .AppendIfTrue(delegationModes.HasValue, delegationModes)
                         .ToArray());
             }
@@ -212,7 +234,7 @@ protected override AttributeCodeFragment GenerateDataAnnotation(IEntityType enti
                 var delegationModes = entityType[SingleStoreAnnotationNames.CollationDelegation] as DelegationModes?;
                 return new AttributeCodeFragment(
                     typeof(SingleStoreCollationAttribute),
-                    new[] {annotation.Value}
+                    new[] { annotation.Value }
                         .AppendIfTrue(delegationModes.HasValue, delegationModes)
                         .ToArray());
             }
@@ -241,7 +263,7 @@ protected override MethodCallCodeFragment GenerateFluentApi(IProperty property,
 
             switch (annotation.Name)
             {
-                case SingleStoreAnnotationNames.CharSet when annotation.Value is string {Length: > 0} charSet:
+                case SingleStoreAnnotationNames.CharSet when annotation.Value is string { Length: > 0 } charSet:
                     return new MethodCallCodeFragment(
                         _propertyHasCharSetMethodInfo,
                         charSet);
@@ -258,10 +280,75 @@ protected override AttributeCodeFragment GenerateDataAnnotation(IProperty proper
 
             return annotation.Name switch
             {
-                SingleStoreAnnotationNames.CharSet when annotation.Value is string {Length: > 0} charSet => new AttributeCodeFragment(typeof(SingleStoreCharSetAttribute), charSet),
-                RelationalAnnotationNames.Collation when annotation.Value is string {Length: > 0} collation => new AttributeCodeFragment(typeof(SingleStoreCollationAttribute), collation),
+                SingleStoreAnnotationNames.CharSet when annotation.Value is string { Length: > 0 } charSet => new AttributeCodeFragment(
+                    typeof(SingleStoreCharSetAttribute), charSet),
+                RelationalAnnotationNames.Collation when annotation.Value is string { Length: > 0 } collation => new AttributeCodeFragment(
+                    typeof(SingleStoreCollationAttribute), collation),
                 _ => base.GenerateDataAnnotation(property, annotation)
             };
         }
+
+
+        public override IReadOnlyList<MethodCallCodeFragment> GenerateFluentApiCalls(
+            IModel model,
+            IDictionary<string, IAnnotation> annotations)
+        {
+            var fragments = new List<MethodCallCodeFragment>(base.GenerateFluentApiCalls(model, annotations));
+
+            if (GenerateValueGenerationStrategy(annotations, onModel: true) is { } valueGenerationStrategy)
+            {
+                fragments.Add(valueGenerationStrategy);
+            }
+
+            return fragments;
+        }
+
+        public override IReadOnlyList<MethodCallCodeFragment> GenerateFluentApiCalls(
+            IProperty property,
+            IDictionary<string, IAnnotation> annotations)
+        {
+            var fragments = new List<MethodCallCodeFragment>(base.GenerateFluentApiCalls(property, annotations));
+
+            if (GenerateValueGenerationStrategy(annotations, onModel: false) is { } valueGenerationStrategy)
+            {
+                fragments.Add(valueGenerationStrategy);
+            }
+
+            return fragments;
+        }
+
+        private MethodCallCodeFragment GenerateValueGenerationStrategy(IDictionary<string, IAnnotation> annotations, bool onModel)
+            => TryGetAndRemove(annotations, SingleStoreAnnotationNames.ValueGenerationStrategy, out SingleStoreValueGenerationStrategy strategy)
+                ? strategy switch
+                {
+                    SingleStoreValueGenerationStrategy.IdentityColumn => new MethodCallCodeFragment(
+                        onModel
+                            ? _modelUseIdentityColumnsMethodInfo
+                            : _propertyUseIdentityColumnMethodInfo),
+                    SingleStoreValueGenerationStrategy.ComputedColumn => new MethodCallCodeFragment(_propertyUseComputedColumnMethodInfo),
+                    SingleStoreValueGenerationStrategy.None => new MethodCallCodeFragment(
+                        _modelHasAnnotationMethodInfo,
+                        SingleStoreAnnotationNames.ValueGenerationStrategy,
+                        SingleStoreValueGenerationStrategy.None),
+                    _ => throw new ArgumentOutOfRangeException(strategy.ToString())
+                }
+                : null;
+
+        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 is not null)
+            {
+                annotations.Remove(annotationName);
+                annotationValue = (T)annotation.Value;
+                return true;
+            }
+
+            annotationValue = default;
+            return false;
+        }
     }
 }
diff --git a/src/EFCore.SingleStore/Design/Internal/SingleStoreCSharpRuntimeAnnotationCodeGenerator.cs b/src/EFCore.SingleStore/Design/Internal/SingleStoreCSharpRuntimeAnnotationCodeGenerator.cs
index 5f2a326fa..1e73a321f 100644
--- a/src/EFCore.SingleStore/Design/Internal/SingleStoreCSharpRuntimeAnnotationCodeGenerator.cs
+++ b/src/EFCore.SingleStore/Design/Internal/SingleStoreCSharpRuntimeAnnotationCodeGenerator.cs
@@ -2,13 +2,20 @@
 // Copyright (c) SingleStore Inc. All rights reserved.
 // Licensed under the MIT. See LICENSE in the project root for license information.
 
+using Microsoft.EntityFrameworkCore;
 using Microsoft.EntityFrameworkCore.ChangeTracking;
 using Microsoft.EntityFrameworkCore.Design.Internal;
+using Microsoft.EntityFrameworkCore.Metadata;
 using Microsoft.EntityFrameworkCore.Storage;
+using EntityFrameworkCore.SingleStore.Metadata.Internal;
 using EntityFrameworkCore.SingleStore.Storage.Internal;
 
 namespace EntityFrameworkCore.SingleStore.Design.Internal;
 
+// Used to generate a compiled model. The compiled model is only used at app runtime and not for design-time purposes.
+// Therefore, all annotations that are related to design-time concerns (i.e. databases, tables or columns) are superfluous and should be
+// removed.
+// TODO: Check behavior for `ValueGenerationStrategy`, `LegacyValueGeneratedOnAdd` and `LegacyValueGeneratedOnAddOrUpdate`.
 public class SingleStoreCSharpRuntimeAnnotationCodeGenerator : RelationalCSharpRuntimeAnnotationCodeGenerator
 {
     public SingleStoreCSharpRuntimeAnnotationCodeGenerator(
@@ -34,4 +41,166 @@ public override bool Create(
 
         return result;
     }
+
+    public override void Generate(IModel model, CSharpRuntimeAnnotationCodeGeneratorParameters parameters)
+    {
+        if (!parameters.IsRuntime)
+        {
+            var annotations = parameters.Annotations;
+
+            annotations.Remove(SingleStoreAnnotationNames.CharSet);
+            annotations.Remove(SingleStoreAnnotationNames.CharSetDelegation);
+#pragma warning disable CS0618 // Type or member is obsolete
+            annotations.Remove(SingleStoreAnnotationNames.Collation);
+#pragma warning restore CS0618 // Type or member is obsolete
+            annotations.Remove(SingleStoreAnnotationNames.CollationDelegation);
+            annotations.Remove(SingleStoreAnnotationNames.GuidCollation);
+        }
+
+        base.Generate(model, parameters);
+    }
+
+    public override void Generate(IRelationalModel model, CSharpRuntimeAnnotationCodeGeneratorParameters parameters)
+    {
+        if (!parameters.IsRuntime)
+        {
+            var annotations = parameters.Annotations;
+
+            annotations.Remove(SingleStoreAnnotationNames.CharSet);
+            annotations.Remove(SingleStoreAnnotationNames.CharSetDelegation);
+#pragma warning disable CS0618 // Type or member is obsolete
+            annotations.Remove(SingleStoreAnnotationNames.Collation);
+#pragma warning restore CS0618 // Type or member is obsolete
+            annotations.Remove(SingleStoreAnnotationNames.CollationDelegation);
+            annotations.Remove(SingleStoreAnnotationNames.GuidCollation);
+
+            annotations.Remove(RelationalAnnotationNames.Collation);
+        }
+
+        base.Generate(model, parameters);
+    }
+
+    public override void Generate(IEntityType entityType, CSharpRuntimeAnnotationCodeGeneratorParameters parameters)
+    {
+        if (!parameters.IsRuntime)
+        {
+            var annotations = parameters.Annotations;
+
+            annotations.Remove(SingleStoreAnnotationNames.CharSet);
+            annotations.Remove(SingleStoreAnnotationNames.CharSetDelegation);
+#pragma warning disable CS0618 // Type or member is obsolete
+            annotations.Remove(SingleStoreAnnotationNames.Collation);
+#pragma warning restore CS0618 // Type or member is obsolete
+            annotations.Remove(SingleStoreAnnotationNames.CollationDelegation);
+            annotations.Remove(SingleStoreAnnotationNames.StoreOptions);
+
+            annotations.Remove(RelationalAnnotationNames.Collation);
+        }
+
+        base.Generate(entityType, parameters);
+    }
+
+    public override void Generate(ITable table, CSharpRuntimeAnnotationCodeGeneratorParameters parameters)
+    {
+        if (!parameters.IsRuntime)
+        {
+            var annotations = parameters.Annotations;
+
+            annotations.Remove(SingleStoreAnnotationNames.CharSet);
+            annotations.Remove(SingleStoreAnnotationNames.CharSetDelegation);
+#pragma warning disable CS0618 // Type or member is obsolete
+            annotations.Remove(SingleStoreAnnotationNames.Collation);
+#pragma warning restore CS0618 // Type or member is obsolete
+            annotations.Remove(SingleStoreAnnotationNames.CollationDelegation);
+            annotations.Remove(SingleStoreAnnotationNames.StoreOptions);
+
+            annotations.Remove(RelationalAnnotationNames.Collation);
+        }
+
+        base.Generate(table, parameters);
+    }
+
+    public override void Generate(IProperty property, CSharpRuntimeAnnotationCodeGeneratorParameters parameters)
+    {
+        if (!parameters.IsRuntime)
+        {
+            var annotations = parameters.Annotations;
+
+            annotations.Remove(SingleStoreAnnotationNames.CharSet);
+#pragma warning disable CS0618 // Type or member is obsolete
+            annotations.Remove(SingleStoreAnnotationNames.Collation);
+#pragma warning restore CS0618 // Type or member is obsolete
+            annotations.Remove(SingleStoreAnnotationNames.SpatialReferenceSystemId);
+
+            annotations.Remove(RelationalAnnotationNames.Collation);
+
+            if (!annotations.ContainsKey(SingleStoreAnnotationNames.ValueGenerationStrategy))
+            {
+                annotations[SingleStoreAnnotationNames.ValueGenerationStrategy] = property.GetValueGenerationStrategy();
+            }
+        }
+
+        base.Generate(property, parameters);
+    }
+
+    public override void Generate(IColumn column, CSharpRuntimeAnnotationCodeGeneratorParameters parameters)
+    {
+        if (!parameters.IsRuntime)
+        {
+            var annotations = parameters.Annotations;
+
+            annotations.Remove(SingleStoreAnnotationNames.CharSet);
+#pragma warning disable CS0618 // Type or member is obsolete
+            annotations.Remove(SingleStoreAnnotationNames.Collation);
+#pragma warning restore CS0618 // Type or member is obsolete
+            annotations.Remove(SingleStoreAnnotationNames.SpatialReferenceSystemId);
+            annotations.Remove(SingleStoreAnnotationNames.ValueGenerationStrategy);
+
+            annotations.Remove(RelationalAnnotationNames.Collation);
+        }
+
+        base.Generate(column, parameters);
+    }
+
+    public override void Generate(IIndex index, CSharpRuntimeAnnotationCodeGeneratorParameters parameters)
+    {
+        if (!parameters.IsRuntime)
+        {
+            var annotations = parameters.Annotations;
+
+            annotations.Remove(SingleStoreAnnotationNames.FullTextIndex);
+            annotations.Remove(SingleStoreAnnotationNames.FullTextParser);
+            annotations.Remove(SingleStoreAnnotationNames.IndexPrefixLength);
+            annotations.Remove(SingleStoreAnnotationNames.SpatialIndex);
+        }
+
+        base.Generate(index, parameters);
+    }
+
+    public override void Generate(ITableIndex index, CSharpRuntimeAnnotationCodeGeneratorParameters parameters)
+    {
+        if (!parameters.IsRuntime)
+        {
+            var annotations = parameters.Annotations;
+
+            annotations.Remove(SingleStoreAnnotationNames.FullTextIndex);
+            annotations.Remove(SingleStoreAnnotationNames.FullTextParser);
+            annotations.Remove(SingleStoreAnnotationNames.IndexPrefixLength);
+            annotations.Remove(SingleStoreAnnotationNames.SpatialIndex);
+        }
+
+        base.Generate(index, parameters);
+    }
+
+    public override void Generate(IKey key, CSharpRuntimeAnnotationCodeGeneratorParameters parameters)
+    {
+        if (!parameters.IsRuntime)
+        {
+            var annotations = parameters.Annotations;
+
+            annotations.Remove(SingleStoreAnnotationNames.IndexPrefixLength);
+        }
+
+        base.Generate(key, parameters);
+    }
 }
diff --git a/src/EFCore.SingleStore/Extensions/SingleStoreEntityTypeExtensions.cs b/src/EFCore.SingleStore/Extensions/SingleStoreEntityTypeExtensions.cs
index 54101d51a..349e2db04 100644
--- a/src/EFCore.SingleStore/Extensions/SingleStoreEntityTypeExtensions.cs
+++ b/src/EFCore.SingleStore/Extensions/SingleStoreEntityTypeExtensions.cs
@@ -7,6 +7,7 @@
 using System.Text;
 using System.Text.RegularExpressions;
 using JetBrains.Annotations;
+using Microsoft.EntityFrameworkCore.Diagnostics;
 using Microsoft.EntityFrameworkCore.Metadata;
 using Microsoft.EntityFrameworkCore.Utilities;
 using EntityFrameworkCore.SingleStore.Metadata.Internal;
@@ -27,7 +28,9 @@ public static class SingleStoreEntityTypeExtensions
         /// <param name="entityType"> The entity type. </param>
         /// <returns> The name of the character set. </returns>
         public static string GetCharSet([NotNull] this IReadOnlyEntityType entityType)
-            => entityType[SingleStoreAnnotationNames.CharSet] as string;
+            => (entityType is RuntimeEntityType)
+                ? throw new InvalidOperationException(CoreStrings.RuntimeModelMissingData)
+                : entityType[SingleStoreAnnotationNames.CharSet] as string;
 
         /// <summary>
         /// Sets the MySQL character set on the table associated with this entity. When you only specify the character set, MySQL implicitly
@@ -82,12 +85,14 @@ public static string SetCharSet(
         /// <param name="entityType"> The entity type. </param>
         /// <returns> The character set delegation modes. </returns>
         public static DelegationModes? GetCharSetDelegation([NotNull] this IReadOnlyEntityType entityType)
-            => ObjectToEnumConverter.GetEnumValue<DelegationModes>(entityType[SingleStoreAnnotationNames.CharSetDelegation]) ??
-               (entityType[SingleStoreAnnotationNames.CharSetDelegation] is bool explicitlyDelegateToChildren
-                   ? explicitlyDelegateToChildren
-                       ? DelegationModes.ApplyToAll
-                       : DelegationModes.ApplyToDatabases
-                   : null);
+            => (entityType is RuntimeEntityType)
+                ? throw new InvalidOperationException(CoreStrings.RuntimeModelMissingData)
+                : ObjectToEnumConverter.GetEnumValue<DelegationModes>(entityType[SingleStoreAnnotationNames.CharSetDelegation]) ??
+                  (entityType[SingleStoreAnnotationNames.CharSetDelegation] is bool explicitlyDelegateToChildren
+                      ? explicitlyDelegateToChildren
+                          ? DelegationModes.ApplyToAll
+                          : DelegationModes.ApplyToDatabases
+                      : null);
 
         /// <summary>
         ///     Attempts to set the character set delegation modes for entity/table.
@@ -154,7 +159,9 @@ public static DelegationModes GetActualCharSetDelegation([NotNull] this IReadOnl
         /// <param name="entityType"> The entity type. </param>
         /// <returns> The name of the collation. </returns>
         public static string GetCollation([NotNull] this IReadOnlyEntityType entityType)
-            => entityType[RelationalAnnotationNames.Collation] as string;
+            => (entityType is RuntimeEntityType)
+                ? throw new InvalidOperationException(CoreStrings.RuntimeModelMissingData)
+                : entityType[RelationalAnnotationNames.Collation] as string;
 
         /// <summary>
         /// Sets the MySQL collation on the table associated with this entity. When you specify the collation, MySQL implicitly sets the
@@ -209,12 +216,14 @@ public static string SetCollation(
         /// <param name="entityType"> The entity type. </param>
         /// <returns> The collation delegation modes. </returns>
         public static DelegationModes? GetCollationDelegation([NotNull] this IReadOnlyEntityType entityType)
-            => ObjectToEnumConverter.GetEnumValue<DelegationModes>(entityType[SingleStoreAnnotationNames.CollationDelegation]) ??
-               (entityType[SingleStoreAnnotationNames.CollationDelegation] is bool explicitlyDelegateToChildren
-                   ? explicitlyDelegateToChildren
-                       ? DelegationModes.ApplyToAll
-                       : DelegationModes.ApplyToDatabases
-                   : null);
+            => (entityType is RuntimeEntityType)
+                ? throw new InvalidOperationException(CoreStrings.RuntimeModelMissingData)
+                : ObjectToEnumConverter.GetEnumValue<DelegationModes>(entityType[SingleStoreAnnotationNames.CollationDelegation]) ??
+                  (entityType[SingleStoreAnnotationNames.CollationDelegation] is bool explicitlyDelegateToChildren
+                      ? explicitlyDelegateToChildren
+                          ? DelegationModes.ApplyToAll
+                          : DelegationModes.ApplyToDatabases
+                      : null);
 
         /// <summary>
         ///     Attempts to set the collation delegation modes for entity/table.
@@ -281,7 +290,9 @@ public static DelegationModes GetActualCollationDelegation([NotNull] this IReadO
         /// <param name="entityType"> The entity type. </param>
         /// <returns> A dictionary of table options. </returns>
         public static Dictionary<string, string> GetTableOptions([NotNull] this IReadOnlyEntityType entityType)
-            => DeserializeTableOptions(entityType[SingleStoreAnnotationNames.StoreOptions] as string);
+            => (entityType is RuntimeEntityType)
+                ? throw new InvalidOperationException(CoreStrings.RuntimeModelMissingData)
+                : DeserializeTableOptions(entityType[SingleStoreAnnotationNames.StoreOptions] as string);
 
         /// <summary>
         /// Sets the MySQL table options for the table associated with this entity.
diff --git a/src/EFCore.SingleStore/Extensions/SingleStoreIndexExtensions.cs b/src/EFCore.SingleStore/Extensions/SingleStoreIndexExtensions.cs
index 66a19b015..1b35e85bb 100644
--- a/src/EFCore.SingleStore/Extensions/SingleStoreIndexExtensions.cs
+++ b/src/EFCore.SingleStore/Extensions/SingleStoreIndexExtensions.cs
@@ -2,7 +2,9 @@
 // Copyright (c) SingleStore Inc. All rights reserved.
 // Licensed under the MIT. See LICENSE in the project root for license information.
 
+using System;
 using JetBrains.Annotations;
+using Microsoft.EntityFrameworkCore.Diagnostics;
 using Microsoft.EntityFrameworkCore.Metadata;
 using EntityFrameworkCore.SingleStore.Metadata.Internal;
 
@@ -20,7 +22,9 @@ public static class SingleStoreIndexExtensions
         /// <param name="index"> The index. </param>
         /// <returns> <see langword="true"/> if the index is full text. </returns>
         public static bool? IsFullText([NotNull] this IIndex index)
-            => (bool?)index[SingleStoreAnnotationNames.FullTextIndex];
+            => (index is RuntimeIndex)
+                ? throw new InvalidOperationException(CoreStrings.RuntimeModelMissingData)
+                : (bool?)index[SingleStoreAnnotationNames.FullTextIndex];
 
         /// <summary>
         ///     Sets a value indicating whether the index is full text.
@@ -59,7 +63,9 @@ public static void SetIsFullText([NotNull] this IMutableIndex index, bool? value
         /// <param name="index"> The index. </param>
         /// <returns> The name of the full text parser. </returns>
         [CanBeNull] public static string FullTextParser([NotNull] this IIndex index)
-            => (string)index[SingleStoreAnnotationNames.FullTextParser];
+            => (index is RuntimeIndex)
+                ? throw new InvalidOperationException(CoreStrings.RuntimeModelMissingData)
+                : (string)index[SingleStoreAnnotationNames.FullTextParser];
 
         /// <summary>
         ///     Sets a value indicating which full text parser to used.
@@ -99,7 +105,9 @@ public static string SetFullTextParser([NotNull] this IConventionIndex index, [C
         /// <returns> The prefix lengths.
         /// A value of `0` indicates, that the full length should be used for that column. </returns>
         public static int[] PrefixLength([NotNull] this IIndex index)
-            => (int[])index[SingleStoreAnnotationNames.IndexPrefixLength];
+            => (index is RuntimeIndex)
+                ? throw new InvalidOperationException(CoreStrings.RuntimeModelMissingData)
+                : (int[])index[SingleStoreAnnotationNames.IndexPrefixLength];
 
         /// <summary>
         ///     Sets prefix lengths for the index.
@@ -140,7 +148,9 @@ public static int[] SetPrefixLength([NotNull] this IConventionIndex index, int[]
         /// <param name="index"> The index. </param>
         /// <returns> <see langword="true"/> if the index is spartial. </returns>
         public static bool? IsSpatial([NotNull] this IIndex index)
-            => (bool?)index[SingleStoreAnnotationNames.SpatialIndex];
+            => (index is RuntimeIndex)
+                ? throw new InvalidOperationException(CoreStrings.RuntimeModelMissingData)
+                : (bool?)index[SingleStoreAnnotationNames.SpatialIndex];
 
         /// <summary>
         ///     Sets a value indicating whether the index is spartial.
diff --git a/src/EFCore.SingleStore/Extensions/SingleStoreKeyExtensions.cs b/src/EFCore.SingleStore/Extensions/SingleStoreKeyExtensions.cs
index 7b6075296..9cc3e96d6 100644
--- a/src/EFCore.SingleStore/Extensions/SingleStoreKeyExtensions.cs
+++ b/src/EFCore.SingleStore/Extensions/SingleStoreKeyExtensions.cs
@@ -2,7 +2,9 @@
 // Copyright (c) SingleStore Inc. All rights reserved.
 // Licensed under the MIT. See LICENSE in the project root for license information.
 
+using System;
 using JetBrains.Annotations;
+using Microsoft.EntityFrameworkCore.Diagnostics;
 using Microsoft.EntityFrameworkCore.Metadata;
 using EntityFrameworkCore.SingleStore.Metadata.Internal;
 
@@ -21,7 +23,9 @@ public static class SingleStoreKeyExtensions
         /// <returns> The prefix lengths.
         /// A value of `0` indicates, that the full length should be used for that column. </returns>
         public static int[] PrefixLength([NotNull] this IKey key)
-            => (int[])key[SingleStoreAnnotationNames.IndexPrefixLength];
+            => (key is RuntimeKey)
+                ? throw new InvalidOperationException(CoreStrings.RuntimeModelMissingData)
+                : (int[])key[SingleStoreAnnotationNames.IndexPrefixLength];
 
         /// <summary>
         ///     Sets prefix lengths for the key.
diff --git a/src/EFCore.SingleStore/Extensions/SingleStoreModelBuilderExtensions.cs b/src/EFCore.SingleStore/Extensions/SingleStoreModelBuilderExtensions.cs
index 23e2b896b..b13f37a70 100644
--- a/src/EFCore.SingleStore/Extensions/SingleStoreModelBuilderExtensions.cs
+++ b/src/EFCore.SingleStore/Extensions/SingleStoreModelBuilderExtensions.cs
@@ -7,7 +7,6 @@
 using Microsoft.EntityFrameworkCore.Metadata;
 using Microsoft.EntityFrameworkCore.Metadata.Builders;
 using Microsoft.EntityFrameworkCore.Utilities;
-using EntityFrameworkCore.SingleStore.Infrastructure;
 using EntityFrameworkCore.SingleStore.Metadata.Internal;
 
 // ReSharper disable once CheckNamespace
@@ -15,6 +14,69 @@ namespace Microsoft.EntityFrameworkCore
 {
     public static class SingleStoreModelBuilderExtensions
     {
+        #region AutoIncrement
+
+        /// <summary>
+        ///     Configures the model to use the AUTO_INCREMENT feature to generate values for properties
+        ///     marked as <see cref="ValueGenerated.OnAdd" />, when targeting MySQL.
+        /// </summary>
+        /// <param name="modelBuilder">The model builder.</param>
+        /// <returns>The same builder instance so that multiple calls can be chained.</returns>
+        public static ModelBuilder AutoIncrementColumns(this ModelBuilder modelBuilder)
+        {
+            Check.NotNull(modelBuilder, nameof(modelBuilder));
+
+            var model = modelBuilder.Model;
+
+            model.SetValueGenerationStrategy(SingleStoreValueGenerationStrategy.IdentityColumn);
+
+            return modelBuilder;
+        }
+
+        /// <summary>
+        ///     Configures the value generation strategy for the key property, when targeting MySQL.
+        /// </summary>
+        /// <param name="modelBuilder">The builder for the property being configured.</param>
+        /// <param name="valueGenerationStrategy">The value generation strategy.</param>
+        /// <param name="fromDataAnnotation">Indicates whether the configuration was specified using a data annotation.</param>
+        /// <returns>
+        ///     The same builder instance if the configuration was applied, <see langword="null"/> otherwise.
+        /// </returns>
+        public static IConventionModelBuilder HasValueGenerationStrategy(
+            this IConventionModelBuilder modelBuilder,
+            SingleStoreValueGenerationStrategy? valueGenerationStrategy,
+            bool fromDataAnnotation = false)
+        {
+            if (modelBuilder.CanSetValueGenerationStrategy(valueGenerationStrategy, fromDataAnnotation))
+            {
+                modelBuilder.Metadata.SetValueGenerationStrategy(valueGenerationStrategy, fromDataAnnotation);
+
+                return modelBuilder;
+            }
+
+            return null;
+        }
+
+        /// <summary>
+        ///     Returns a value indicating whether the given value can be set as the default value generation strategy.
+        /// </summary>
+        /// <param name="modelBuilder"> The model builder. </param>
+        /// <param name="valueGenerationStrategy"> The value generation strategy. </param>
+        /// <param name="fromDataAnnotation"> Indicates whether the configuration was specified using a data annotation. </param>
+        /// <returns> <see langword="true"/> if the given value can be set as the default value generation strategy. </returns>
+        public static bool CanSetValueGenerationStrategy(
+            this IConventionModelBuilder modelBuilder,
+            SingleStoreValueGenerationStrategy? valueGenerationStrategy,
+            bool fromDataAnnotation = false)
+        {
+            Check.NotNull(modelBuilder, nameof(modelBuilder));
+
+            return modelBuilder.CanSetAnnotation(
+                SingleStoreAnnotationNames.ValueGenerationStrategy, valueGenerationStrategy, fromDataAnnotation);
+        }
+
+        #endregion Identity
+
         #region CharSet and delegation
 
         /// <summary>
diff --git a/src/EFCore.SingleStore/Extensions/SingleStoreModelExtensions.cs b/src/EFCore.SingleStore/Extensions/SingleStoreModelExtensions.cs
index 03b825eac..f5facb888 100644
--- a/src/EFCore.SingleStore/Extensions/SingleStoreModelExtensions.cs
+++ b/src/EFCore.SingleStore/Extensions/SingleStoreModelExtensions.cs
@@ -4,6 +4,7 @@
 
 using System;
 using JetBrains.Annotations;
+using Microsoft.EntityFrameworkCore.Diagnostics;
 using Microsoft.EntityFrameworkCore.Metadata;
 using EntityFrameworkCore.SingleStore.Metadata.Internal;
 
@@ -21,17 +22,11 @@ public static class SingleStoreModelExtensions
         /// <param name="model"> The model. </param>
         /// <returns> The default <see cref="SingleStoreValueGenerationStrategy" />. </returns>
         public static SingleStoreValueGenerationStrategy? GetValueGenerationStrategy([NotNull] this IReadOnlyModel model)
-        {
-            // Allow users to use the underlying type value instead of the enum itself.
-            // Workaround for: https://github.com/PomeloFoundation/Pomelo.EntityFrameworkCore.MySql/issues/1205
-            if (model[SingleStoreAnnotationNames.ValueGenerationStrategy] is { } annotation &&
-                ObjectToEnumConverter.GetEnumValue<SingleStoreValueGenerationStrategy>(annotation) is { } enumValue)
-            {
-                return enumValue;
-            }
-
-            return null;
-        }
+            => model[SingleStoreAnnotationNames.ValueGenerationStrategy] is { } annotationValue
+                ? ObjectToEnumConverter.GetEnumValue<SingleStoreValueGenerationStrategy>(annotationValue) is { } enumValue
+                    ? enumValue
+                    : (SingleStoreValueGenerationStrategy)annotationValue
+                : null;
 
         /// <summary>
         ///     Attempts to set the <see cref="SingleStoreValueGenerationStrategy" /> to use for properties
@@ -75,7 +70,9 @@ public static void SetValueGenerationStrategy([NotNull] this IMutableModel model
         /// <param name="model"> The model. </param>
         /// <returns> The default character set. </returns>
         public static string GetCharSet([NotNull] this IReadOnlyModel model)
-            => model[SingleStoreAnnotationNames.CharSet] as string;
+            => (model is RuntimeModel)
+                ? throw new InvalidOperationException(CoreStrings.RuntimeModelMissingData)
+                : model[SingleStoreAnnotationNames.CharSet] as string;
 
         /// <summary>
         ///     Attempts to set the character set to use as the default for the model/database.
@@ -116,12 +113,14 @@ public static string SetCharSet([NotNull] this IConventionModel model, string ch
         /// <param name="model"> The model. </param>
         /// <returns> The character set delegation modes. </returns>
         public static DelegationModes? GetCharSetDelegation([NotNull] this IReadOnlyModel model)
-            => ObjectToEnumConverter.GetEnumValue<DelegationModes>(model[SingleStoreAnnotationNames.CharSetDelegation]) ??
-               (model[SingleStoreAnnotationNames.CharSetDelegation] is bool explicitlyDelegateToChildren
-                   ? explicitlyDelegateToChildren
-                       ? DelegationModes.ApplyToAll
-                       : DelegationModes.ApplyToDatabases
-                   : null);
+            => (model is RuntimeModel)
+                ? throw new InvalidOperationException(CoreStrings.RuntimeModelMissingData)
+                : ObjectToEnumConverter.GetEnumValue<DelegationModes>(model[SingleStoreAnnotationNames.CharSetDelegation]) ??
+                  (model[SingleStoreAnnotationNames.CharSetDelegation] is bool explicitlyDelegateToChildren
+                      ? explicitlyDelegateToChildren
+                          ? DelegationModes.ApplyToAll
+                          : DelegationModes.ApplyToDatabases
+                      : null);
 
         /// <summary>
         ///     Attempts to set the character set delegation modes for the model/database.
@@ -182,12 +181,14 @@ public static DelegationModes GetActualCharSetDelegation([NotNull] this IReadOnl
         /// <param name="model"> The model. </param>
         /// <returns> The collation delegation modes. </returns>
         public static DelegationModes? GetCollationDelegation([NotNull] this IReadOnlyModel model)
-            => ObjectToEnumConverter.GetEnumValue<DelegationModes>(model[SingleStoreAnnotationNames.CollationDelegation]) ??
-               (model[SingleStoreAnnotationNames.CollationDelegation] is bool explicitlyDelegateToChildren
-                   ? explicitlyDelegateToChildren
-                       ? DelegationModes.ApplyToAll
-                       : DelegationModes.ApplyToDatabases
-                   : null);
+            => (model is RuntimeModel)
+                ? throw new InvalidOperationException(CoreStrings.RuntimeModelMissingData)
+                : ObjectToEnumConverter.GetEnumValue<DelegationModes>(model[SingleStoreAnnotationNames.CollationDelegation]) ??
+                  (model[SingleStoreAnnotationNames.CollationDelegation] is bool explicitlyDelegateToChildren
+                      ? explicitlyDelegateToChildren
+                          ? DelegationModes.ApplyToAll
+                          : DelegationModes.ApplyToDatabases
+                      : null);
 
         /// <summary>
         ///     Attempts to set the collation delegation modes for the model/database.
@@ -252,7 +253,9 @@ public static DelegationModes GetActualCollationDelegation([NotNull] this IReadO
         ///     collation `ascii_general_ci` will be applied.
         /// </returns>
         public static string GetGuidCollation([NotNull] this IReadOnlyModel model)
-            => model[SingleStoreAnnotationNames.GuidCollation] as string;
+            => (model is RuntimeModel)
+                ? throw new InvalidOperationException(CoreStrings.RuntimeModelMissingData)
+                : model[SingleStoreAnnotationNames.GuidCollation] as string;
 
         /// <summary>
         ///     Attempts to set the default collation used for char-based <see cref="Guid"/> columns.
diff --git a/src/EFCore.SingleStore/Extensions/SingleStorePropertyBuilderExtensions.cs b/src/EFCore.SingleStore/Extensions/SingleStorePropertyBuilderExtensions.cs
index 3bbb1c738..928f2e422 100644
--- a/src/EFCore.SingleStore/Extensions/SingleStorePropertyBuilderExtensions.cs
+++ b/src/EFCore.SingleStore/Extensions/SingleStorePropertyBuilderExtensions.cs
@@ -7,24 +7,25 @@
 using Microsoft.EntityFrameworkCore.Metadata;
 using Microsoft.EntityFrameworkCore.Metadata.Builders;
 using Microsoft.EntityFrameworkCore.Utilities;
-using EntityFrameworkCore.SingleStore.Infrastructure;
 using EntityFrameworkCore.SingleStore.Metadata.Internal;
 
 // ReSharper disable once CheckNamespace
 namespace Microsoft.EntityFrameworkCore
 {
+    #region AutoIncrement
+
     /// <summary>
     ///     MySQL specific extension methods for <see cref="PropertyBuilder" />.
     /// </summary>
     public static class SingleStorePropertyBuilderExtensions
     {
         /// <summary>
-        ///     Configures the key property to use the MySQL IDENTITY feature to generate values for new entities,
+        ///     Configures the key property to use the AUTO_INCREMENT feature to generate values for new entities,
         ///     when targeting MySQL. This method sets the property to be <see cref="ValueGenerated.OnAdd" />.
         /// </summary>
         /// <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 PropertyBuilder UseSingleStoreIdentityColumn(
+        public static PropertyBuilder UseSingleStoreIdentityColumn( // TODO: Mark as obsolete and introduce UseAutoIncrementColumn instead.
             [NotNull] this PropertyBuilder propertyBuilder)
         {
             Check.NotNull(propertyBuilder, nameof(propertyBuilder));
@@ -36,16 +37,69 @@ public static PropertyBuilder UseSingleStoreIdentityColumn(
         }
 
         /// <summary>
-        ///     Configures the key property to use the MySQL IDENTITY feature to generate values for new entities,
+        ///     Configures the key property to use the AUTO_INCREMENT feature to generate values for new entities,
         ///     when targeting MySQL. This method sets the property to be <see cref="ValueGenerated.OnAdd" />.
         /// </summary>
         /// <typeparam name="TProperty"> The type of the property being configured. </typeparam>
         /// <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 PropertyBuilder<TProperty> UseSingleStoreIdentityColumn<TProperty>(
+        public static PropertyBuilder<TProperty> UseSingleStoreIdentityColumn<TProperty>( // TODO: Mark as obsolete and introduce UseAutoIncrementColumn instead.
             [NotNull] this PropertyBuilder<TProperty> propertyBuilder)
             => (PropertyBuilder<TProperty>)UseSingleStoreIdentityColumn((PropertyBuilder)propertyBuilder);
 
+        #endregion Identity
+
+        #region General value generation strategy
+
+        /// <summary>
+        ///     Configures the value generation strategy for the key property, when targeting MySQL.
+        /// </summary>
+        /// <param name="propertyBuilder">The builder for the property being configured.</param>
+        /// <param name="valueGenerationStrategy">The value generation strategy.</param>
+        /// <param name="fromDataAnnotation">Indicates whether the configuration was specified using a data annotation.</param>
+        /// <returns>
+        ///     The same builder instance if the configuration was applied, <see langword="null"/> otherwise.
+        /// </returns>
+        public static IConventionPropertyBuilder HasValueGenerationStrategy(
+            this IConventionPropertyBuilder propertyBuilder,
+            SingleStoreValueGenerationStrategy? valueGenerationStrategy,
+            bool fromDataAnnotation = false)
+        {
+            if (propertyBuilder.CanSetAnnotation(
+                    SingleStoreAnnotationNames.ValueGenerationStrategy, valueGenerationStrategy, fromDataAnnotation))
+            {
+                propertyBuilder.Metadata.SetValueGenerationStrategy(valueGenerationStrategy, fromDataAnnotation);
+
+                return propertyBuilder;
+            }
+
+            return null;
+        }
+
+        /// <summary>
+        ///     Returns a value indicating whether the given value can be set as the value generation strategy.
+        /// </summary>
+        /// <param name="propertyBuilder">The builder for the property being configured.</param>
+        /// <param name="valueGenerationStrategy">The value generation strategy.</param>
+        /// <param name="fromDataAnnotation">Indicates whether the configuration was specified using a data annotation.</param>
+        /// <returns><see langword="true"/> if the given value can be set as the default value generation strategy.</returns>
+        public static bool CanSetValueGenerationStrategy(
+            this IConventionPropertyBuilder propertyBuilder,
+            SingleStoreValueGenerationStrategy? valueGenerationStrategy,
+            bool fromDataAnnotation = false)
+        {
+            Check.NotNull(propertyBuilder, nameof(propertyBuilder));
+
+            return (valueGenerationStrategy is null ||
+                    SingleStorePropertyExtensions.IsCompatibleIdentityColumn(propertyBuilder.Metadata))
+                && propertyBuilder.CanSetAnnotation(
+                    SingleStoreAnnotationNames.ValueGenerationStrategy, valueGenerationStrategy, fromDataAnnotation);
+        }
+
+        #endregion General value generation strategy
+
+        #region Computed
+
         /// <summary>
         ///     Configures the key property to use the MySQL Computed feature to generate values for new entities,
         ///     when targeting MySQL. This method sets the property to be <see cref="ValueGenerated.OnAddOrUpdate" />.
@@ -74,6 +128,10 @@ public static PropertyBuilder<TProperty> UseSingleStoreComputedColumn<TProperty>
             [NotNull] this PropertyBuilder<TProperty> propertyBuilder)
             => (PropertyBuilder<TProperty>)UseSingleStoreComputedColumn((PropertyBuilder)propertyBuilder);
 
+        #endregion Computed
+
+        #region CharSet
+
         /// <summary>
         /// Configures the charset for the property's column.
         /// </summary>
@@ -143,6 +201,10 @@ public static bool CanSetCharSet(
                 charSet,
                 fromDataAnnotation);
 
+        #endregion CharSet
+
+        #region Collation
+
         /// <summary>
         /// Configures the collation for the property's column.
         /// </summary>
@@ -171,6 +233,10 @@ public static PropertyBuilder<TProperty> HasCollation<TProperty>(
             string collation)
             => (PropertyBuilder<TProperty>)HasCollation((PropertyBuilder)propertyBuilder, collation);
 
+        #endregion Collation
+
+        #region SRID
+
         /// <summary>
         /// Restricts the Spatial Reference System Identifier (SRID) for the property's column.
         /// </summary>
@@ -199,5 +265,7 @@ public static PropertyBuilder<TProperty> HasSpatialReferenceSystem<TProperty>(
             [NotNull] this PropertyBuilder<TProperty> propertyBuilder,
             int? srid)
             => (PropertyBuilder<TProperty>)HasSpatialReferenceSystem((PropertyBuilder)propertyBuilder, srid);
+
+        #endregion SRID
     }
 }
diff --git a/src/EFCore.SingleStore/Extensions/SingleStorePropertyExtensions.cs b/src/EFCore.SingleStore/Extensions/SingleStorePropertyExtensions.cs
index e50375d7e..3598c4781 100644
--- a/src/EFCore.SingleStore/Extensions/SingleStorePropertyExtensions.cs
+++ b/src/EFCore.SingleStore/Extensions/SingleStorePropertyExtensions.cs
@@ -3,9 +3,9 @@
 // Licensed under the MIT. See LICENSE in the project root for license information.
 
 using System;
-using System.ComponentModel.DataAnnotations.Schema;
 using System.Linq;
 using JetBrains.Annotations;
+using Microsoft.EntityFrameworkCore.Diagnostics;
 using Microsoft.EntityFrameworkCore.Infrastructure;
 using Microsoft.EntityFrameworkCore.Metadata;
 using Microsoft.EntityFrameworkCore.Storage;
@@ -33,12 +33,21 @@ public static class SingleStorePropertyExtensions
         /// <returns> The strategy, or <see cref="SingleStoreValueGenerationStrategy.None"/> if none was set. </returns>
         public static SingleStoreValueGenerationStrategy GetValueGenerationStrategy([NotNull] this IReadOnlyProperty property)
         {
-            // Allow users to use the underlying type value instead of the enum itself.
-            // Workaround for: https://github.com/PomeloFoundation/Pomelo.EntityFrameworkCore.MySql/issues/1205
-            if (property[SingleStoreAnnotationNames.ValueGenerationStrategy] is { } annotationValue &&
-                ObjectToEnumConverter.GetEnumValue<SingleStoreValueGenerationStrategy>(annotationValue) is { } enumValue)
+            if (property.FindAnnotation(SingleStoreAnnotationNames.ValueGenerationStrategy) is { } annotation)
             {
-                return enumValue;
+                if (annotation.Value is { } annotationValue)
+                {
+                    // Allow users to use the underlying type value instead of the enum itself.
+                    // Workaround for: https://github.com/PomeloFoundation/Pomelo.EntityFrameworkCore.MySql/issues/1205
+                    if (ObjectToEnumConverter.GetEnumValue<SingleStoreValueGenerationStrategy>(annotationValue) is { } enumValue)
+                    {
+                        return enumValue;
+                    }
+
+                    return (SingleStoreValueGenerationStrategy)annotationValue;
+                }
+
+                return SingleStoreValueGenerationStrategy.None;
             }
 
             if (property.ValueGenerated == ValueGenerated.OnAdd)
@@ -51,11 +60,6 @@ public static SingleStoreValueGenerationStrategy GetValueGenerationStrategy([Not
                     return SingleStoreValueGenerationStrategy.None;
                 }
 
-                if (IsCompatibleIdentityColumn(property))
-                {
-                    return SingleStoreValueGenerationStrategy.IdentityColumn;
-                }
-
                 return GetDefaultValueGenerationStrategy(property);
             }
 
@@ -127,11 +131,6 @@ is StoreObjectIdentifier principal
                     return SingleStoreValueGenerationStrategy.None;
                 }
 
-                if (IsCompatibleIdentityColumn(property))
-                {
-                    return SingleStoreValueGenerationStrategy.IdentityColumn;
-                }
-
                 var defaultStrategy = GetDefaultValueGenerationStrategy(property, storeObject, typeMappingSource);
                 if (defaultStrategy != SingleStoreValueGenerationStrategy.None)
                 {
@@ -173,13 +172,10 @@ private static SingleStoreValueGenerationStrategy GetDefaultValueGenerationStrat
         {
             var modelStrategy = property.DeclaringType.Model.GetValueGenerationStrategy();
 
-            if (modelStrategy == SingleStoreValueGenerationStrategy.IdentityColumn &&
-                IsCompatibleAutoIncrementColumn(property))
-            {
-                return SingleStoreValueGenerationStrategy.IdentityColumn;
-            }
-
-            return SingleStoreValueGenerationStrategy.None;
+            return modelStrategy == SingleStoreValueGenerationStrategy.IdentityColumn &&
+                   IsCompatibleIdentityColumn(property)
+                ? SingleStoreValueGenerationStrategy.IdentityColumn
+                : SingleStoreValueGenerationStrategy.None;
         }
 
         private static SingleStoreValueGenerationStrategy GetDefaultValueGenerationStrategy(
@@ -190,7 +186,7 @@ private static SingleStoreValueGenerationStrategy GetDefaultValueGenerationStrat
             var modelStrategy = property.DeclaringType.Model.GetValueGenerationStrategy();
 
             return modelStrategy == SingleStoreValueGenerationStrategy.IdentityColumn
-                   && IsCompatibleAutoIncrementColumn(property, storeObject, typeMappingSource)
+                   && IsCompatibleIdentityColumn(property, storeObject, typeMappingSource)
                 ? SingleStoreValueGenerationStrategy.IdentityColumn
                 : SingleStoreValueGenerationStrategy.None;
         }
@@ -360,9 +356,12 @@ private static bool IsCompatibleIdentityColumn(
         /// <returns> <see langword="true"/> if compatible. </returns>
         public static bool IsCompatibleAutoIncrementColumn(IReadOnlyProperty property)
         {
-            var valueConverter = GetConverter(property);
+            var valueConverter = property.GetValueConverter() ??
+                        property.FindTypeMapping()?.Converter;
+
             var type = (valueConverter?.ProviderClrType ?? property.ClrType).UnwrapNullableType();
             return type.IsInteger() ||
+                   type.IsEnum ||
                    type == typeof(decimal);
         }
 
@@ -376,11 +375,14 @@ private static bool IsCompatibleAutoIncrementColumn(
                 return false;
             }
 
-            var valueConverter = GetConverter(property, storeObject, typeMappingSource);
+            var valueConverter = property.GetValueConverter() ??
+                        (property.FindRelationalTypeMapping(storeObject) ??
+                        typeMappingSource?.FindMapping((IProperty)property))?.Converter;
             var type = (valueConverter?.ProviderClrType ?? property.ClrType).UnwrapNullableType();
 
-            return (type.IsInteger()
-                    || type == typeof(decimal));
+            return (type.IsInteger() ||
+                    type.IsEnum ||
+                    type == typeof(decimal));
         }
 
         /// <summary>
@@ -454,8 +456,24 @@ private static ValueConverter GetConverter(
         /// <param name="property">The property of which to get the columns charset from.</param>
         /// <returns>The name of the charset or null, if no explicit charset was set.</returns>
         public static string GetCharSet([NotNull] this IReadOnlyProperty property)
-            => property[SingleStoreAnnotationNames.CharSet] as string ??
-               property.GetSingleStoreLegacyCharSet();
+            => (property is RuntimeProperty)
+                ? throw new InvalidOperationException(CoreStrings.RuntimeModelMissingData)
+                : property[SingleStoreAnnotationNames.CharSet] as string ??
+                  property.GetSingleStoreLegacyCharSet();
+
+        /// <summary>
+        /// Returns the name of the charset used by the column of the property.
+        /// </summary>
+        /// <param name="property">The property of which to get the columns charset from.</param>
+        /// <param name="storeObject">The identifier of the table-like store object containing the column.</param>
+        /// <returns>The name of the charset or null, if no explicit charset was set.</returns>
+        public static string GetCharSet(this IReadOnlyProperty property, in StoreObjectIdentifier storeObject)
+            => property is RuntimeProperty
+                ? throw new InvalidOperationException(CoreStrings.RuntimeModelMissingData)
+                : property.FindAnnotation(SingleStoreAnnotationNames.CharSet) is { } annotation
+                    ? annotation.Value as string ??
+                      property.GetSingleStoreLegacyCharSet()
+                    : property.FindSharedStoreObjectRootProperty(storeObject)?.GetCharSet(storeObject);
 
         /// <summary>
         /// Returns the name of the charset used by the column of the property, defined as part of the column type.
@@ -546,7 +564,22 @@ internal static string GetSingleStoreLegacyCollation([NotNull] this IReadOnlyPro
         /// <param name="property">The property of which to get the columns SRID from.</param>
         /// <returns>The SRID or null, if no explicit SRID has been set.</returns>
         public static int? GetSpatialReferenceSystem([NotNull] this IReadOnlyProperty property)
-            => (int?)property[SingleStoreAnnotationNames.SpatialReferenceSystemId];
+            => (property is RuntimeProperty)
+                ? throw new InvalidOperationException(CoreStrings.RuntimeModelMissingData)
+                : (int?)property[SingleStoreAnnotationNames.SpatialReferenceSystemId];
+
+        /// <summary>
+        /// Returns the Spatial Reference System Identifier (SRID) used by the column of the property.
+        /// </summary>
+        /// <param name="property">The property of which to get the columns SRID from.</param>
+        /// <param name="storeObject">The identifier of the table-like store object containing the column.</param>
+        /// <returns>The SRID or null, if no explicit SRID has been set.</returns>
+        public static int? GetSpatialReferenceSystem(this IReadOnlyProperty property, in StoreObjectIdentifier storeObject)
+            => property is RuntimeProperty
+                ? throw new InvalidOperationException(CoreStrings.RuntimeModelMissingData)
+                : property.FindAnnotation(SingleStoreAnnotationNames.SpatialReferenceSystemId) is { } annotation
+                    ? (int?)annotation.Value
+                    : property.FindSharedStoreObjectRootProperty(storeObject)?.GetSpatialReferenceSystem(storeObject);
 
         /// <summary>
         /// Sets the Spatial Reference System Identifier (SRID) in use by the column of the property.
diff --git a/src/EFCore.SingleStore/Infrastructure/ServerVersion.cs b/src/EFCore.SingleStore/Infrastructure/ServerVersion.cs
index 1858279bd..546d2fdea 100644
--- a/src/EFCore.SingleStore/Infrastructure/ServerVersion.cs
+++ b/src/EFCore.SingleStore/Infrastructure/ServerVersion.cs
@@ -72,7 +72,12 @@ public override string ToString()
         public static ServerVersion AutoDetect(string connectionString)
         {
             using var connection = new SingleStoreConnection(
-                new SingleStoreConnectionStringBuilder(connectionString) {Database = string.Empty}.ConnectionString);
+                new SingleStoreConnectionStringBuilder(connectionString)
+                {
+                    Database = string.Empty,
+                    AutoEnlist = false,
+                    Pooling = false,
+                }.ConnectionString);
             connection.Open();
             return Parse(connection.S2ServerVersion);
         }
@@ -96,7 +101,12 @@ public static ServerVersion AutoDetect(SingleStoreConnection connection)
             if (connection.State != ConnectionState.Open)
             {
                 using var clonedConnection = connection.CloneWith(
-                    new SingleStoreConnectionStringBuilder(connection.ConnectionString) {Database = string.Empty}.ConnectionString);
+                    new SingleStoreConnectionStringBuilder(connection.ConnectionString)
+                    {
+                        Database = string.Empty,
+                        AutoEnlist = false,
+                        Pooling = false,
+                    }.ConnectionString);
                 clonedConnection.Open();
                 serverVersion = clonedConnection.S2ServerVersion;
             }
diff --git a/src/EFCore.SingleStore/Infrastructure/ServerVersionSupport.cs b/src/EFCore.SingleStore/Infrastructure/ServerVersionSupport.cs
index 080c2eee3..362f2b5eb 100644
--- a/src/EFCore.SingleStore/Infrastructure/ServerVersionSupport.cs
+++ b/src/EFCore.SingleStore/Infrastructure/ServerVersionSupport.cs
@@ -74,8 +74,8 @@ public virtual bool PropertyOrVersion(string propertyNameOrServerVersion)
         public virtual bool SpatialDistanceFunctionImplementsAndoyer => false;
         public virtual bool SpatialDistanceSphereFunction => false;
         public virtual bool SpatialGeographic => false;
-        public virtual bool ExceptIntercept => false;
-        public virtual bool ExceptInterceptPrecedence => false;
+        public virtual bool ExceptIntercept => true;
+        public virtual bool ExceptInterceptPrecedence => true;
         public virtual bool JsonDataTypeEmulation => false;
         public virtual bool ImplicitBoolCheckUsesIndex => false;
         public virtual bool Sequences => false;
diff --git a/src/EFCore.SingleStore/Infrastructure/SingleStoreServerVersion.cs b/src/EFCore.SingleStore/Infrastructure/SingleStoreServerVersion.cs
index 62d4fc01c..eea72f5cb 100644
--- a/src/EFCore.SingleStore/Infrastructure/SingleStoreServerVersion.cs
+++ b/src/EFCore.SingleStore/Infrastructure/SingleStoreServerVersion.cs
@@ -11,12 +11,11 @@ namespace Microsoft.EntityFrameworkCore
 {
     /// <summary>
     /// Represents a <see cref="ServerVersion"/> for MySQL database servers.
-    /// For MariaDB database servers, use <see cref="MariaDbServerVersion"/> instead.
     /// </summary>
     public class SingleStoreServerVersion : ServerVersion
     {
         public static readonly string SingleStoreTypeIdentifier = nameof(ServerType.SingleStore).ToLowerInvariant();
-        public static readonly ServerVersion LatestSupportedServerVersion = new SingleStoreServerVersion(new Version(8, 9, 0));
+        public static readonly ServerVersion LatestSupportedServerVersion = new SingleStoreServerVersion(new Version(9, 0, 0));
 
         public override ServerVersionSupport Supports { get; }
 
diff --git a/src/EFCore.SingleStore/Metadata/Conventions/SingleStoreConventionSetBuilder.cs b/src/EFCore.SingleStore/Metadata/Conventions/SingleStoreConventionSetBuilder.cs
index fae3bf801..ef9bc0b44 100644
--- a/src/EFCore.SingleStore/Metadata/Conventions/SingleStoreConventionSetBuilder.cs
+++ b/src/EFCore.SingleStore/Metadata/Conventions/SingleStoreConventionSetBuilder.cs
@@ -36,6 +36,8 @@ public override ConventionSet CreateConventionSet()
         {
             var conventionSet = base.CreateConventionSet();
 
+            conventionSet.Add(new SingleStoreValueGenerationStrategyConvention(Dependencies, RelationalDependencies));
+
             conventionSet.ModelInitializedConventions.Add(new RelationalMaxIdentifierLengthConvention(64, Dependencies, RelationalDependencies));
 
             conventionSet.EntityTypeAddedConventions.Add(new TableCharSetAttributeConvention(Dependencies));
@@ -51,6 +53,10 @@ public override ConventionSet CreateConventionSet()
             ReplaceConvention(conventionSet.ForeignKeyRemovedConventions, valueGenerationConvention);
             conventionSet.PropertyAnnotationChangedConventions.Add(valueGenerationConvention);
 
+            ReplaceConvention(
+                conventionSet.ModelFinalizedConventions,
+                (RuntimeModelConvention)new SingleStoreRuntimeModelConvention(Dependencies, RelationalDependencies));
+
             return conventionSet;
         }
 
diff --git a/src/EFCore.SingleStore/Metadata/Conventions/SingleStoreRuntimeModelConvention.cs b/src/EFCore.SingleStore/Metadata/Conventions/SingleStoreRuntimeModelConvention.cs
new file mode 100644
index 000000000..0ba163ea7
--- /dev/null
+++ b/src/EFCore.SingleStore/Metadata/Conventions/SingleStoreRuntimeModelConvention.cs
@@ -0,0 +1,134 @@
+// Copyright (c) Pomelo Foundation. All rights reserved.
+// Copyright (c) SingleStore Inc. All rights reserved.
+// Licensed under the MIT. See LICENSE in the project root for license information.
+
+using System.Collections.Generic;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Metadata;
+using Microsoft.EntityFrameworkCore.Metadata.Conventions;
+using Microsoft.EntityFrameworkCore.Metadata.Conventions.Infrastructure;
+using EntityFrameworkCore.SingleStore.Metadata.Internal;
+
+namespace EntityFrameworkCore.SingleStore.Metadata.Conventions;
+
+/// <summary>
+///     A convention that creates an optimized copy of the mutable model.
+///     The runtime model is only used at app runtime and not for design-time purposes.
+///     Therefore, all annotations that are related to design-time concerns (i.e. databases, tables or columns) are superfluous and should
+///     be removed.
+/// </summary>
+public class SingleStoreRuntimeModelConvention : RelationalRuntimeModelConvention
+{
+    /// <summary>
+    ///     Creates a new instance of <see cref="SingleStoreRuntimeModelConvention" />.
+    /// </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 SingleStoreRuntimeModelConvention(
+        ProviderConventionSetBuilderDependencies dependencies,
+        RelationalConventionSetBuilderDependencies relationalDependencies)
+        : base(dependencies, relationalDependencies)
+    {
+    }
+
+    /// <inheritdoc />
+    protected override void ProcessModelAnnotations(
+        Dictionary<string, object> annotations,
+        IModel model,
+        RuntimeModel runtimeModel,
+        bool runtime)
+    {
+        base.ProcessModelAnnotations(annotations, model, runtimeModel, runtime);
+
+        if (!runtime)
+        {
+            annotations.Remove(SingleStoreAnnotationNames.CharSet);
+            annotations.Remove(SingleStoreAnnotationNames.CharSetDelegation);
+#pragma warning disable CS0618 // Type or member is obsolete
+            annotations.Remove(SingleStoreAnnotationNames.Collation);
+#pragma warning restore CS0618 // Type or member is obsolete
+            annotations.Remove(SingleStoreAnnotationNames.CollationDelegation);
+            annotations.Remove(SingleStoreAnnotationNames.GuidCollation);
+        }
+    }
+
+    /// <inheritdoc />
+    protected override void ProcessEntityTypeAnnotations(
+        Dictionary<string, object> annotations,
+        IEntityType entityType,
+        RuntimeEntityType runtimeEntityType,
+        bool runtime)
+    {
+        base.ProcessEntityTypeAnnotations(annotations, entityType, runtimeEntityType, runtime);
+
+        if (!runtime)
+        {
+            annotations.Remove(SingleStoreAnnotationNames.CharSet);
+            annotations.Remove(SingleStoreAnnotationNames.CharSetDelegation);
+#pragma warning disable CS0618 // Type or member is obsolete
+            annotations.Remove(SingleStoreAnnotationNames.Collation);
+#pragma warning restore CS0618 // Type or member is obsolete
+            annotations.Remove(SingleStoreAnnotationNames.CollationDelegation);
+            annotations.Remove(SingleStoreAnnotationNames.StoreOptions);
+
+            annotations.Remove(RelationalAnnotationNames.Collation);
+        }
+    }
+
+    /// <inheritdoc />
+    protected override void ProcessPropertyAnnotations(
+        Dictionary<string, object> annotations,
+        IProperty property,
+        RuntimeProperty runtimeProperty,
+        bool runtime)
+    {
+        base.ProcessPropertyAnnotations(annotations, property, runtimeProperty, runtime);
+
+        if (!runtime)
+        {
+            annotations.Remove(SingleStoreAnnotationNames.CharSet);
+#pragma warning disable CS0618 // Type or member is obsolete
+            annotations.Remove(SingleStoreAnnotationNames.Collation);
+#pragma warning restore CS0618 // Type or member is obsolete
+            annotations.Remove(SingleStoreAnnotationNames.SpatialReferenceSystemId);
+
+            if (!annotations.ContainsKey(SingleStoreAnnotationNames.ValueGenerationStrategy))
+            {
+                annotations[SingleStoreAnnotationNames.ValueGenerationStrategy] = property.GetValueGenerationStrategy();
+            }
+        }
+    }
+
+    /// <inheritdoc />
+    protected override void ProcessIndexAnnotations(
+        Dictionary<string, object> annotations,
+        IIndex index,
+        RuntimeIndex runtimeIndex,
+        bool runtime)
+    {
+        base.ProcessIndexAnnotations(annotations, index, runtimeIndex, runtime);
+
+        if (!runtime)
+        {
+            annotations.Remove(SingleStoreAnnotationNames.FullTextIndex);
+            annotations.Remove(SingleStoreAnnotationNames.FullTextParser);
+            annotations.Remove(SingleStoreAnnotationNames.IndexPrefixLength);
+            annotations.Remove(SingleStoreAnnotationNames.SpatialIndex);
+        }
+    }
+
+    /// <inheritdoc />
+    protected override void ProcessKeyAnnotations(
+        Dictionary<string, object> annotations,
+        IKey key,
+        RuntimeKey runtimeKey,
+        bool runtime)
+    {
+        base.ProcessKeyAnnotations(annotations, key, runtimeKey, runtime);
+
+        if (!runtime)
+        {
+            annotations.Remove(SingleStoreAnnotationNames.IndexPrefixLength);
+        }
+    }
+}
diff --git a/src/EFCore.SingleStore/Metadata/Conventions/SingleStoreValueGenerationStrategyConvention.cs b/src/EFCore.SingleStore/Metadata/Conventions/SingleStoreValueGenerationStrategyConvention.cs
new file mode 100644
index 000000000..2d44bce95
--- /dev/null
+++ b/src/EFCore.SingleStore/Metadata/Conventions/SingleStoreValueGenerationStrategyConvention.cs
@@ -0,0 +1,110 @@
+// Copyright (c) Pomelo Foundation. All rights reserved.
+// Copyright (c) SingleStore Inc. All rights reserved.
+// Licensed under the MIT. See LICENSE in the project root for license information.
+
+using System;
+using System.Linq;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Metadata;
+using Microsoft.EntityFrameworkCore.Metadata.Builders;
+using Microsoft.EntityFrameworkCore.Metadata.Conventions;
+using Microsoft.EntityFrameworkCore.Metadata.Conventions.Infrastructure;
+
+namespace EntityFrameworkCore.SingleStore.Metadata.Conventions;
+
+/// <summary>
+///     A convention that configures the default model <see cref="SingleStoreValueGenerationStrategy" /> as
+///     <see cref="SingleStoreValueGenerationStrategy.IdentityColumn" />.
+/// </summary>
+public class SingleStoreValueGenerationStrategyConvention : IModelInitializedConvention, IModelFinalizingConvention
+{
+    /// <summary>
+    ///     Creates a new instance of <see cref="SingleStoreValueGenerationStrategyConvention" />.
+    /// </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 SingleStoreValueGenerationStrategyConvention(
+        ProviderConventionSetBuilderDependencies dependencies,
+        RelationalConventionSetBuilderDependencies relationalDependencies)
+    {
+        Dependencies = dependencies;
+        RelationalDependencies = relationalDependencies;
+    }
+
+    /// <summary>
+    ///     Parameter object containing service dependencies.
+    /// </summary>
+    protected virtual ProviderConventionSetBuilderDependencies Dependencies { get; }
+
+    /// <summary>
+    ///     Relational provider-specific dependencies for this service.
+    /// </summary>
+    protected virtual RelationalConventionSetBuilderDependencies RelationalDependencies { get; }
+
+    /// <inheritdoc />
+    public virtual void ProcessModelInitialized(IConventionModelBuilder modelBuilder, IConventionContext<IConventionModelBuilder> context)
+        => modelBuilder.HasValueGenerationStrategy(SingleStoreValueGenerationStrategy.IdentityColumn);
+
+    /// <inheritdoc />
+    public virtual void ProcessModelFinalizing(
+        IConventionModelBuilder modelBuilder,
+        IConventionContext<IConventionModelBuilder> context)
+    {
+        foreach (var entityType in modelBuilder.Metadata.GetEntityTypes())
+        {
+            foreach (var property in entityType.GetDeclaredProperties())
+            {
+                SingleStoreValueGenerationStrategy? strategy = null;
+                var declaringTable = property.GetMappedStoreObjects(StoreObjectType.Table).FirstOrDefault();
+                if (declaringTable.Name != null!)
+                {
+                    strategy = property.GetValueGenerationStrategy(declaringTable, Dependencies.TypeMappingSource);
+                    if (strategy == SingleStoreValueGenerationStrategy.None &&
+                        !IsStrategyNoneNeeded(property, declaringTable))
+                    {
+                        strategy = null;
+                    }
+                }
+                else
+                {
+                    var declaringView = property.GetMappedStoreObjects(StoreObjectType.View).FirstOrDefault();
+                    if (declaringView.Name != null!)
+                    {
+                        strategy = property.GetValueGenerationStrategy(declaringView, Dependencies.TypeMappingSource);
+                        if (strategy == SingleStoreValueGenerationStrategy.None &&
+                            !IsStrategyNoneNeeded(property, declaringView))
+                        {
+                            strategy = null;
+                        }
+                    }
+                }
+
+                // Needed for the annotation to show up in the model snapshot.
+                if (strategy != null &&
+                    declaringTable.Name != null)
+                {
+                    property.Builder.HasValueGenerationStrategy(strategy);
+                }
+            }
+        }
+
+        bool IsStrategyNoneNeeded(IReadOnlyProperty property, StoreObjectIdentifier storeObject)
+        {
+            if (property.ValueGenerated == ValueGenerated.OnAdd &&
+                !property.TryGetDefaultValue(storeObject, out _) &&
+                property.GetDefaultValueSql(storeObject) is null &&
+                property.GetComputedColumnSql(storeObject) is null &&
+                property.DeclaringType.Model.GetValueGenerationStrategy() != SingleStoreValueGenerationStrategy.None)
+            {
+                var providerClrType = (property.GetValueConverter() ??
+                                       (property.FindRelationalTypeMapping(storeObject) ??
+                                        Dependencies.TypeMappingSource.FindMapping((IProperty)property))?.Converter)
+                    ?.ProviderClrType.UnwrapNullableType();
+
+                return providerClrType is not null && (providerClrType.IsInteger());
+            }
+
+            return false;
+        }
+    }
+}
diff --git a/src/EFCore.SingleStore/Migrations/SingleStoreMigrationsSqlGenerator.cs b/src/EFCore.SingleStore/Migrations/SingleStoreMigrationsSqlGenerator.cs
index 456c035f3..82d07e725 100644
--- a/src/EFCore.SingleStore/Migrations/SingleStoreMigrationsSqlGenerator.cs
+++ b/src/EFCore.SingleStore/Migrations/SingleStoreMigrationsSqlGenerator.cs
@@ -34,6 +34,8 @@ namespace EntityFrameworkCore.SingleStore.Migrations
     /// </summary>
     public class SingleStoreMigrationsSqlGenerator : MigrationsSqlGenerator
     {
+        private const string InternalAnnotationPrefix = SingleStoreAnnotationNames.Prefix + "SingleStoreMigrationsSqlGenerator:";
+
         private static readonly Regex _typeRegex = new Regex(@"(?<Name>[a-z0-9]+)\s*?(?:\(\s*(?<Length>\d+)?\s*\))?",
             RegexOptions.IgnoreCase);
 
@@ -79,63 +81,103 @@ public SingleStoreMigrationsSqlGenerator(
         /// <returns>The list of commands to be executed or scripted.</returns>
         public override IReadOnlyList<MigrationCommand> Generate(
             IReadOnlyList<MigrationOperation> operations,
-            IModel model,
+            IModel model = null,
             MigrationsSqlGenerationOptions options = MigrationsSqlGenerationOptions.Default)
         {
-            Check.NotNull(operations, nameof(operations));
-
-            Options = options;
-
-            var builder = new MigrationCommandListBuilder(Dependencies);
             try
             {
-                UpdateMigrationOperations(operations);
-                foreach (var operation in operations)
-                {
-                    if (!IsFullText(operation))
-                    {
-                        Generate(operation, model, builder);
-                    }
-                }
+                var filteredOperations = FilterOperations(operations, model);
+                var migrationCommands = base.Generate(filteredOperations, model, options);
+
+                return migrationCommands;
             }
             finally
             {
-                Options = MigrationsSqlGenerationOptions.Default;
+                CleanUpInternalAnnotations(operations);
             }
-
-            return builder.GetCommandList();
         }
 
-        private void UpdateMigrationOperations(IReadOnlyList<MigrationOperation> operations)
+        private static void CleanUpInternalAnnotations(IReadOnlyList<MigrationOperation> filteredOperations)
         {
-            foreach (var operation in operations)
+            foreach (var filteredOperation in filteredOperations)
             {
-                if (operation is CreateIndexOperation createIndexOperation)
+                foreach (var annotation in filteredOperation.GetAnnotations().ToList())
                 {
-                    if (IsFullText(operation))
+                    if (annotation.Name.StartsWith(InternalAnnotationPrefix))
                     {
-                        var createTableOperation = (CreateTableOperation)operations.Single(o =>
-                            (o is CreateTableOperation createTableOperation && createTableOperation.Name == createIndexOperation.Table));
-
-                        try
-                        {
-                            createTableOperation.AddAnnotation(SingleStoreAnnotationNames.FullTextIndex, createIndexOperation.Columns);
-                        }
-                        catch (InvalidOperationException)
-                        {
-                            throw new InvalidOperationException("Feature 'more than one FULLTEXT KEY' is not supported by SingleStore Distributed.");
-                        }
+                        filteredOperation.RemoveAnnotation(annotation.Name);
                     }
                 }
             }
         }
 
+        /// <summary>
+        ///     Checks if a migration operation is a FULLTEXT index creation.
+        /// </summary>
+        /// <param name="operation">The migration operation to check.</param>
+        /// <returns>True if the operation is a CreateIndexOperation with FULLTEXT annotation.</returns>
         private static bool IsFullText(MigrationOperation operation)
         {
             return operation is CreateIndexOperation &&
                    operation[SingleStoreAnnotationNames.FullTextIndex] as bool? == true;
         }
 
+        /// <summary>
+        ///     Filters and preprocesses migration operations to handle SingleStore-specific requirements.
+        ///
+        ///     FULLTEXT indexes: SingleStore requires FULLTEXT indexes to be defined inline in CREATE TABLE statements,
+        ///     not as separate CREATE INDEX statements. This method transfers FULLTEXT CreateIndexOperations to inline
+        ///     annotations on CreateTableOperations.
+        /// </summary>
+        /// <param name="operations">The list of migration operations to filter.</param>
+        /// <param name="model">The target model.</param>
+        /// <returns>A filtered list of operations ready for SQL generation.</returns>
+        protected virtual IReadOnlyList<MigrationOperation> FilterOperations(IReadOnlyList<MigrationOperation> operations, IModel model)
+        {
+            if (operations.Count <= 0)
+            {
+                return operations;
+            }
+
+            // Process FULLTEXT indexes
+            // SingleStore requires FULLTEXT indexes to be defined inline in CREATE TABLE statements, not as separate CREATE INDEX.
+            // We transfer the FULLTEXT index definition from CreateIndexOperation to CreateTableOperation as an annotation.
+            var filteredOperations = new List<MigrationOperation>();
+
+            foreach (var operation in operations)
+            {
+                if (operation is CreateIndexOperation createIndexOperation && IsFullText(operation))
+                {
+                    // Find the corresponding CreateTableOperation for this FULLTEXT index
+                    var createTableOperation = (CreateTableOperation)operations.Single(o =>
+                            (o is CreateTableOperation createTableOperation && createTableOperation.Name == createIndexOperation.Table));
+
+                    try
+                    {
+                        createTableOperation.AddAnnotation(SingleStoreAnnotationNames.FullTextIndex, createIndexOperation.Columns);
+                    }
+                    catch (InvalidOperationException)
+                    {
+                        throw new InvalidOperationException("Feature 'more than one FULLTEXT KEY' is not supported by SingleStore Distributed.");
+                    }
+
+                    // Transfer parser annotation if present (for custom FULLTEXT parsers like ngram)
+                    if (createIndexOperation[SingleStoreAnnotationNames.FullTextParser] is string parser)
+                    {
+                        createTableOperation.AddAnnotation(SingleStoreAnnotationNames.FullTextParser, parser);
+                    }
+
+                    // Skip adding this CreateIndexOperation - it will be generated inline in CREATE TABLE
+                    continue;
+                }
+
+                // Add all non-FULLTEXT operations to the list
+                filteredOperations.Add(operation);
+            }
+
+            return filteredOperations.AsReadOnly();
+        }
+
         /// <summary>
         ///     <para>
         ///         Builds commands for the given <see cref="MigrationOperation" /> by making calls on the given
@@ -854,29 +896,16 @@ protected override void ColumnDefinition(
             Check.NotNull(operation, nameof(operation));
             Check.NotNull(builder, nameof(builder));
 
-            var matchType = GetColumnType(schema, table, name, operation, model);
-            var matchLen = "";
-            var match = _typeRegex.Match(matchType ?? "-");
-            if (match.Success)
-            {
-                matchType = match.Groups["Name"].Value.ToLower();
-                if (match.Groups["Length"].Success)
-                {
-                    matchLen = match.Groups["Length"].Value;
-                }
-            }
-
+            var (matchType, matchLen) = GetColumBaseTypeAndLength(schema, table, name, operation, model);
             var valueGenerationStrategy = SingleStoreValueGenerationStrategyCompatibility.GetValueGenerationStrategy(operation.GetAnnotations().OfType<IAnnotation>().ToArray());
+            var autoIncrement = IsAutoIncrement(operation, matchType, valueGenerationStrategy);
 
-            var autoIncrement = false;
-            if (valueGenerationStrategy == SingleStoreValueGenerationStrategy.IdentityColumn &&
-                string.IsNullOrWhiteSpace(operation.DefaultValueSql) && operation.DefaultValue == null)
+            if (!autoIncrement &&
+                valueGenerationStrategy == SingleStoreValueGenerationStrategy.IdentityColumn &&
+                string.IsNullOrWhiteSpace(operation.DefaultValueSql))
             {
                 switch (matchType)
                 {
-                    case "bigint":
-                        autoIncrement = true;
-                        break;
                     case "datetime":
                         if (!_options.ServerVersion.Supports.DateTimeCurrentTimestamp)
                         {
@@ -884,8 +913,8 @@ protected override void ColumnDefinition(
                                 $"Error in {table}.{name}: DATETIME does not support values generated " +
                                 $"on Add or Update in server version {_options.ServerVersion}. Try explicitly setting the column type to TIMESTAMP.");
                         }
-
                         goto case "timestamp";
+
                     case "timestamp":
                         operation.DefaultValueSql = $"CURRENT_TIMESTAMP({matchLen})";
                         break;
@@ -921,15 +950,16 @@ protected override void ColumnDefinition(
             {
                 ColumnDefinitionWithCharSet(schema, table, name, operation, model, builder);
 
+                GenerateComment(operation.Comment, builder);
+
+                // AUTO_INCREMENT has priority over reference definitions.
+                // Note: SingleStore requires AUTO_INCREMENT columns to be included in an index (PRIMARY, UNIQUE, or regular KEY).
+                // This must be defined in the CREATE TABLE statement; ALTER TABLE ADD COLUMN with AUTO_INCREMENT is not supported.
                 if (autoIncrement)
                 {
                     builder.Append(" AUTO_INCREMENT");
                 }
-
-                GenerateComment(operation.Comment, builder);
-
-                // AUTO_INCREMENT has priority over reference definitions.
-                if (onUpdateSql != null && !autoIncrement)
+                else if (onUpdateSql != null)
                 {
                     builder
                         .Append(" ON UPDATE ")
@@ -955,6 +985,50 @@ protected override void ColumnDefinition(
             }
         }
 
+        protected virtual (string matchType, string matchLen) GetColumBaseTypeAndLength(
+            ColumnOperation operation,
+            IModel model)
+            => GetColumBaseTypeAndLength(operation.Schema, operation.Table, operation.Name, operation, model);
+
+        protected virtual (string matchType, string matchLen) GetColumBaseTypeAndLength(
+            string schema,
+            string table,
+            string name,
+            ColumnOperation operation,
+            IModel model)
+        {
+            var matchType = GetColumnType(schema, table, name, operation, model);
+            var matchLen = "";
+            var match = _typeRegex.Match(matchType ?? "-");
+            if (match.Success)
+            {
+                matchType = match.Groups["Name"].Value.ToLower();
+                if (match.Groups["Length"].Success)
+                {
+                    matchLen = match.Groups["Length"].Value;
+                }
+            }
+
+            return (matchType, matchLen);
+        }
+
+        protected virtual bool IsAutoIncrement(ColumnOperation operation,
+            string columnType,
+            SingleStoreValueGenerationStrategy? valueGenerationStrategy)
+        {
+            if (valueGenerationStrategy == SingleStoreValueGenerationStrategy.IdentityColumn &&
+                string.IsNullOrWhiteSpace(operation.DefaultValueSql))
+            {
+                switch (columnType)
+                {
+                    case "bigint":
+                        return true;
+                }
+            }
+
+            return false;
+        }
+
         private void GenerateComment(string comment, MigrationCommandListBuilder builder)
         {
             if (comment == null)
diff --git a/src/EFCore.SingleStore/Query/ExpressionVisitors/Internal/SingleStoreParameterInliningExpressionVisitor.cs b/src/EFCore.SingleStore/Query/ExpressionVisitors/Internal/SingleStoreParameterInliningExpressionVisitor.cs
index df5af5dcd..c62f85c51 100644
--- a/src/EFCore.SingleStore/Query/ExpressionVisitors/Internal/SingleStoreParameterInliningExpressionVisitor.cs
+++ b/src/EFCore.SingleStore/Query/ExpressionVisitors/Internal/SingleStoreParameterInliningExpressionVisitor.cs
@@ -2,6 +2,7 @@
 // Copyright (c) SingleStore Inc. All rights reserved.
 // Licensed under the MIT. See LICENSE in the project root for license information.
 
+using System;
 using System.Collections.Generic;
 using System.Linq.Expressions;
 using Microsoft.EntityFrameworkCore.Query;
@@ -26,7 +27,7 @@ public class SingleStoreParameterInliningExpressionVisitor : ExpressionVisitor
     private IReadOnlyDictionary<string, object> _parametersValues;
     private bool _canCache;
 
-    private bool _inJsonTableSourceParameterCall;
+    private bool _shouldInlineParameters;
 
     public SingleStoreParameterInliningExpressionVisitor(
         IRelationalTypeMappingSource typeMappingSource,
@@ -44,6 +45,7 @@ public virtual Expression Process(Expression expression, IReadOnlyDictionary<str
 
         _parametersValues = parametersValues;
         _canCache = true;
+        _shouldInlineParameters = false;
 
         var result = Visit(expression);
 
@@ -56,6 +58,7 @@ protected override Expression VisitExtension(Expression extensionExpression)
         => extensionExpression switch
         {
             SingleStoreJsonTableExpression jsonTableExpression => VisitJsonTable(jsonTableExpression),
+            SelectExpression selectExpression => VisitSelect(selectExpression),
             SqlParameterExpression sqlParameterExpression => VisitSqlParameter(sqlParameterExpression),
             ShapedQueryExpression shapedQueryExpression => shapedQueryExpression.Update(
                 Visit(shapedQueryExpression.QueryExpression),
@@ -63,36 +66,65 @@ protected override Expression VisitExtension(Expression extensionExpression)
             _ => base.VisitExtension(extensionExpression)
         };
 
+    protected virtual Expression VisitSelect(SelectExpression selectExpression)
+        => NewInlineParametersScope(
+            inlineParameters: false,
+            () => base.VisitExtension(selectExpression));
+    // => NewInlineParametersScope(
+    //     inlineParameters: false,
+    //     () => selectExpression.Offset is not null
+    //         ? selectExpression.Update(
+    //             selectExpression.Projection,
+    //             selectExpression.Tables,
+    //             selectExpression.Predicate,
+    //             selectExpression.GroupBy,
+    //             selectExpression.Having,
+    //             selectExpression.Orderings,
+    //             selectExpression.Limit,
+    //             NewInlineParametersScope(
+    //                 inlineParameters: true,
+    //                 () => (SqlExpression)Visit(selectExpression.Offset)))
+    //         : base.VisitExtension(selectExpression));
+
+    // For test simplicity, we currently inline parameters even for non MySQL database engines (even though it should not be necessary
+    // for e.g. MariaDB).
+    // TODO: Use inlined parameters only if JsonTableImplementationUsingParameterAsSourceWithoutEngineCrash is true.
     protected virtual Expression VisitJsonTable(SingleStoreJsonTableExpression jsonTableExpression)
-    {
-        var parentInJsonTableSourceParameterCall = _inJsonTableSourceParameterCall;
-        _inJsonTableSourceParameterCall = true;
-        var jsonExpression = (SqlExpression)Visit(jsonTableExpression.JsonExpression);
-        _inJsonTableSourceParameterCall = parentInJsonTableSourceParameterCall;
-
-        return jsonTableExpression.Update(
-            jsonExpression,
+        => jsonTableExpression.Update(
+            NewInlineParametersScope(
+                inlineParameters: true,
+                () => (SqlExpression)Visit(jsonTableExpression.JsonExpression)),
             jsonTableExpression.Path,
             jsonTableExpression.ColumnInfos);
-    }
 
     protected virtual Expression VisitSqlParameter(SqlParameterExpression sqlParameterExpression)
     {
-        // For test simplicity, we currently inline parameters even for non MySQL database engines (even though it should not be necessary
-        // for e.g. MariaDB).
-        // TODO: Use inlined parameters only if JsonTableImplementationUsingParameterAsSourceWithoutEngineCrash is true.
-        if (_inJsonTableSourceParameterCall /*&&
-            !_options.ServerVersion.Supports.JsonTableImplementationUsingParameterAsSourceWithoutEngineCrash*/)
+        if (!_shouldInlineParameters)
         {
-            _canCache = false;
-
-            return new SingleStoreInlinedParameterExpression(
-                sqlParameterExpression,
-                _sqlExpressionFactory.Constant(
-                    _parametersValues[sqlParameterExpression.Name],
-                    sqlParameterExpression.TypeMapping));
+            return sqlParameterExpression;
         }
 
-        return sqlParameterExpression;
+        _canCache = false;
+
+        return new SingleStoreInlinedParameterExpression(
+            sqlParameterExpression,
+            _sqlExpressionFactory.Constant(
+                _parametersValues[sqlParameterExpression.Name],
+                sqlParameterExpression.TypeMapping));
+    }
+
+    protected virtual T NewInlineParametersScope<T>(bool inlineParameters, Func<T> func)
+    {
+        var parentShouldInlineParameters = _shouldInlineParameters;
+        _shouldInlineParameters = inlineParameters;
+
+        try
+        {
+            return func();
+        }
+        finally
+        {
+            _shouldInlineParameters = parentShouldInlineParameters;
+        }
     }
 }
diff --git a/src/EFCore.SingleStore/Query/ExpressionVisitors/Internal/SingleStoreQuerySqlGenerator.cs b/src/EFCore.SingleStore/Query/ExpressionVisitors/Internal/SingleStoreQuerySqlGenerator.cs
index 481beb65a..d0d9fe593 100644
--- a/src/EFCore.SingleStore/Query/ExpressionVisitors/Internal/SingleStoreQuerySqlGenerator.cs
+++ b/src/EFCore.SingleStore/Query/ExpressionVisitors/Internal/SingleStoreQuerySqlGenerator.cs
@@ -865,7 +865,29 @@ public virtual Expression VisitSingleStoreBinaryExpression(SingleStoreBinaryExpr
             return mySqlBinaryExpression;
         }
 
-                protected virtual Expression VisitJsonTableExpression(SingleStoreJsonTableExpression jsonTableExpression)
+        protected override Expression VisitOrdering(OrderingExpression orderingExpression)
+        {
+            // The base implementation translates this case to `(SELECT 1)`.
+            // This leads to a bug in Oracle's MySQL, where completely wrong data is being returned under certain conditions.
+            // This can be reproduced by executing a no-op (or any existing) test of the `ProxyGraphUpdatesSingleStoreTest+LazyLoading` class (e.g. our own `DummyTest`),
+            // immediately followed by NorthwindSplitIncludeNoTrackingQuerySingleStoreTest.Include_collection_OrderBy_empty_list_contains(async: False).
+            // As a workaround, we just output `1` instead of `(SELECT 1)` for all database versions and types.
+            if (orderingExpression.Expression is SqlConstantExpression or SqlParameterExpression)
+            {
+                Sql.Append("1");
+
+                if (!orderingExpression.IsAscending)
+                {
+                    Sql.Append(" DESC");
+                }
+
+                return orderingExpression;
+            }
+
+            return base.VisitOrdering(orderingExpression);
+        }
+
+        protected virtual Expression VisitJsonTableExpression(SingleStoreJsonTableExpression jsonTableExpression)
         {
             // if (jsonTableExpression.ColumnInfos is not { Count: > 0 })
             // {
diff --git a/src/EFCore.SingleStore/Storage/Internal/BytesToDateTimeConverter.cs b/src/EFCore.SingleStore/Storage/Internal/BytesToDateTimeConverter.cs
index 34c6da8f2..09ca1a26b 100644
--- a/src/EFCore.SingleStore/Storage/Internal/BytesToDateTimeConverter.cs
+++ b/src/EFCore.SingleStore/Storage/Internal/BytesToDateTimeConverter.cs
@@ -14,9 +14,15 @@ private static readonly NumberToBytesConverter<long> _longToBytes
 
         public BytesToDateTimeConverter()
             : base(
-                v => DateTime.FromBinary((long)_longToBytes.ConvertFromProvider(v)),
-                v => (byte[])_longToBytes.ConvertToProvider(v.ToBinary()))
+                v => FromBytes(v),
+                v => ToBytes(v))
         {
         }
+
+        public static byte[] ToBytes(DateTime v)
+            => (byte[])_longToBytes.ConvertToProvider(v.ToBinary());
+
+        public static DateTime FromBytes(byte[] v)
+            => DateTime.FromBinary((long)_longToBytes.ConvertFromProvider(v));
     }
 }
diff --git a/test/EFCore.SingleStore.FunctionalTests/AssemblyInfo.cs b/test/EFCore.SingleStore.FunctionalTests/AssemblyInfo.cs
index 6714ac906..93af71ff1 100644
--- a/test/EFCore.SingleStore.FunctionalTests/AssemblyInfo.cs
+++ b/test/EFCore.SingleStore.FunctionalTests/AssemblyInfo.cs
@@ -1,5 +1,3 @@
-// #define FIXED_TEST_ORDER
-
 using Xunit;
 
 //
@@ -7,11 +5,11 @@
 //           This can be helpful for diffing etc.
 //
 
-#if FIXED_TEST_ORDER
+#if FIXED_TEST_ORDER || SPECIFIC_TEST_ORDER
 
 [assembly: CollectionBehavior(CollectionBehavior.CollectionPerAssembly, DisableTestParallelization = true, MaxParallelThreads = 1)]
-[assembly: TestCollectionOrderer("EntityFrameworkCore.SingleStore.FunctionalTests.TestUtilities.Xunit.SingleStoreTestCollectionOrderer", "EntityFrameworkCore.SingleStore.FunctionalTests")]
 [assembly: TestCaseOrderer("EntityFrameworkCore.SingleStore.FunctionalTests.TestUtilities.Xunit.SingleStoreTestCaseOrderer", "EntityFrameworkCore.SingleStore.FunctionalTests")]
+[assembly: TestCollectionOrderer("EntityFrameworkCore.SingleStore.FunctionalTests.TestUtilities.Xunit.SingleStoreTestCollectionOrderer", "EntityFrameworkCore.SingleStore.FunctionalTests")]
 
 #endif
 
diff --git a/test/EFCore.SingleStore.FunctionalTests/BadDataJsonDeserializationSingleStoreTest.cs b/test/EFCore.SingleStore.FunctionalTests/BadDataJsonDeserializationSingleStoreTest.cs
new file mode 100644
index 000000000..7a0651a76
--- /dev/null
+++ b/test/EFCore.SingleStore.FunctionalTests/BadDataJsonDeserializationSingleStoreTest.cs
@@ -0,0 +1,10 @@
+using Microsoft.EntityFrameworkCore;
+using EntityFrameworkCore.SingleStore.Tests;
+
+namespace EntityFrameworkCore.SingleStore.FunctionalTests;
+
+public class BadDataJsonDeserializationMySqlTest : BadDataJsonDeserializationTestBase
+{
+    protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
+        => base.OnConfiguring(optionsBuilder.UseSingleStore(b => b.UseNetTopologySuite()));
+}
diff --git a/test/EFCore.SingleStore.FunctionalTests/EFCore.SingleStore.FunctionalTests.csproj b/test/EFCore.SingleStore.FunctionalTests/EFCore.SingleStore.FunctionalTests.csproj
index 74b52e0e5..9d0e96969 100644
--- a/test/EFCore.SingleStore.FunctionalTests/EFCore.SingleStore.FunctionalTests.csproj
+++ b/test/EFCore.SingleStore.FunctionalTests/EFCore.SingleStore.FunctionalTests.csproj
@@ -8,9 +8,15 @@
     <DefaultItemExcludes>$(DefaultItemExcludes);*.trx</DefaultItemExcludes>
   </PropertyGroup>
 
+  <PropertyGroup>
+    <FixedTestOrder Condition="'$(FixedTestOrder)' == ''">false</FixedTestOrder>
+    <SpecificTestOrder Condition="'$(SpecificTestOrder)' == ''">false</SpecificTestOrder>
+  </PropertyGroup>
+ 
   <PropertyGroup>
     <MSBuildWarningsAsMessages>$(MSBuildWarningsAsMessages);$(NoWarn)</MSBuildWarningsAsMessages>
     <DefineConstants Condition="'$(FixedTestOrder)' == 'true'">$(DefineConstants);FIXED_TEST_ORDER</DefineConstants>
+    <DefineConstants Condition="'$(SpecificTestOrder)' == 'true'">$(DefineConstants);SPECIFIC_TEST_ORDER</DefineConstants>
   </PropertyGroup>
 
   <ItemGroup>
diff --git a/test/EFCore.SingleStore.FunctionalTests/MigrationsSingleStoreTest.cs b/test/EFCore.SingleStore.FunctionalTests/MigrationsSingleStoreTest.cs
index 7d8f2784f..4c556f36a 100644
--- a/test/EFCore.SingleStore.FunctionalTests/MigrationsSingleStoreTest.cs
+++ b/test/EFCore.SingleStore.FunctionalTests/MigrationsSingleStoreTest.cs
@@ -1,7 +1,6 @@
 using System;
 using System.Linq;
 using System.Threading.Tasks;
-using JetBrains.Annotations;
 using Microsoft.EntityFrameworkCore;
 using Microsoft.EntityFrameworkCore.Infrastructure;
 using Microsoft.EntityFrameworkCore.Metadata;
@@ -1394,6 +1393,10 @@ public override Task Rename_table()
                 },
                 withConventions: false);
 
+        // The constraint name for a primary key is always PRIMARY in MySQL.
+        protected override bool AssertConstraintNames
+            => false;
+
         protected virtual string DefaultCollation => ((SingleStoreTestStore)Fixture.TestStore).DatabaseCollation;
 
         protected override string NonDefaultCollation
diff --git a/test/EFCore.SingleStore.FunctionalTests/ProxyGraphUpdatesSingleStoreTest.cs b/test/EFCore.SingleStore.FunctionalTests/ProxyGraphUpdatesSingleStoreTest.cs
index 8c78cd258..edab7cad4 100644
--- a/test/EFCore.SingleStore.FunctionalTests/ProxyGraphUpdatesSingleStoreTest.cs
+++ b/test/EFCore.SingleStore.FunctionalTests/ProxyGraphUpdatesSingleStoreTest.cs
@@ -4,6 +4,7 @@
 using Microsoft.EntityFrameworkCore.TestUtilities;
 using Microsoft.Extensions.DependencyInjection;
 using EntityFrameworkCore.SingleStore.FunctionalTests.TestUtilities;
+using Xunit;
 
 namespace EntityFrameworkCore.SingleStore.FunctionalTests
 {
@@ -38,6 +39,12 @@ public LazyLoading(ProxyGraphUpdatesWithLazyLoadingSingleStoreFixture fixture)
             {
             }
 
+            // Used to track down a bug in Oracle's MySQL implementation, related to `SELECT ... ORDER BY (SELECT 1)`.
+            [Fact]
+            public void DummyTest()
+            {
+            }
+
             protected override bool DoesLazyLoading
                 => true;
 
diff --git a/test/EFCore.SingleStore.FunctionalTests/Query/GearsOfWarQuerySingleStoreTest.cs b/test/EFCore.SingleStore.FunctionalTests/Query/GearsOfWarQuerySingleStoreTest.cs
index 35df4d23d..82dc1d72d 100644
--- a/test/EFCore.SingleStore.FunctionalTests/Query/GearsOfWarQuerySingleStoreTest.cs
+++ b/test/EFCore.SingleStore.FunctionalTests/Query/GearsOfWarQuerySingleStoreTest.cs
@@ -563,5 +563,17 @@ await AssertQuery(
 WHERE EXTRACT(hour FROM `m`.`Timeline`) = 8
 """);
         }
+
+        [ConditionalTheory(Skip = "Feature 'Correlated subselect that can not be transformed and does not match on shard keys' is not supported by SingleStore Distributed.")]
+        public override async Task Nav_expansion_inside_Contains_argument(bool async)
+        {
+            await base.Nav_expansion_inside_Contains_argument(async);
+        }
+
+        [ConditionalTheory(Skip = "Feature 'Correlated subselect that can not be transformed and does not match on shard keys' is not supported by SingleStore Distributed.")]
+        public override async Task Nav_expansion_with_member_pushdown_inside_Contains_argument(bool async)
+        {
+            await base.Nav_expansion_with_member_pushdown_inside_Contains_argument(async);
+        }
     }
 }
diff --git a/test/EFCore.SingleStore.FunctionalTests/Query/NorthwindEFPropertyIncludeQuerySingleStoreTest.cs b/test/EFCore.SingleStore.FunctionalTests/Query/NorthwindEFPropertyIncludeQuerySingleStoreTest.cs
index b52dc5a60..fd1ca8390 100644
--- a/test/EFCore.SingleStore.FunctionalTests/Query/NorthwindEFPropertyIncludeQuerySingleStoreTest.cs
+++ b/test/EFCore.SingleStore.FunctionalTests/Query/NorthwindEFPropertyIncludeQuerySingleStoreTest.cs
@@ -1080,7 +1080,7 @@ LIMIT 18446744073709551610 OFFSET @__p_1
     SELECT `c`.`CustomerID`, `c`.`Address`, `c`.`City`, `c`.`CompanyName`, `c`.`ContactName`, `c`.`ContactTitle`, `c`.`Country`, `c`.`Fax`, `c`.`Phone`, `c`.`PostalCode`, `c`.`Region`, FALSE AS `c`
     FROM `Customers` AS `c`
     WHERE `c`.`CustomerID` LIKE 'A%'
-    ORDER BY (SELECT 1)
+    ORDER BY 1
     LIMIT 18446744073709551610 OFFSET @__p_1
 ) AS `t`
 LEFT JOIN `Orders` AS `o` ON `t`.`CustomerID` = `o`.`CustomerID`
@@ -2009,7 +2009,7 @@ LIMIT 18446744073709551610 OFFSET @__p_1
                     SELECT `c`.`CustomerID`, `c`.`Address`, `c`.`City`, `c`.`CompanyName`, `c`.`ContactName`, `c`.`ContactTitle`, `c`.`Country`, `c`.`Fax`, `c`.`Phone`, `c`.`PostalCode`, `c`.`Region`, TRUE AS `c`
                     FROM `Customers` AS `c`
                     WHERE `c`.`CustomerID` LIKE 'A%'
-                    ORDER BY (SELECT 1)
+                    ORDER BY 1
                     LIMIT 18446744073709551610 OFFSET @__p_1
                 ) AS `t`
                 LEFT JOIN `Orders` AS `o` ON `t`.`CustomerID` = `o`.`CustomerID`
diff --git a/test/EFCore.SingleStore.FunctionalTests/Query/NorthwindSplitIncludeNoTrackingQuerySingleStoreTest.cs b/test/EFCore.SingleStore.FunctionalTests/Query/NorthwindSplitIncludeNoTrackingQuerySingleStoreTest.cs
index 87ff1d597..2c0b38cf9 100644
--- a/test/EFCore.SingleStore.FunctionalTests/Query/NorthwindSplitIncludeNoTrackingQuerySingleStoreTest.cs
+++ b/test/EFCore.SingleStore.FunctionalTests/Query/NorthwindSplitIncludeNoTrackingQuerySingleStoreTest.cs
@@ -2,19 +2,23 @@
 using System.Threading.Tasks;
 using Microsoft.EntityFrameworkCore;
 using Microsoft.EntityFrameworkCore.Query;
+using Microsoft.EntityFrameworkCore.Storage;
 using Microsoft.EntityFrameworkCore.TestModels.Northwind;
 using Microsoft.EntityFrameworkCore.TestUtilities;
+using Microsoft.Extensions.DependencyInjection;
+using EntityFrameworkCore.SingleStore.FunctionalTests.TestUtilities.DebugServices;
 using Xunit;
 using Xunit.Abstractions;
 
 namespace EntityFrameworkCore.SingleStore.FunctionalTests.Query
 {
-    public class NorthwindSplitIncludeNoTrackingQuerySingleStoreTest : NorthwindSplitIncludeNoTrackingQueryTestBase<NorthwindQuerySingleStoreFixture<NoopModelCustomizer>>
+    // We use our custom fixture here, to inject a custom debug services.
+    public class NorthwindSplitIncludeNoTrackingQuerySingleStoreTest : NorthwindSplitIncludeNoTrackingQueryTestBase<NorthwindSplitIncludeNoTrackingQuerySingleStoreTest.NorthwindSplitIncludeNoTrackingQuerySingleStoreFixture>
     {
-        public NorthwindSplitIncludeNoTrackingQuerySingleStoreTest(NorthwindQuerySingleStoreFixture<NoopModelCustomizer> fixture, ITestOutputHelper testOutputHelper)
+        public NorthwindSplitIncludeNoTrackingQuerySingleStoreTest(NorthwindSplitIncludeNoTrackingQuerySingleStoreFixture fixture, ITestOutputHelper testOutputHelper)
             : base(fixture)
         {
-            //TestSqlLoggerFactory.CaptureOutput(testOutputHelper);
+            Fixture.TestSqlLoggerFactory.SetTestOutputHelper(testOutputHelper);
         }
 
         [ConditionalTheory(Skip = "SingleStore does not support this type of query: correlated subselect in ORDER BY")]
@@ -120,5 +124,14 @@ public override Task Include_duplicate_collection_result_operator(bool async)
         {
             return base.Include_duplicate_collection_result_operator(async);
         }
+
+        public class NorthwindSplitIncludeNoTrackingQuerySingleStoreFixture : NorthwindQuerySingleStoreFixture<NoopModelCustomizer>
+        {
+            // We used our `DebugRelationalCommandBuilderFactory` implementation to track down a
+            // bug in Oracle's MySQL implementation, related to `SELECT ... ORDER BY (SELECT 1)`.
+            protected override IServiceCollection AddServices(IServiceCollection serviceCollection)
+                => base.AddServices(serviceCollection)
+                    .AddSingleton<IRelationalCommandBuilderFactory, DebugRelationalCommandBuilderFactory>();
+        }
     }
 }
diff --git a/test/EFCore.SingleStore.FunctionalTests/Query/PrimitiveCollectionsQuerySingleStoreTest.cs b/test/EFCore.SingleStore.FunctionalTests/Query/PrimitiveCollectionsQuerySingleStoreTest.cs
index 02af71bf9..e5b5bbb98 100644
--- a/test/EFCore.SingleStore.FunctionalTests/Query/PrimitiveCollectionsQuerySingleStoreTest.cs
+++ b/test/EFCore.SingleStore.FunctionalTests/Query/PrimitiveCollectionsQuerySingleStoreTest.cs
@@ -1652,6 +1652,36 @@ public override async Task Column_collection_Concat_parameter_collection_equalit
         AssertSql();
     }
 
+    public override async Task Nested_contains_with_Lists_and_no_inferred_type_mapping(bool async)
+    {
+        await base.Nested_contains_with_Lists_and_no_inferred_type_mapping(async);
+
+        AssertSql(
+            """
+            SELECT `p`.`Id`, `p`.`Bool`, `p`.`Bools`, `p`.`DateTime`, `p`.`DateTimes`, `p`.`Enum`, `p`.`Enums`, `p`.`Int`, `p`.`Ints`, `p`.`NullableInt`, `p`.`NullableInts`, `p`.`NullableString`, `p`.`NullableStrings`, `p`.`String`, `p`.`Strings`
+            FROM `PrimitiveCollectionsEntity` AS `p`
+            WHERE CASE
+                WHEN `p`.`Int` IN (1, 2, 3) THEN 'one'
+                ELSE 'two'
+            END IN ('one', 'two', 'three')
+            """);
+    }
+
+    public override async Task Nested_contains_with_arrays_and_no_inferred_type_mapping(bool async)
+    {
+        await base.Nested_contains_with_arrays_and_no_inferred_type_mapping(async);
+
+        AssertSql(
+            """
+            SELECT `p`.`Id`, `p`.`Bool`, `p`.`Bools`, `p`.`DateTime`, `p`.`DateTimes`, `p`.`Enum`, `p`.`Enums`, `p`.`Int`, `p`.`Ints`, `p`.`NullableInt`, `p`.`NullableInts`, `p`.`NullableString`, `p`.`NullableStrings`, `p`.`String`, `p`.`Strings`
+            FROM `PrimitiveCollectionsEntity` AS `p`
+            WHERE CASE
+                WHEN `p`.`Int` IN (1, 2, 3) THEN 'one'
+                ELSE 'two'
+            END IN ('one', 'two', 'three')
+            """);
+    }
+
     [ConditionalFact]
     public virtual void Check_all_tests_overridden()
         => TestHelpers.AssertAllMethodsOverridden(GetType());
diff --git a/test/EFCore.SingleStore.FunctionalTests/Query/TPCGearsOfWarQuerySingleStoreTest.cs b/test/EFCore.SingleStore.FunctionalTests/Query/TPCGearsOfWarQuerySingleStoreTest.cs
index 2eef59dfc..04be62ec0 100644
--- a/test/EFCore.SingleStore.FunctionalTests/Query/TPCGearsOfWarQuerySingleStoreTest.cs
+++ b/test/EFCore.SingleStore.FunctionalTests/Query/TPCGearsOfWarQuerySingleStoreTest.cs
@@ -13330,6 +13330,90 @@ SELECT 1
 """);
     }
 
+    [ConditionalTheory(Skip = "Feature 'Correlated subselect that can not be transformed and does not match on shard keys' is not supported by SingleStore Distributed.")]
+    public override async Task Nav_expansion_inside_Contains_argument(bool async)
+    {
+        await base.Nav_expansion_inside_Contains_argument(async);
+
+        AssertSql(
+"""
+SELECT `t`.`Nickname`, `t`.`SquadId`, `t`.`AssignedCityName`, `t`.`CityOfBirthName`, `t`.`FullName`, `t`.`HasSoulPatch`, `t`.`LeaderNickname`, `t`.`LeaderSquadId`, `t`.`Rank`, `t`.`Discriminator`
+FROM (
+    SELECT `g`.`Nickname`, `g`.`SquadId`, `g`.`AssignedCityName`, `g`.`CityOfBirthName`, `g`.`FullName`, `g`.`HasSoulPatch`, `g`.`LeaderNickname`, `g`.`LeaderSquadId`, `g`.`Rank`, 'Gear' AS `Discriminator`
+    FROM `Gears` AS `g`
+    UNION ALL
+    SELECT `o`.`Nickname`, `o`.`SquadId`, `o`.`AssignedCityName`, `o`.`CityOfBirthName`, `o`.`FullName`, `o`.`HasSoulPatch`, `o`.`LeaderNickname`, `o`.`LeaderSquadId`, `o`.`Rank`, 'Officer' AS `Discriminator`
+    FROM `Officers` AS `o`
+) AS `t`
+WHERE CASE
+    WHEN EXISTS (
+        SELECT 1
+        FROM `Weapons` AS `w`
+        WHERE `t`.`FullName` = `w`.`OwnerFullName`) THEN 1
+    ELSE 0
+END IN (1, -1)
+""");
+    }
+
+    [ConditionalTheory(Skip = "Feature 'Correlated subselect that can not be transformed and does not match on shard keys' is not supported by SingleStore Distributed.")]
+    public override async Task Nav_expansion_with_member_pushdown_inside_Contains_argument(bool async)
+    {
+        await base.Nav_expansion_with_member_pushdown_inside_Contains_argument(async);
+
+        AssertSql(
+"""
+SELECT `t`.`Nickname`, `t`.`SquadId`, `t`.`AssignedCityName`, `t`.`CityOfBirthName`, `t`.`FullName`, `t`.`HasSoulPatch`, `t`.`LeaderNickname`, `t`.`LeaderSquadId`, `t`.`Rank`, `t`.`Discriminator`
+FROM (
+    SELECT `g`.`Nickname`, `g`.`SquadId`, `g`.`AssignedCityName`, `g`.`CityOfBirthName`, `g`.`FullName`, `g`.`HasSoulPatch`, `g`.`LeaderNickname`, `g`.`LeaderSquadId`, `g`.`Rank`, 'Gear' AS `Discriminator`
+    FROM `Gears` AS `g`
+    UNION ALL
+    SELECT `o`.`Nickname`, `o`.`SquadId`, `o`.`AssignedCityName`, `o`.`CityOfBirthName`, `o`.`FullName`, `o`.`HasSoulPatch`, `o`.`LeaderNickname`, `o`.`LeaderSquadId`, `o`.`Rank`, 'Officer' AS `Discriminator`
+    FROM `Officers` AS `o`
+) AS `t`
+WHERE (
+    SELECT `w`.`Name`
+    FROM `Weapons` AS `w`
+    WHERE `t`.`FullName` = `w`.`OwnerFullName`
+    ORDER BY `w`.`Id`
+    LIMIT 1) IN ('Marcus'' Lancer', 'Dom''s Gnasher')
+""");
+    }
+
+    public override async Task Subquery_inside_Take_argument(bool async)
+    {
+        await base.Subquery_inside_Take_argument(async);
+
+        AssertSql("");
+    }
+
+    public override async Task Nav_expansion_inside_Skip_correlated_to_source(bool async)
+    {
+        await base.Nav_expansion_inside_Skip_correlated_to_source(async);
+
+        AssertSql("");
+    }
+
+    public override async Task Nav_expansion_inside_Take_correlated_to_source(bool async)
+    {
+        await base.Nav_expansion_inside_Take_correlated_to_source(async);
+
+        AssertSql("");
+    }
+
+    public override async Task Nav_expansion_with_member_pushdown_inside_Take_correlated_to_source(bool async)
+    {
+        await base.Nav_expansion_with_member_pushdown_inside_Take_correlated_to_source(async);
+
+        AssertSql("");
+    }
+
+    public override async Task Nav_expansion_inside_ElementAt_correlated_to_source(bool async)
+    {
+        await base.Nav_expansion_inside_ElementAt_correlated_to_source(async);
+
+        AssertSql("");
+    }
+
     private void AssertSql(params string[] expected)
         => Fixture.TestSqlLoggerFactory.AssertBaseline(expected);
 }
diff --git a/test/EFCore.SingleStore.FunctionalTests/Query/TPTGearsOfWarQuerySingleStoreTest.cs b/test/EFCore.SingleStore.FunctionalTests/Query/TPTGearsOfWarQuerySingleStoreTest.cs
index 844134393..1169f7e96 100644
--- a/test/EFCore.SingleStore.FunctionalTests/Query/TPTGearsOfWarQuerySingleStoreTest.cs
+++ b/test/EFCore.SingleStore.FunctionalTests/Query/TPTGearsOfWarQuerySingleStoreTest.cs
@@ -523,6 +523,18 @@ WHERE EXTRACT(hour FROM `m`.`Timeline`) = 8
                 """);
         }
 
+        [ConditionalTheory(Skip = "Feature 'Correlated subselect that can not be transformed and does not match on shard keys' is not supported by SingleStore Distributed.")]
+        public override async Task Nav_expansion_inside_Contains_argument(bool async)
+        {
+            await base.Nav_expansion_inside_Contains_argument(async);
+        }
+
+        [ConditionalTheory(Skip = "Feature 'Correlated subselect that can not be transformed and does not match on shard keys' is not supported by SingleStore Distributed.")]
+        public override async Task Nav_expansion_with_member_pushdown_inside_Contains_argument(bool async)
+        {
+            await base.Nav_expansion_with_member_pushdown_inside_Contains_argument(async);
+        }
+
         private string AssertSql(string expected)
         {
             Fixture.TestSqlLoggerFactory.AssertBaseline(new[] {expected});
diff --git a/test/EFCore.SingleStore.FunctionalTests/TestUtilities/DebugServices/DebugRelationalCommand.cs b/test/EFCore.SingleStore.FunctionalTests/TestUtilities/DebugServices/DebugRelationalCommand.cs
new file mode 100644
index 000000000..d8ff3a926
--- /dev/null
+++ b/test/EFCore.SingleStore.FunctionalTests/TestUtilities/DebugServices/DebugRelationalCommand.cs
@@ -0,0 +1,19 @@
+using System.Collections.Generic;
+using JetBrains.Annotations;
+using Microsoft.EntityFrameworkCore.Storage;
+
+namespace EntityFrameworkCore.SingleStore.FunctionalTests.TestUtilities.DebugServices;
+
+public class DebugRelationalCommand : RelationalCommand
+{
+    public DebugRelationalCommand(
+        [NotNull] RelationalCommandBuilderDependencies dependencies,
+        [NotNull] string commandText,
+        [NotNull] IReadOnlyList<IRelationalParameter> parameters)
+        : base(dependencies, commandText, parameters)
+    {
+    }
+
+    protected override RelationalDataReader CreateRelationalDataReader()
+        => new DebugRelationalDataReader();
+}
diff --git a/test/EFCore.SingleStore.FunctionalTests/TestUtilities/DebugServices/DebugRelationalCommandBuilder.cs b/test/EFCore.SingleStore.FunctionalTests/TestUtilities/DebugServices/DebugRelationalCommandBuilder.cs
new file mode 100644
index 000000000..fbfee53b5
--- /dev/null
+++ b/test/EFCore.SingleStore.FunctionalTests/TestUtilities/DebugServices/DebugRelationalCommandBuilder.cs
@@ -0,0 +1,15 @@
+using JetBrains.Annotations;
+using Microsoft.EntityFrameworkCore.Storage;
+
+namespace EntityFrameworkCore.SingleStore.FunctionalTests.TestUtilities.DebugServices;
+
+public class DebugRelationalCommandBuilder : RelationalCommandBuilder
+{
+    public DebugRelationalCommandBuilder([NotNull] RelationalCommandBuilderDependencies dependencies)
+        : base(dependencies)
+    {
+    }
+
+    public override IRelationalCommand Build()
+        => new DebugRelationalCommand(Dependencies, base.Build().CommandText, Parameters);
+}
diff --git a/test/EFCore.SingleStore.FunctionalTests/TestUtilities/DebugServices/DebugRelationalCommandBuilderFactory.cs b/test/EFCore.SingleStore.FunctionalTests/TestUtilities/DebugServices/DebugRelationalCommandBuilderFactory.cs
new file mode 100644
index 000000000..fa583afe8
--- /dev/null
+++ b/test/EFCore.SingleStore.FunctionalTests/TestUtilities/DebugServices/DebugRelationalCommandBuilderFactory.cs
@@ -0,0 +1,15 @@
+using JetBrains.Annotations;
+using Microsoft.EntityFrameworkCore.Storage;
+
+namespace EntityFrameworkCore.SingleStore.FunctionalTests.TestUtilities.DebugServices;
+
+public class DebugRelationalCommandBuilderFactory : RelationalCommandBuilderFactory
+{
+    public DebugRelationalCommandBuilderFactory([NotNull] RelationalCommandBuilderDependencies dependencies)
+        : base(dependencies)
+    {
+    }
+
+    public override IRelationalCommandBuilder Create()
+        => new DebugRelationalCommandBuilder(Dependencies);
+}
diff --git a/test/EFCore.SingleStore.FunctionalTests/TestUtilities/DebugServices/DebugRelationalDataReader.cs b/test/EFCore.SingleStore.FunctionalTests/TestUtilities/DebugServices/DebugRelationalDataReader.cs
new file mode 100644
index 000000000..821bd48c4
--- /dev/null
+++ b/test/EFCore.SingleStore.FunctionalTests/TestUtilities/DebugServices/DebugRelationalDataReader.cs
@@ -0,0 +1,259 @@
+using System;
+using System.Collections;
+using System.Collections.ObjectModel;
+using System.Data;
+using System.Data.Common;
+using System.IO;
+using System.Linq;
+using System.Text;
+using System.Threading;
+using System.Threading.Tasks;
+using Microsoft.EntityFrameworkCore.Diagnostics;
+using Microsoft.EntityFrameworkCore.Storage;
+using Microsoft.Extensions.Logging;
+
+namespace EntityFrameworkCore.SingleStore.FunctionalTests.TestUtilities.DebugServices;
+
+public class DebugRelationalDataReader : RelationalDataReader
+{
+    private DebugDbDataReader _dataReaderWrapper;
+
+    public override void Initialize(
+        IRelationalConnection relationalConnection,
+        DbCommand command,
+        DbDataReader reader,
+        Guid commandId,
+        IRelationalCommandDiagnosticsLogger logger)
+    {
+        _dataReaderWrapper?.Dispose();
+        _dataReaderWrapper = new DebugDbDataReader(reader, commandId, logger!.Logger);
+
+        base.Initialize(relationalConnection, command, _dataReaderWrapper, commandId, logger);
+    }
+
+    public override void Dispose()
+    {
+        _dataReaderWrapper.Dispose();
+
+        base.Dispose();
+    }
+
+    public override async ValueTask DisposeAsync()
+    {
+        await _dataReaderWrapper.DisposeAsync();
+
+        await base.DisposeAsync();
+    }
+}
+
+public class DebugDbDataReader : DbDataReader, IDisposable
+{
+    private readonly DbDataReader _implementation;
+    private readonly ILogger _logger;
+    private readonly StringBuilder _stringBuilder;
+    private bool _isClosed;
+
+    public DebugDbDataReader(DbDataReader implementation, Guid commandId, ILogger logger)
+    {
+        _implementation = implementation;
+        _logger = logger;
+        _stringBuilder = new StringBuilder();
+
+        _stringBuilder.AppendLine($"DebugRelationalDataReader for Command {commandId}:");
+        _stringBuilder.AppendLine(string.Join("\t", Enumerable.Range(0, _implementation.FieldCount).Select(f => _implementation.GetName(f))));
+    }
+
+    public override bool Read()
+    {
+        var result = _implementation.Read();
+
+        if (result)
+        {
+            _stringBuilder.AppendLine(string.Join("\t", Enumerable.Range(0, _implementation.FieldCount).Select(f => _implementation.GetValue(f)?.ToString())));
+        }
+
+        return result;
+    }
+
+    public override async Task<bool> ReadAsync(CancellationToken cancellationToken)
+    {
+        var result = await _implementation.ReadAsync(cancellationToken);
+
+        if (result)
+        {
+            _stringBuilder.AppendLine(string.Join("\t", Enumerable.Range(0, _implementation.FieldCount).Select(f => _implementation.GetValue(f)?.ToString())));
+        }
+
+        return result;
+    }
+
+    public override void Close()
+    {
+        if (!_isClosed)
+        {
+            _logger.LogInformation(_stringBuilder.ToString());
+            _isClosed = true;
+        }
+
+        _implementation.Close();
+    }
+
+    public override Task CloseAsync()
+    {
+        if (!_isClosed)
+        {
+            _logger.LogInformation(_stringBuilder.ToString());
+            _isClosed = true;
+        }
+
+        return _implementation.CloseAsync();
+    }
+
+    #region Delegated
+
+    void IDisposable.Dispose()
+        => _implementation.Dispose();
+
+    public override ValueTask DisposeAsync()
+        => _implementation.DisposeAsync();
+
+    public override Task<T> GetFieldValueAsync<T>(int ordinal, CancellationToken cancellationToken)
+        => _implementation.GetFieldValueAsync<T>(ordinal, cancellationToken);
+
+    public override T GetFieldValue<T>(int ordinal)
+        => _implementation.GetFieldValue<T>(ordinal);
+
+    public override Type GetProviderSpecificFieldType(int ordinal)
+        => _implementation.GetProviderSpecificFieldType(ordinal);
+
+    public override object GetProviderSpecificValue(int ordinal)
+        => _implementation.GetProviderSpecificValue(ordinal);
+
+    public override int GetProviderSpecificValues(object[] values)
+        => _implementation.GetProviderSpecificValues(values);
+
+    public override DataTable GetSchemaTable()
+        => _implementation.GetSchemaTable();
+
+    public override Task<DataTable> GetSchemaTableAsync(CancellationToken cancellationToken = new CancellationToken())
+        => _implementation.GetSchemaTableAsync(cancellationToken);
+
+    public override Task<ReadOnlyCollection<DbColumn>> GetColumnSchemaAsync(CancellationToken cancellationToken = new CancellationToken())
+        => _implementation.GetColumnSchemaAsync(cancellationToken);
+
+    public override Stream GetStream(int ordinal)
+        => _implementation.GetStream(ordinal);
+
+    public override TextReader GetTextReader(int ordinal)
+        => _implementation.GetTextReader(ordinal);
+
+    public override Task<bool> IsDBNullAsync(int ordinal, CancellationToken cancellationToken)
+        => _implementation.IsDBNullAsync(ordinal, cancellationToken);
+
+    public override Task<bool> NextResultAsync(CancellationToken cancellationToken)
+        => _implementation.NextResultAsync(cancellationToken);
+
+    public override int VisibleFieldCount
+        => _implementation.VisibleFieldCount;
+
+    public override bool Equals(object obj)
+        => _implementation.Equals(obj);
+
+    public override int GetHashCode()
+        => _implementation.GetHashCode();
+
+    public override string ToString()
+        => _implementation.ToString();
+
+    public override bool GetBoolean(int ordinal)
+        => _implementation.GetBoolean(ordinal);
+
+    public override byte GetByte(int ordinal)
+        => _implementation.GetByte(ordinal);
+
+    public override long GetBytes(int ordinal, long dataOffset, byte[] buffer, int bufferOffset, int length)
+        => _implementation.GetBytes(ordinal, dataOffset, buffer, bufferOffset, length);
+
+    public override char GetChar(int ordinal)
+        => _implementation.GetChar(ordinal);
+
+    public override long GetChars(int ordinal, long dataOffset, char[] buffer, int bufferOffset, int length)
+        => _implementation.GetChars(ordinal, dataOffset, buffer, bufferOffset, length);
+
+    public override string GetDataTypeName(int ordinal)
+        => _implementation.GetDataTypeName(ordinal);
+
+    public override DateTime GetDateTime(int ordinal)
+        => _implementation.GetDateTime(ordinal);
+
+    public override decimal GetDecimal(int ordinal)
+        => _implementation.GetDecimal(ordinal);
+
+    public override double GetDouble(int ordinal)
+        => _implementation.GetDouble(ordinal);
+
+    public override Type GetFieldType(int ordinal)
+        => _implementation.GetFieldType(ordinal);
+
+    public override float GetFloat(int ordinal)
+        => _implementation.GetFloat(ordinal);
+
+    public override Guid GetGuid(int ordinal)
+        => _implementation.GetGuid(ordinal);
+
+    public override short GetInt16(int ordinal)
+        => _implementation.GetInt16(ordinal);
+
+    public override int GetInt32(int ordinal)
+        => _implementation.GetInt32(ordinal);
+
+    public override long GetInt64(int ordinal)
+        => _implementation.GetInt64(ordinal);
+
+    public override string GetName(int ordinal)
+        => _implementation.GetName(ordinal);
+
+    public override int GetOrdinal(string name)
+        => _implementation.GetOrdinal(name);
+
+    public override string GetString(int ordinal)
+        => _implementation.GetString(ordinal);
+
+    public override object GetValue(int ordinal)
+        => _implementation.GetValue(ordinal);
+
+    public override int GetValues(object[] values)
+        => _implementation.GetValues(values);
+
+    public override bool IsDBNull(int ordinal)
+        => _implementation.IsDBNull(ordinal);
+
+    public override int FieldCount
+        => _implementation.FieldCount;
+
+    public override object this[int ordinal]
+        => _implementation[ordinal];
+
+    public override object this[string name]
+        => _implementation[name];
+
+    public override int RecordsAffected
+        => _implementation.RecordsAffected;
+
+    public override bool HasRows
+        => _implementation.HasRows;
+
+    public override bool IsClosed
+        => _implementation.IsClosed;
+
+    public override bool NextResult()
+        => _implementation.NextResult();
+
+    public override int Depth
+        => _implementation.Depth;
+
+    public override IEnumerator GetEnumerator()
+        => _implementation.GetEnumerator();
+
+    #endregion Delegated
+}
diff --git a/test/EFCore.SingleStore.FunctionalTests/TestUtilities/SingleStoreNorthwindTestStoreFactory.cs b/test/EFCore.SingleStore.FunctionalTests/TestUtilities/SingleStoreNorthwindTestStoreFactory.cs
index b4a3b4519..39d298784 100644
--- a/test/EFCore.SingleStore.FunctionalTests/TestUtilities/SingleStoreNorthwindTestStoreFactory.cs
+++ b/test/EFCore.SingleStore.FunctionalTests/TestUtilities/SingleStoreNorthwindTestStoreFactory.cs
@@ -5,11 +5,11 @@ namespace EntityFrameworkCore.SingleStore.FunctionalTests.TestUtilities
 {
     public class SingleStoreNorthwindTestStoreFactory : SingleStoreTestStoreFactory
     {
-        public const string DefaultName = "Northwind";
+        public const string DefaultNamePrefix = "Northwind";
 
         public static new SingleStoreNorthwindTestStoreFactory Instance => InstanceCi;
-        public static SingleStoreNorthwindTestStoreFactory InstanceCi { get; } = new SingleStoreNorthwindTestStoreFactory(databaseCollation: AppConfig.ServerVersion.DefaultUtf8CiCollation);
-        public static SingleStoreNorthwindTestStoreFactory InstanceCs { get; } = new SingleStoreNorthwindTestStoreFactory(databaseCollation: AppConfig.ServerVersion.DefaultUtf8CsCollation);
+        public static new SingleStoreNorthwindTestStoreFactory InstanceCi { get; } = new SingleStoreNorthwindTestStoreFactory(databaseCollation: AppConfig.ServerVersion.DefaultUtf8CiCollation);
+        public static new SingleStoreNorthwindTestStoreFactory InstanceCs { get; } = new SingleStoreNorthwindTestStoreFactory(databaseCollation: AppConfig.ServerVersion.DefaultUtf8CsCollation);
         public static new SingleStoreNorthwindTestStoreFactory NoBackslashEscapesInstance { get; } = new SingleStoreNorthwindTestStoreFactory(true);
 
         protected SingleStoreNorthwindTestStoreFactory(bool noBackslashEscapes = false, string databaseCollation = null)
@@ -18,6 +18,6 @@ protected SingleStoreNorthwindTestStoreFactory(bool noBackslashEscapes = false,
         }
 
         public override TestStore GetOrCreate(string storeName)
-            => SingleStoreTestStore.GetOrCreate(storeName ?? DefaultName, "Northwind.sql", noBackslashEscapes: NoBackslashEscapes, databaseCollation: DatabaseCollation);
+            => SingleStoreTestStore.GetOrCreate(storeName ?? $"{DefaultNamePrefix}__{DatabaseCollation}", "Northwind.sql", noBackslashEscapes: NoBackslashEscapes, databaseCollation: DatabaseCollation);
     }
 }
diff --git a/test/EFCore.SingleStore.FunctionalTests/TestUtilities/SingleStoreTestStoreFactory.cs b/test/EFCore.SingleStore.FunctionalTests/TestUtilities/SingleStoreTestStoreFactory.cs
index 9a3473bb0..32d47c6aa 100644
--- a/test/EFCore.SingleStore.FunctionalTests/TestUtilities/SingleStoreTestStoreFactory.cs
+++ b/test/EFCore.SingleStore.FunctionalTests/TestUtilities/SingleStoreTestStoreFactory.cs
@@ -1,12 +1,16 @@
 using Microsoft.EntityFrameworkCore.TestUtilities;
 using Microsoft.Extensions.DependencyInjection;
 using SingleStoreConnector;
+using EntityFrameworkCore.SingleStore.Tests;
 
 namespace EntityFrameworkCore.SingleStore.FunctionalTests.TestUtilities
 {
     public class SingleStoreTestStoreFactory : RelationalTestStoreFactory
     {
-        public static SingleStoreTestStoreFactory Instance { get; } = new SingleStoreTestStoreFactory();
+        public static SingleStoreTestStoreFactory Instance => InstanceCi;
+        public static SingleStoreTestStoreFactory InstanceCi { get; } = new SingleStoreTestStoreFactory(databaseCollation: AppConfig.ServerVersion.DefaultUtf8CiCollation);
+        public static SingleStoreTestStoreFactory InstanceCs { get; } = new SingleStoreTestStoreFactory(databaseCollation: AppConfig.ServerVersion.DefaultUtf8CsCollation);
+
         public static SingleStoreTestStoreFactory NoBackslashEscapesInstance { get; } = new SingleStoreTestStoreFactory(noBackslashEscapes: true);
         public static SingleStoreTestStoreFactory GuidBinary16Instance { get; } = new SingleStoreTestStoreFactory(guidFormat: SingleStoreGuidFormat.Binary16);
 
diff --git a/test/EFCore.SingleStore.FunctionalTests/TestUtilities/Xunit/ISingleStoreTestClassOrderer.cs b/test/EFCore.SingleStore.FunctionalTests/TestUtilities/Xunit/ISingleStoreTestClassOrderer.cs
new file mode 100644
index 000000000..90627031b
--- /dev/null
+++ b/test/EFCore.SingleStore.FunctionalTests/TestUtilities/Xunit/ISingleStoreTestClassOrderer.cs
@@ -0,0 +1,9 @@
+using System.Collections.Generic;
+using Xunit.Abstractions;
+
+namespace EntityFrameworkCore.SingleStore.FunctionalTests.TestUtilities.Xunit;
+
+public interface ISingleStoreTestClassOrderer
+{
+    IEnumerable<ITestClass> OrderTestClasses(IEnumerable<ITestClass> testClasses);
+}
diff --git a/test/EFCore.SingleStore.FunctionalTests/TestUtilities/Xunit/SingleStoreTestCaseOrderer.cs b/test/EFCore.SingleStore.FunctionalTests/TestUtilities/Xunit/SingleStoreTestCaseOrderer.cs
index a12561cb6..50783cb1f 100644
--- a/test/EFCore.SingleStore.FunctionalTests/TestUtilities/Xunit/SingleStoreTestCaseOrderer.cs
+++ b/test/EFCore.SingleStore.FunctionalTests/TestUtilities/Xunit/SingleStoreTestCaseOrderer.cs
@@ -1,15 +1,51 @@
 using System;
 using System.Collections.Generic;
+using System.IO;
 using System.Linq;
+using System.Text.RegularExpressions;
 using Xunit.Abstractions;
 using Xunit.Sdk;
 
 namespace EntityFrameworkCore.SingleStore.FunctionalTests.TestUtilities.Xunit
 {
-    public class SingleStoreTestCaseOrderer : ITestCaseOrderer
+    public class SingleStoreTestCaseOrderer : ITestCaseOrderer, ISingleStoreTestClassOrderer
     {
+#if SPECIFIC_TEST_ORDER
+        private static readonly bool _isSpecificTestCaseOrderingEnabled = true;
+#else
+        private static readonly bool _isSpecificTestCaseOrderingEnabled = false;
+#endif
+
+        private static string[] _specificTestCaseDisplayNamesInOrder;
+        public static string[] SpecificTestCaseDisplayNamesInOrder
+            => _specificTestCaseDisplayNamesInOrder ??= _isSpecificTestCaseOrderingEnabled &&
+                                                        Path.GetFullPath(@"..\..\..\TestResults\SpecificTestOrder.txt") is var path &&
+                                                        File.Exists(path)
+                ? File.ReadLines(path)
+                    .Select(s => Regex.Match(s, @"^(?:\W*)([^\u200B]+)").Groups[1].Value)
+                    .Where(s => !string.IsNullOrEmpty(s))
+                    .Distinct()
+                    .ToArray()
+                : [];
+
+        private readonly Dictionary<string, int> _specificTestCaseDisplayNamesWithIndex;
+
+        public SingleStoreTestCaseOrderer()
+        {
+            _specificTestCaseDisplayNamesWithIndex = SpecificTestCaseDisplayNamesInOrder
+                .Select((s, i) => (s, i))
+                .ToDictionary(t => t.s, t => t.i);
+        }
+
         public IEnumerable<TTestCase> OrderTestCases<TTestCase>(IEnumerable<TTestCase> testCases)
             where TTestCase : ITestCase
-            => testCases.OrderBy(c => c.TestMethod.Method.Name, StringComparer.OrdinalIgnoreCase);
+            => testCases
+                .OrderBy(c => _specificTestCaseDisplayNamesWithIndex.GetValueOrDefault(c.DisplayName, int.MaxValue))
+                .ThenBy(c => c.DisplayName, StringComparer.OrdinalIgnoreCase)
+                .ThenBy(c => c.DisplayName, StringComparer.Ordinal)
+                .ThenBy(c => c.UniqueID);
+
+        public IEnumerable<ITestClass> OrderTestClasses(IEnumerable<ITestClass> testClasses)
+            => testClasses.OrderBy(c => c.Class.Name);
     }
 }
diff --git a/test/EFCore.SingleStore.FunctionalTests/TestUtilities/Xunit/SingleStoreTestCollectionOrderer.cs b/test/EFCore.SingleStore.FunctionalTests/TestUtilities/Xunit/SingleStoreTestCollectionOrderer.cs
index 53c3d3c97..550282207 100644
--- a/test/EFCore.SingleStore.FunctionalTests/TestUtilities/Xunit/SingleStoreTestCollectionOrderer.cs
+++ b/test/EFCore.SingleStore.FunctionalTests/TestUtilities/Xunit/SingleStoreTestCollectionOrderer.cs
@@ -9,6 +9,9 @@ namespace EntityFrameworkCore.SingleStore.FunctionalTests.TestUtilities.Xunit
     public class SingleStoreTestCollectionOrderer : ITestCollectionOrderer
     {
         public IEnumerable<ITestCollection> OrderTestCollections(IEnumerable<ITestCollection> testCollections)
-            => testCollections.OrderBy(c => c.DisplayName, StringComparer.OrdinalIgnoreCase);
+            => testCollections
+                .OrderBy(c => c.DisplayName, StringComparer.OrdinalIgnoreCase)
+                .ThenBy(c => c.DisplayName, StringComparer.Ordinal)
+                .ThenBy(c => c.UniqueID);
     }
 }
diff --git a/test/EFCore.SingleStore.FunctionalTests/TestUtilities/Xunit/SingleStoreXunitTestAssemblyRunner.cs b/test/EFCore.SingleStore.FunctionalTests/TestUtilities/Xunit/SingleStoreXunitTestAssemblyRunner.cs
new file mode 100644
index 000000000..91cd16dbe
--- /dev/null
+++ b/test/EFCore.SingleStore.FunctionalTests/TestUtilities/Xunit/SingleStoreXunitTestAssemblyRunner.cs
@@ -0,0 +1,34 @@
+using System.Collections.Generic;
+using System.Threading;
+using System.Threading.Tasks;
+using Xunit.Abstractions;
+using Xunit.Sdk;
+
+namespace EntityFrameworkCore.SingleStore.FunctionalTests.TestUtilities.Xunit;
+
+public class SingleStoreXunitTestAssemblyRunner : XunitTestAssemblyRunner
+{
+    public SingleStoreXunitTestAssemblyRunner(
+        ITestAssembly testAssembly,
+        IEnumerable<IXunitTestCase> testCases,
+        IMessageSink diagnosticMessageSink,
+        IMessageSink executionMessageSink,
+        ITestFrameworkExecutionOptions executionOptions)
+        : base(testAssembly, testCases, diagnosticMessageSink, executionMessageSink, executionOptions)
+    {
+    }
+
+    protected override Task<RunSummary> RunTestCollectionAsync(
+        IMessageBus messageBus,
+        ITestCollection testCollection,
+        IEnumerable<IXunitTestCase> testCases,
+        CancellationTokenSource cancellationTokenSource)
+        => new SingleStoreXunitTestCollectionRunner(
+            testCollection,
+            testCases,
+            DiagnosticMessageSink,
+            messageBus,
+            TestCaseOrderer,
+            new ExceptionAggregator(Aggregator),
+            cancellationTokenSource).RunAsync();
+}
diff --git a/test/EFCore.SingleStore.FunctionalTests/TestUtilities/Xunit/SingleStoreXunitTestCollectionRunner.cs b/test/EFCore.SingleStore.FunctionalTests/TestUtilities/Xunit/SingleStoreXunitTestCollectionRunner.cs
new file mode 100644
index 000000000..9b9d8e1a0
--- /dev/null
+++ b/test/EFCore.SingleStore.FunctionalTests/TestUtilities/Xunit/SingleStoreXunitTestCollectionRunner.cs
@@ -0,0 +1,51 @@
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using Xunit.Abstractions;
+using Xunit.Sdk;
+
+namespace EntityFrameworkCore.SingleStore.FunctionalTests.TestUtilities.Xunit;
+
+public class SingleStoreXunitTestCollectionRunner : XunitTestCollectionRunner
+{
+    public SingleStoreXunitTestCollectionRunner(
+        ITestCollection testCollection,
+        IEnumerable<IXunitTestCase> testCases,
+        IMessageSink diagnosticMessageSink,
+        IMessageBus messageBus,
+        ITestCaseOrderer testCaseOrderer,
+        ExceptionAggregator aggregator,
+        CancellationTokenSource cancellationTokenSource)
+        : base(testCollection, testCases, diagnosticMessageSink, messageBus, testCaseOrderer, aggregator, cancellationTokenSource)
+    {
+    }
+
+    protected override async Task<RunSummary> RunTestClassesAsync()
+    {
+        var summary = new RunSummary();
+
+        var testsGroupedByClass = TestCases.GroupBy(tc => tc.TestMethod.TestClass, TestClassComparer.Instance);
+
+        // Explicitly order test classes.
+        if (TestCaseOrderer is ISingleStoreTestClassOrderer testClassOrderer)
+        {
+            var testClassesWithIndex = testClassOrderer
+                .OrderTestClasses(testsGroupedByClass.Select(g => g.Key))
+                .Select((s, i) => (s, i))
+                .ToDictionary(t => t.s, t => t.i);
+
+            testsGroupedByClass = testsGroupedByClass
+                .OrderBy(g => testClassesWithIndex.GetValueOrDefault(g.Key, int.MaxValue));
+        }
+
+        foreach (var testCasesByClass in testsGroupedByClass)
+        {
+            summary.Aggregate(await RunTestClassAsync(testCasesByClass.Key, (IReflectionTypeInfo)testCasesByClass.Key.Class, testCasesByClass));
+            if (CancellationTokenSource.IsCancellationRequested)
+                break;
+        }
+
+        return summary;
+    }
+}
diff --git a/test/EFCore.SingleStore.FunctionalTests/TestUtilities/Xunit/SingleStoreXunitTestFramework.cs b/test/EFCore.SingleStore.FunctionalTests/TestUtilities/Xunit/SingleStoreXunitTestFramework.cs
index f2e78ebd7..17e6d0d58 100644
--- a/test/EFCore.SingleStore.FunctionalTests/TestUtilities/Xunit/SingleStoreXunitTestFramework.cs
+++ b/test/EFCore.SingleStore.FunctionalTests/TestUtilities/Xunit/SingleStoreXunitTestFramework.cs
@@ -1,4 +1,6 @@
-using Xunit.Abstractions;
+using System;
+using System.Reflection;
+using Xunit.Abstractions;
 using Xunit.Sdk;
 
 namespace EntityFrameworkCore.SingleStore.FunctionalTests.TestUtilities.Xunit
@@ -11,5 +13,8 @@ public SingleStoreXunitTestFramework(IMessageSink messageSink) : base(messageSin
 
         protected override ITestFrameworkDiscoverer CreateDiscoverer(IAssemblyInfo assemblyInfo)
             => new SingleStoreXunitTestFrameworkDiscoverer(assemblyInfo, SourceInformationProvider, DiagnosticMessageSink);
+
+        protected override ITestFrameworkExecutor CreateExecutor(AssemblyName assemblyName)
+            => new SingleStoreXunitTestFrameworkExecutor(assemblyName, SourceInformationProvider, DiagnosticMessageSink);
     }
 }
diff --git a/test/EFCore.SingleStore.FunctionalTests/TestUtilities/Xunit/SingleStoreXunitTestFrameworkDiscoverer.cs b/test/EFCore.SingleStore.FunctionalTests/TestUtilities/Xunit/SingleStoreXunitTestFrameworkDiscoverer.cs
index 64fb71b64..6f426e39b 100644
--- a/test/EFCore.SingleStore.FunctionalTests/TestUtilities/Xunit/SingleStoreXunitTestFrameworkDiscoverer.cs
+++ b/test/EFCore.SingleStore.FunctionalTests/TestUtilities/Xunit/SingleStoreXunitTestFrameworkDiscoverer.cs
@@ -39,5 +39,56 @@ protected virtual IEnumerable<ITestCondition> GetTestConditions<TType>(ITypeInfo
             => type.GetCustomAttributes(typeof(TType))
                 .Select(attribute => (TType)Activator.CreateInstance(typeof(TType), attribute.GetConstructorArguments().ToArray()))
                 .Cast<ITestCondition>();
+
+        protected override bool FindTestsForMethod(
+            ITestMethod testMethod,
+            bool includeSourceInformation,
+            IMessageBus messageBus,
+            ITestFrameworkDiscoveryOptions discoveryOptions)
+            => base.FindTestsForMethod(
+                testMethod,
+                includeSourceInformation,
+                new FindTestsForMethodMessageBus(messageBus),
+                discoveryOptions);
+
+        private class FindTestsForMethodMessageBus : IMessageBus
+        {
+            private readonly IMessageBus _messageBus;
+            private static readonly HashSet<string> _testCaseDisplayNamesInOrder = SingleStoreTestCaseOrderer.SpecificTestCaseDisplayNamesInOrder.ToHashSet();
+
+            public FindTestsForMethodMessageBus(IMessageBus messageBus)
+                => _messageBus = messageBus;
+
+            public void Dispose()
+                => _messageBus.Dispose();
+
+            public bool QueueMessage(IMessageSinkMessage message)
+            {
+                // Intercept TestCaseDiscoveryMessage messages to filter specific test cases independent of the discoverer, so we can filter
+                // all test cases and not just the ones for which we specify our own discoverers.
+                if (_testCaseDisplayNamesInOrder.Count > 0 &&
+                    message is TestCaseDiscoveryMessage testCaseDiscoveryMessage)
+                {
+                    var displayName = GetFullyQualifiedDisplayName(testCaseDiscoveryMessage.TestCase);
+
+                    if (!_testCaseDisplayNamesInOrder.Contains(displayName))
+                    {
+                        return true;
+                    }
+                }
+
+                return _messageBus.QueueMessage(message);
+            }
+
+            private static string GetFullyQualifiedDisplayName(ITestCase testCase)
+            {
+                var className = testCase.TestMethod.TestClass.Class.Name;
+                var displayName = testCase.DisplayName;
+
+                return !displayName.StartsWith(className)
+                    ? $"{className}.{displayName}"
+                    : displayName;
+            }
+        }
     }
 }
diff --git a/test/EFCore.SingleStore.FunctionalTests/TestUtilities/Xunit/SingleStoreXunitTestFrameworkExecutor.cs b/test/EFCore.SingleStore.FunctionalTests/TestUtilities/Xunit/SingleStoreXunitTestFrameworkExecutor.cs
new file mode 100644
index 000000000..c71ad0d63
--- /dev/null
+++ b/test/EFCore.SingleStore.FunctionalTests/TestUtilities/Xunit/SingleStoreXunitTestFrameworkExecutor.cs
@@ -0,0 +1,31 @@
+using System.Collections.Generic;
+using System.Reflection;
+using Xunit.Abstractions;
+using Xunit.Sdk;
+
+namespace EntityFrameworkCore.SingleStore.FunctionalTests.TestUtilities.Xunit;
+
+public class SingleStoreXunitTestFrameworkExecutor : XunitTestFrameworkExecutor
+{
+    public SingleStoreXunitTestFrameworkExecutor(
+        AssemblyName assemblyName,
+        ISourceInformationProvider sourceInformationProvider,
+        IMessageSink diagnosticMessageSink)
+        : base(assemblyName, sourceInformationProvider, diagnosticMessageSink)
+    {
+    }
+
+    protected override async void RunTestCases(
+        IEnumerable<IXunitTestCase> testCases,
+        IMessageSink executionMessageSink,
+        ITestFrameworkExecutionOptions executionOptions)
+    {
+        using var assemblyRunner = new SingleStoreXunitTestAssemblyRunner(
+            TestAssembly,
+            testCases,
+            DiagnosticMessageSink,
+            executionMessageSink,
+            executionOptions);
+        await assemblyRunner.RunAsync();
+    }
+}
diff --git a/test/EFCore.SingleStore.FunctionalTests/TransactionSingleStoreTest.cs b/test/EFCore.SingleStore.FunctionalTests/TransactionSingleStoreTest.cs
index 6c52f7b53..b432ee340 100644
--- a/test/EFCore.SingleStore.FunctionalTests/TransactionSingleStoreTest.cs
+++ b/test/EFCore.SingleStore.FunctionalTests/TransactionSingleStoreTest.cs
@@ -19,9 +19,8 @@ public TransactionSingleStoreTest(TransactionSingleStoreFixture fixture)
         {
         }
 
-        protected override bool SnapshotSupported => false;
+        protected override bool SnapshotSupported => true;
         protected override bool AmbientTransactionsSupported => true;
-        protected override bool DirtyReadsOccur => false;
 
         protected override bool SavepointsSupported => false;
 
@@ -55,6 +54,18 @@ public override void EnlistTransaction_throws_if_ambient_transaction_started()
             base.EnlistTransaction_throws_if_ambient_transaction_started();
         }
 
+        [ConditionalTheory(Skip = "IsolationLevel.ReadUncommitted is not supported by SingleStore Distributed.")]
+        public override void Query_uses_explicit_transaction(AutoTransactionBehavior autoTransactionBehavior)
+        {
+            base.Query_uses_explicit_transaction(autoTransactionBehavior);
+        }
+
+        [ConditionalTheory(Skip = "IsolationLevel.ReadUncommitted is not supported by SingleStore Distributed.")]
+        public override async Task QueryAsync_uses_explicit_transaction(AutoTransactionBehavior autoTransactionBehavior)
+        {
+            await base.QueryAsync_uses_explicit_transaction(autoTransactionBehavior);
+        }
+
         protected override DbContext CreateContextWithConnectionString()
         {
             var options = Fixture.AddOptions(
diff --git a/tools/QueryBaselineUpdater/Program.cs b/tools/QueryBaselineUpdater/Program.cs
index ddae2ae00..bf1e167cb 100644
--- a/tools/QueryBaselineUpdater/Program.cs
+++ b/tools/QueryBaselineUpdater/Program.cs
@@ -1,4 +1,5 @@
 using System;
+using System.Collections.Generic;
 using System.IO;
 using System.Linq;
 using System.Text.RegularExpressions;
@@ -7,53 +8,142 @@ namespace QueryBaselineUpdater
 {
     internal static class Program
     {
-        private static void Main(string[] args)
-        {
-            const string assertSqlPattern = @"\s*Assert(?:ExecuteUpdate)?Sql\(\s*(?:(?:@?(""""""|"")).*?\1)?\);\r?\n";
+        private const string AssertSqlPattern = @"\s*Assert(?:ExecuteUpdate)?Sql\(\s*(?:(?:@?(""""""|"")).*?\1)?\);\r?\n";
 
+        private static int Main(string[] args)
+        {
             var queryBaselineFilePath = args[0];
-            var testFilePath = args[1];
-
-            File.WriteAllText(
-                testFilePath,
-                Regex.Matches(
-                        File.ReadAllText(queryBaselineFilePath),
-                        $@"(?:^|\n)(?<Name>(?:Pomelo|EntityFrameworkCore|Microsoft)[^\r\n]*)\([^\r\n]*\) : (?<Line>\d+)\r?\n(?<AssertSql>{assertSqlPattern})\r?\n(?<Truncated>Output truncated.)?\r?\n--------------------(?=\r?\n)",
-                        RegexOptions.IgnoreCase | RegexOptions.Singleline)
-                    .Select(
-                        match => new
-                        {
-                            Line = int.Parse(match.Groups["Line"].Value),
-                            Name = match.Groups["Name"].Value,
-                            AssertSql = match.Groups["AssertSql"].Value,
-                            Truncated = match.Groups["Truncated"].Success,
-                        })
-                    .GroupBy(t => t.Line)
-                    .Select(g => g.First())
-                    .OrderByDescending(t => t.Line)
-                    .Aggregate(
-                        File.ReadAllText(testFilePath),
-                        (current, next) =>
-                        {
-                            var lines = Regex.Split(current, @"\r?\n");
-                            var before = lines.Take(next.Line - 1);
-                            var remaining = lines.Skip(next.Line - 1);
-                            var replaced = Regex.Split(
-                                Regex.Replace(
-                                    string.Join(Environment.NewLine, remaining),
-                                    $"^{assertSqlPattern}",
-                                    next.AssertSql,
-                                    RegexOptions.IgnoreCase | RegexOptions.Singleline),
-                                @"\r?\n")
-                                .AsEnumerable();
-
-                            if (next.Truncated)
-                            {
-                                replaced = replaced.Prepend("            #warning TRUNCATED: Add remaining baseline queries.");
-                            }
-
-                            return string.Join(Environment.NewLine, before.Concat(replaced));
-                        }));
+            var testFileBasePath = args[1];
+
+            if (!Directory.Exists(testFileBasePath))
+            {
+                throw new ArgumentException($"Path '{testFileBasePath}' does not exist or is not a directory.");
+            }
+
+            var notFound = new List<string>();
+
+            foreach (var file in Regex.Matches(
+                             File.ReadAllText(queryBaselineFilePath),
+                             $@"(?:^|\n)(?<Id>(?<Name>(?:SingleStore|EntityFrameworkCore|Microsoft)[^\r\n]*)\([^\r\n]*\) : (?<Line>\d+))\r?\n(?<AssertSql>{AssertSqlPattern})\r?\n(?<Truncated>Output truncated.)?\r?\n--------------------(?=\r?\n)",
+                             RegexOptions.IgnoreCase | RegexOptions.Singleline)
+                         .Select(
+                             match => new AssertSqlChunk(
+                                 match.Groups["Id"].Value,
+                                 Path.Combine(
+                                     testFileBasePath,
+                                     Regex.Replace(
+                                         Regex.Replace(
+                                             Regex.Replace(
+                                                 Regex.Replace(
+                                                     match.Groups["Name"].Value,
+                                                     @"^EntityFrameworkCore\.SingleStore\.FunctionalTests\.",
+                                                     string.Empty),
+                                                 @"\.[^.]+$",
+                                                 string.Empty),
+                                             @"\.",
+                                             @"\"),
+                                         "^.*$",
+                                         "$0.cs")),
+                                 int.Parse(match.Groups["Line"].Value),
+                                 match.Groups["Name"].Value,
+                                 match.Groups["AssertSql"].Value,
+                                 match.Groups["Truncated"].Success))
+                         .GroupBy(
+                             c => c.File,
+                             (_, cc) => cc
+                                 .GroupBy(t => t.Line)
+                                 .Select(g => g.First())
+                                 .OrderByDescending(t => t.Line)
+                                 .ToArray()))
+            {
+                var filePath = file.First().File;
+
+                // If we didn't find the chunk in the original file, it is possible that the test class is partial and that the chunk exists
+                // in a separate file that has the name `<ClassName>.SingleStore.cs`.
+                var retryCustomized = new List<string>();
+
+                File.WriteAllText(
+                    filePath,
+                    file.Aggregate(
+                            File.ReadAllText(filePath),
+                            (result, current) => ReplaceChunk(result, current, retryCustomized)));
+
+                if (!retryCustomized.Any())
+                {
+                    continue;
+                }
+
+                var customizedFilePath = Path.Combine(
+                    Path.GetDirectoryName(filePath) ?? string.Empty,
+                    $"{Path.GetFileNameWithoutExtension(filePath)}.SingleStore{Path.GetExtension(filePath)}");
+
+                if (File.Exists(customizedFilePath))
+                {
+                    File.WriteAllText(
+                        customizedFilePath,
+                        file.Join(
+                                retryCustomized,
+                                f => f.Id,
+                                s => s,
+                                (inner, _) => inner)
+                            .OrderByDescending(t => t.Line)
+                            .Aggregate(
+                                File.ReadAllText(customizedFilePath),
+                                (result, current) => ReplaceChunk(result, current, notFound)));
+                }
+                else
+                {
+                    notFound.AddRange(retryCustomized);
+                }
+            }
+
+            if (notFound.Any())
+            {
+                Console.WriteLine("The following chunks were not found:");
+                Console.WriteLine();
+
+                foreach (var id in notFound)
+                {
+                    Console.WriteLine(id);
+                }
+
+                return -1;
+            }
+
+            return 0;
+        }
+
+        private static string ReplaceChunk(string result, AssertSqlChunk current, List<string> notFound)
+        {
+            var lines = Regex.Split(result, @"\r?\n");
+            var before = lines.Take(current.Line - 1);
+            var remaining = lines.Skip(current.Line - 1);
+            var inputText = string.Join(Environment.NewLine, remaining);
+            var replacedResult = Regex.Replace(
+                inputText,
+                $"^{AssertSqlPattern}",
+                current.AssertSql,
+                RegexOptions.IgnoreCase | RegexOptions.Singleline);
+
+            if (inputText == replacedResult)
+            {
+                notFound.Add(current.Id);
+                return result;
+            }
+
+            var splitReplaced = Regex.Split(
+                    replacedResult,
+                    @"\r?\n")
+                .AsEnumerable();
+
+            if (current.Truncated)
+            {
+                splitReplaced = splitReplaced.Prepend("            #warning TRUNCATED: Add remaining baseline queries.");
+            }
+
+            return string.Join(Environment.NewLine, before.Concat(splitReplaced));
         }
     }
+
+    public record AssertSqlChunk(string Id, string File, int Line, string Name, string AssertSql, bool Truncated);
 }
diff --git a/tools/QueryBaselineUpdater/QueryBaselineUpdater.csproj b/tools/QueryBaselineUpdater/QueryBaselineUpdater.csproj
index f1fa7fe2c..7ed017cb7 100644
--- a/tools/QueryBaselineUpdater/QueryBaselineUpdater.csproj
+++ b/tools/QueryBaselineUpdater/QueryBaselineUpdater.csproj
@@ -2,7 +2,7 @@
 
     <PropertyGroup>
         <OutputType>Exe</OutputType>
-        <TargetFramework>net8.0</TargetFramework>
+        <TargetFramework>$(SingleStoreTestTargetFramework)</TargetFramework>
     </PropertyGroup>
 
 </Project>