diff --git a/.github/workflows/test_setup/run-functional-tests2.ps1 b/.github/workflows/test_setup/run-functional-tests2.ps1
index ac9cf1cc3..1ccdb887a 100644
--- a/.github/workflows/test_setup/run-functional-tests2.ps1
+++ b/.github/workflows/test_setup/run-functional-tests2.ps1
@@ -118,6 +118,30 @@ dotnet.exe test -f net8.0 -c Release --no-build --filter 'FullyQualifiedName~.TP
 $TOTAL_FAILURES += ($LASTEXITCODE -ne 0)
 dotnet.exe test -f net8.0 -c Release --no-build --filter 'FullyQualifiedName~.TPTInheritanceBulkUpdatesSingleStoreTest.'
 $TOTAL_FAILURES += ($LASTEXITCODE -ne 0)
+dotnet.exe test -f net8.0 -c Release --no-build --filter 'FullyQualifiedName~.ComplexTypeBulkUpdatesSingleStoreTest.'
+$TOTAL_FAILURES += ($LASTEXITCODE -ne 0)
+dotnet.exe test -f net8.0 -c Release --no-build --filter 'FullyQualifiedName~.ComplexTypesTrackingSingleStoreTest.'
+$TOTAL_FAILURES += ($LASTEXITCODE -ne 0)
+dotnet.exe test -f net8.0 -c Release --no-build --filter 'FullyQualifiedName~.ComplexTypeQuerySingleStoreTest.'
+$TOTAL_FAILURES += ($LASTEXITCODE -ne 0)
+dotnet.exe test -f net8.0 -c Release --no-build --filter 'FullyQualifiedName~.BadDataJsonDeserializationSingleStoreTest.'
+$TOTAL_FAILURES += ($LASTEXITCODE -ne 0)
+dotnet.exe test -f net8.0 -c Release --no-build --filter 'FullyQualifiedName~.AdHocComplexTypeQuerySingleStoreTest.'
+$TOTAL_FAILURES += ($LASTEXITCODE -ne 0)
+dotnet.exe test -f net8.0 -c Release --no-build --filter 'FullyQualifiedName~.AdHocAdvancedMappingsQuerySingleStoreTest.'
+$TOTAL_FAILURES += ($LASTEXITCODE -ne 0)
+dotnet.exe test -f net8.0 -c Release --no-build --filter 'FullyQualifiedName~.OperatorsProceduralSingleStoreTest.'
+$TOTAL_FAILURES += ($LASTEXITCODE -ne 0)
+dotnet.exe test -f net8.0 -c Release --no-build --filter 'FullyQualifiedName~.OperatorsQuerySingleStoreTest.'
+$TOTAL_FAILURES += ($LASTEXITCODE -ne 0)
+dotnet.exe test -f net8.0 -c Release --no-build --filter 'FullyQualifiedName~.OptionalDependentQuerySingleStoreTest.'
+$TOTAL_FAILURES += ($LASTEXITCODE -ne 0)
+dotnet.exe test -f net8.0 -c Release --no-build --filter 'FullyQualifiedName~.SqlQuerySingleStoreTest.'
+$TOTAL_FAILURES += ($LASTEXITCODE -ne 0)
+dotnet.exe test -f net8.0 -c Release --no-build --filter 'FullyQualifiedName~.TPHInheritanceQuerySingleStoreTest.'
+$TOTAL_FAILURES += ($LASTEXITCODE -ne 0)
+dotnet.exe test -f net8.0 -c Release --no-build --filter 'FullyQualifiedName~.SingleStoreConnectionStringOptionsValidatorTests.'
+$TOTAL_FAILURES += ($LASTEXITCODE -ne 0)
 
 cd ..\..\
 
diff --git a/.github/workflows/test_setup/run_functional_tests2.sh b/.github/workflows/test_setup/run_functional_tests2.sh
index e1135ee75..40e49cd6f 100755
--- a/.github/workflows/test_setup/run_functional_tests2.sh
+++ b/.github/workflows/test_setup/run_functional_tests2.sh
@@ -148,6 +148,31 @@ dotnet test -f net8.0 -c Release --no-build --filter 'FullyQualifiedName~.ValueC
 ((TOTAL_FAILURES += $? != 0))
 dotnet test -f net8.0 -c Release --no-build --filter 'FullyQualifiedName~.UpdatesSingleStoreTest.'
 ((TOTAL_FAILURES += $? != 0))
+dotnet test -f net8.0 -c Release --no-build --filter 'FullyQualifiedName~.ComplexTypeBulkUpdatesSingleStoreTest.'
+((TOTAL_FAILURES += $? != 0))
+dotnet test -f net8.0 -c Release --no-build --filter 'FullyQualifiedName~.ComplexTypesTrackingSingleStoreTest.'
+((TOTAL_FAILURES += $? != 0))
+dotnet test -f net8.0 -c Release --no-build --filter 'FullyQualifiedName~.ComplexTypeQuerySingleStoreTest.'
+((TOTAL_FAILURES += $? != 0))
+dotnet test -f net8.0 -c Release --no-build --filter 'FullyQualifiedName~.BadDataJsonDeserializationSingleStoreTest.'
+((TOTAL_FAILURES += $? != 0))
+dotnet test -f net8.0 -c Release --no-build --filter 'FullyQualifiedName~.AdHocComplexTypeQuerySingleStoreTest.'
+((TOTAL_FAILURES += $? != 0))
+dotnet test -f net8.0 -c Release --no-build --filter 'FullyQualifiedName~.AdHocAdvancedMappingsQuerySingleStoreTest.'
+((TOTAL_FAILURES += $? != 0))
+dotnet test -f net8.0 -c Release --no-build --filter 'FullyQualifiedName~.OperatorsProceduralSingleStoreTest.'
+((TOTAL_FAILURES += $? != 0))
+dotnet test -f net8.0 -c Release --no-build --filter 'FullyQualifiedName~.OperatorsQuerySingleStoreTest.'
+((TOTAL_FAILURES += $? != 0))
+dotnet test -f net8.0 -c Release --no-build --filter 'FullyQualifiedName~.OptionalDependentQuerySingleStoreTest.'
+((TOTAL_FAILURES += $? != 0))
+dotnet test -f net8.0 -c Release --no-build --filter 'FullyQualifiedName~.SqlQuerySingleStoreTest.'
+((TOTAL_FAILURES += $? != 0))
+dotnet test -f net8.0 -c Release --no-build --filter 'FullyQualifiedName~.TPHInheritanceQuerySingleStoreTest.'
+((TOTAL_FAILURES += $? != 0))
+dotnet test -f net8.0 -c Release --no-build --filter 'FullyQualifiedName~.SingleStoreConnectionStringOptionsValidatorTests.'
+((TOTAL_FAILURES += $? != 0))
+
 
 cd ../../
 
diff --git a/Dependencies.targets b/Dependencies.targets
index 75fdb612f..2238f6241 100644
--- a/Dependencies.targets
+++ b/Dependencies.targets
@@ -1,6 +1,6 @@
 <Project>
   <PropertyGroup Label="Common Versions">
-    <EFCoreVersion>[8.0.2,8.0.999]</EFCoreVersion>
+    <EFCoreVersion>[8.0.13,8.0.999]</EFCoreVersion>
   </PropertyGroup>
 
   <ItemGroup Label="Dependencies">
@@ -12,30 +12,29 @@
     <PackageReference Update="SingleStoreConnector" Version="1.2.0" />
 
     <PackageReference Update="NetTopologySuite" Version="2.5.0" />
-    <PackageReference Update="System.Text.Json" Version="8.0.2" />
     <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.2" />
-    <PackageReference Update="Microsoft.AspNetCore.Mvc.NewtonsoftJson" Version="8.0.2" />
+    <PackageReference Update="Microsoft.AspNetCore.Identity.EntityFrameworkCore" Version="8.0.13" />
+    <PackageReference Update="Microsoft.AspNetCore.Mvc.NewtonsoftJson" Version="8.0.13" />
     <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.1" />
+    <PackageReference Update="Microsoft.Extensions.Caching.Memory" Version="8.0.1" />
+    <PackageReference Update="Microsoft.Extensions.Configuration.Binder" Version="8.0.2" />
     <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" />
+    <PackageReference Update="Microsoft.Extensions.Configuration.FileExtensions" Version="8.0.1" />
+    <PackageReference Update="Microsoft.Extensions.Configuration.Json" Version="8.0.1" />
     <PackageReference Update="Microsoft.Extensions.Configuration" Version="8.0.0" />
-    <PackageReference Update="Microsoft.Extensions.DependencyInjection" Version="8.0.0" />
-    <PackageReference Update="Microsoft.Extensions.DependencyModel" Version="8.0.0" />
-    <PackageReference Update="Microsoft.Extensions.Logging" Version="8.0.0" />
-    <PackageReference Update="Microsoft.NET.Test.Sdk" Version="17.9.0" />
+    <PackageReference Update="Microsoft.Extensions.DependencyInjection" Version="8.0.1" />
+    <PackageReference Update="Microsoft.Extensions.DependencyModel" Version="8.0.2" />
+    <PackageReference Update="Microsoft.Extensions.Logging" Version="8.0.1" />
+    <PackageReference Update="Microsoft.NET.Test.Sdk" Version="17.13.0" />
     <PackageReference Update="Microsoft.SourceLink.GitHub" Version="8.0.0" />
-    <PackageReference Update="Moq" Version="4.20.70" />
+    <PackageReference Update="Moq" Version="4.20.72" />
     <PackageReference Update="System.Collections.Immutable" Version="8.0.0" />
     <PackageReference Update="System.ComponentModel.TypeConverter" Version="4.3.0" />
-    <PackageReference Update="System.Diagnostics.DiagnosticSource" Version="8.0.0" />
-    <PackageReference Update="GitHubActionsTestLogger" Version="2.3.3" />
+    <PackageReference Update="System.Diagnostics.DiagnosticSource" Version="8.0.1" />
+    <PackageReference Update="GitHubActionsTestLogger" Version="2.4.1" />
 
     <!-- Keep at the same level that the EF Core projects use. -->
     <PackageReference Update="xunit.assert" Version="2.4.2" />
diff --git a/Version.props b/Version.props
index 05660f9d4..acf5578e2 100644
--- a/Version.props
+++ b/Version.props
@@ -2,17 +2,12 @@
   <PropertyGroup Label="Version settings">
     <!--
       Use the following values for the different release types:
-          - "alpha"     - EF Core release independent, code quality unstable,         major changes
-          - "beta"      - EF Core release independent, code quality stable,           can introduce breaking changes
-          - "silver"    - EF Core release independent, code quality stable,           only minor changes are expected
-
-          - "preview"   - EF Core release targeted,    code quality stable,           can introduce breaking changes
-          - "rc"        - EF Core release targeted,    code quality production ready, only minor changes are expected
-
-          - "rtm"       - EF Core release independent, code quality production ready, major release
-          - "servicing" - EF Core release independent, code quality production ready, mainly bugfixes
+          - "-preview"   - Code quality stable,           can introduce breaking changes
+          - "-rc"        - Code quality production ready, only minor changes are expected
+          - "-rtm"       - Code quality production ready, major release
+          - "-servicing" - Code quality production ready, mainly bugfixes
     -->
-    <VersionPrefix>8.0.2</VersionPrefix>
+    <VersionPrefix>8.0.3</VersionPrefix>
     <PreReleaseVersionLabel>servicing</PreReleaseVersionLabel>
 
     <!--
diff --git a/dotnet-tools.json b/dotnet-tools.json
index fd9a39d87..a6a3adb61 100644
--- a/dotnet-tools.json
+++ b/dotnet-tools.json
@@ -3,7 +3,7 @@
   "isRoot": true,
   "tools": {
     "dotnet-ef": {
-      "version": "8.0.1",
+      "version": "8.0.13",
       "commands": [
         "dotnet-ef"
       ]
diff --git a/src/EFCore.SingleStore/Internal/SingleStoreOptions.cs b/src/EFCore.SingleStore/Internal/SingleStoreOptions.cs
index c80ba4019..04b72bb94 100644
--- a/src/EFCore.SingleStore/Internal/SingleStoreOptions.cs
+++ b/src/EFCore.SingleStore/Internal/SingleStoreOptions.cs
@@ -31,10 +31,10 @@ public SingleStoreOptions()
             // This is also being used as the universal fallback character set, if no character set was explicitly defined for the model,
             // which will result in similar behavior as in previous versions and ensure that databases use a decent/the recommended charset
             // by default, if none was explicitly set.
-            DefaultCharSet = CharSet.Utf8;
+            DefaultCharSet = CharSet.Utf8Mb4;
 
             // Optimize space and performance for GUID columns.
-            DefaultGuidCollation = "utf8_general_ci";
+            DefaultGuidCollation = "utf8mb4_bin";
 
             ReplaceLineBreaksWithCharFunction = true;
             DefaultDataTypeMappings = new SingleStoreDefaultDataTypeMappings();
diff --git a/src/EFCore.SingleStore/Query/Internal/SingleStoreMathMethodTranslator.cs b/src/EFCore.SingleStore/Query/Internal/SingleStoreMathMethodTranslator.cs
index 70aadf0c4..65e77b955 100644
--- a/src/EFCore.SingleStore/Query/Internal/SingleStoreMathMethodTranslator.cs
+++ b/src/EFCore.SingleStore/Query/Internal/SingleStoreMathMethodTranslator.cs
@@ -4,6 +4,7 @@
 
 using System;
 using System.Collections.Generic;
+using System.Diagnostics;
 using System.Reflection;
 using Microsoft.EntityFrameworkCore;
 using Microsoft.EntityFrameworkCore.Diagnostics;
@@ -14,102 +15,102 @@ namespace EntityFrameworkCore.SingleStore.Query.Internal
 {
     public class SingleStoreMathMethodTranslator : IMethodCallTranslator
     {
-        private static readonly IDictionary<MethodInfo, (string Name, bool OnlyNullByArgs)> _methodToFunctionName = new Dictionary<MethodInfo, (string Name, bool OnlyNullByArgs)>
+        private static readonly IDictionary<MethodInfo, (string Name, bool OnlyNullByArgs, bool ReverseArgs)> _methodToFunctionName = new Dictionary<MethodInfo, (string Name, bool OnlyNullByArgs, bool ReverseArgs)>
         {
-            { typeof(Math).GetRuntimeMethod(nameof(Math.Abs), new[] { typeof(decimal) }), ("ABS", true) },
-            { typeof(Math).GetRuntimeMethod(nameof(Math.Abs), new[] { typeof(double) }), ("ABS", true) },
-            { typeof(Math).GetRuntimeMethod(nameof(Math.Abs), new[] { typeof(float) }), ("ABS", true) },
-            { typeof(Math).GetRuntimeMethod(nameof(Math.Abs), new[] { typeof(int) }), ("ABS", true) },
-            { typeof(Math).GetRuntimeMethod(nameof(Math.Abs), new[] { typeof(long) }), ("ABS", true) },
-            { typeof(Math).GetRuntimeMethod(nameof(Math.Abs), new[] { typeof(short) }), ("ABS", true) },
-            { typeof(MathF).GetRuntimeMethod(nameof(MathF.Abs), new[] { typeof(float) }), ("ABS", true) },
-
-            { typeof(Math).GetRuntimeMethod(nameof(Math.Acos), new[] { typeof(double) }), ("ACOS", false) },
-            { typeof(MathF).GetRuntimeMethod(nameof(MathF.Acos), new[] { typeof(float) }), ("ACOS", false) },
-
-            { typeof(Math).GetRuntimeMethod(nameof(Math.Asin), new[] { typeof(double) }), ("ASIN", false) },
-            { typeof(MathF).GetRuntimeMethod(nameof(MathF.Asin), new[] { typeof(float) }), ("ASIN", false) },
-
-            { typeof(Math).GetRuntimeMethod(nameof(Math.Atan), new[] { typeof(double) }), ("ATAN", true) },
-            { typeof(MathF).GetRuntimeMethod(nameof(MathF.Atan), new[] { typeof(float) }), ("ATAN", true) },
-
-            { typeof(Math).GetRuntimeMethod(nameof(Math.Atan2), new[] { typeof(double), typeof(double) }), ("ATAN2", true) },
-            { typeof(MathF).GetRuntimeMethod(nameof(MathF.Atan2), new[] { typeof(float), typeof(float) }), ("ATAN2", true) },
-
-            { typeof(Math).GetRuntimeMethod(nameof(Math.Ceiling), new[] { typeof(decimal) }), ("CEILING", true) },
-            { typeof(Math).GetRuntimeMethod(nameof(Math.Ceiling), new[] { typeof(double) }), ("CEILING", true) },
-            { typeof(MathF).GetRuntimeMethod(nameof(MathF.Ceiling), new[] { typeof(float) }), ("CEILING", true) },
-
-            { typeof(Math).GetRuntimeMethod(nameof(Math.Cos), new[] { typeof(double) }), ("COS", true) },
-            { typeof(MathF).GetRuntimeMethod(nameof(MathF.Cos), new[] { typeof(float) }), ("COS", true) },
-
-            { typeof(double).GetRuntimeMethod(nameof(double.DegreesToRadians), new[] { typeof(double) })!, ("RADIANS", true) },
-            { typeof(float).GetRuntimeMethod(nameof(float.DegreesToRadians), new[] { typeof(float) })!, ("RADIANS", true) },
-            { typeof(double).GetRuntimeMethod(nameof(double.RadiansToDegrees), new[] { typeof(double) })!, ("DEGREES", true) },
-            { typeof(float).GetRuntimeMethod(nameof(float.RadiansToDegrees), new[] { typeof(float) })!, ("DEGREES", true) },
-
-            { typeof(Math).GetRuntimeMethod(nameof(Math.Exp), new[] { typeof(double) }), ("EXP", true) },
-            { typeof(MathF).GetRuntimeMethod(nameof(MathF.Exp), new[] { typeof(float) }), ("EXP", true) },
-
-            { typeof(Math).GetRuntimeMethod(nameof(Math.Floor), new[] { typeof(decimal) }), ("FLOOR", true) },
-            { typeof(Math).GetRuntimeMethod(nameof(Math.Floor), new[] { typeof(double) }), ("FLOOR", true) },
-            { typeof(MathF).GetRuntimeMethod(nameof(MathF.Floor), new[] { typeof(float) }), ("FLOOR", true) },
-
-            { typeof(Math).GetRuntimeMethod(nameof(Math.Log), new[] { typeof(double) }), ("LOG", true) },
-            { typeof(Math).GetRuntimeMethod(nameof(Math.Log), new[] { typeof(double), typeof(double) }), ("LOG", false) },
-            { typeof(MathF).GetRuntimeMethod(nameof(MathF.Log), new[] { typeof(float) }), ("LOG", true) },
-            { typeof(MathF).GetRuntimeMethod(nameof(MathF.Log), new[] { typeof(float), typeof(float) }), ("LOG", false) },
-
-            { typeof(Math).GetRuntimeMethod(nameof(Math.Log10), new[] { typeof(double) }), ("LOG10", false) },
-            { typeof(MathF).GetRuntimeMethod(nameof(MathF.Log10), new[] { typeof(float) }), ("LOG10", false) },
-
-            { typeof(Math).GetRuntimeMethod(nameof(Math.Max), new[] { typeof(decimal), typeof(decimal) }), ("GREATEST", true) },
-            { typeof(Math).GetRuntimeMethod(nameof(Math.Max), new[] { typeof(double), typeof(double) }), ("GREATEST", true) },
-            { typeof(Math).GetRuntimeMethod(nameof(Math.Max), new[] { typeof(float), typeof(float) }), ("GREATEST", true) },
-            { typeof(Math).GetRuntimeMethod(nameof(Math.Max), new[] { typeof(int), typeof(int) }), ("GREATEST", true) },
-            { typeof(Math).GetRuntimeMethod(nameof(Math.Max), new[] { typeof(long), typeof(long) }), ("GREATEST", true) },
-            { typeof(Math).GetRuntimeMethod(nameof(Math.Max), new[] { typeof(short), typeof(short) }), ("GREATEST", true) },
-            { typeof(MathF).GetRuntimeMethod(nameof(MathF.Max), new[] { typeof(float), typeof(float) }), ("GREATEST", true) },
-
-            { typeof(Math).GetRuntimeMethod(nameof(Math.Min), new[] { typeof(decimal), typeof(decimal) }), ("LEAST", true) },
-            { typeof(Math).GetRuntimeMethod(nameof(Math.Min), new[] { typeof(double), typeof(double) }), ("LEAST", true) },
-            { typeof(Math).GetRuntimeMethod(nameof(Math.Min), new[] { typeof(float), typeof(float) }), ("LEAST", true) },
-            { typeof(Math).GetRuntimeMethod(nameof(Math.Min), new[] { typeof(int), typeof(int) }), ("LEAST", true) },
-            { typeof(Math).GetRuntimeMethod(nameof(Math.Min), new[] { typeof(long), typeof(long) }), ("LEAST", true) },
-            { typeof(Math).GetRuntimeMethod(nameof(Math.Min), new[] { typeof(short), typeof(short) }), ("LEAST", true) },
-            { typeof(MathF).GetRuntimeMethod(nameof(MathF.Min), new[] { typeof(float), typeof(float) }), ("LEAST", true) },
-
-            { typeof(Math).GetRuntimeMethod(nameof(Math.Pow), new[] { typeof(double), typeof(double) }), ("POWER", true) },
-            { typeof(MathF).GetRuntimeMethod(nameof(MathF.Pow), new[] { typeof(float), typeof(float) }), ("POWER", true) },
-
-            { typeof(Math).GetRuntimeMethod(nameof(Math.Round), new[] { typeof(double) }), ("ROUND", true) },
-            { typeof(Math).GetRuntimeMethod(nameof(Math.Round), new[] { typeof(double), typeof(int) }), ("ROUND", true) },
-            { typeof(Math).GetRuntimeMethod(nameof(Math.Round), new[] { typeof(decimal) }), ("ROUND", true) },
-            { typeof(Math).GetRuntimeMethod(nameof(Math.Round), new[] { typeof(decimal), typeof(int) }), ("ROUND", true) },
-            { typeof(MathF).GetRuntimeMethod(nameof(MathF.Round), new[] { typeof(float) }), ("ROUND", true) },
-            { typeof(MathF).GetRuntimeMethod(nameof(MathF.Round), new[] { typeof(float), typeof(int) }), ("ROUND", true) },
-
-            { typeof(Math).GetRuntimeMethod(nameof(Math.Sign), new[] { typeof(decimal) }), ("SIGN", true) },
-            { typeof(Math).GetRuntimeMethod(nameof(Math.Sign), new[] { typeof(double) }), ("SIGN", true) },
-            { typeof(Math).GetRuntimeMethod(nameof(Math.Sign), new[] { typeof(float) }), ("SIGN", true) },
-            { typeof(Math).GetRuntimeMethod(nameof(Math.Sign), new[] { typeof(int) }), ("SIGN", true) },
-            { typeof(Math).GetRuntimeMethod(nameof(Math.Sign), new[] { typeof(long) }), ("SIGN", true) },
-            { typeof(Math).GetRuntimeMethod(nameof(Math.Sign), new[] { typeof(sbyte) }), ("SIGN", true) },
-            { typeof(Math).GetRuntimeMethod(nameof(Math.Sign), new[] { typeof(short) }), ("SIGN", true) },
-            { typeof(MathF).GetRuntimeMethod(nameof(MathF.Sign), new[] { typeof(float) }), ("SIGN", true) },
-
-            { typeof(Math).GetRuntimeMethod(nameof(Math.Sin), new[] { typeof(double) }), ("SIN", true) },
-            { typeof(MathF).GetRuntimeMethod(nameof(MathF.Sin), new[] { typeof(float) }), ("SIN", true) },
-
-            { typeof(Math).GetRuntimeMethod(nameof(Math.Sqrt), new[] { typeof(double) }), ("SQRT", false) },
-            { typeof(MathF).GetRuntimeMethod(nameof(MathF.Sqrt), new[] { typeof(float) }), ("SQRT", false) },
-
-            { typeof(Math).GetRuntimeMethod(nameof(Math.Tan), new[] { typeof(double) }), ("TAN", true) },
-            { typeof(MathF).GetRuntimeMethod(nameof(MathF.Tan), new[] { typeof(float) }), ("TAN", true) },
-
-            { typeof(Math).GetRuntimeMethod(nameof(Math.Truncate), new[] { typeof(double) }), ("TRUNCATE", true) },
-            { typeof(Math).GetRuntimeMethod(nameof(Math.Truncate), new[] { typeof(decimal) }), ("TRUNCATE", true) },
-            { typeof(MathF).GetRuntimeMethod(nameof(MathF.Truncate), new[] { typeof(float) }), ("TRUNCATE", true) },
+            { typeof(Math).GetRuntimeMethod(nameof(Math.Abs), new[] { typeof(decimal) }), ("ABS", true, false) },
+            { typeof(Math).GetRuntimeMethod(nameof(Math.Abs), new[] { typeof(double) }), ("ABS", true, false) },
+            { typeof(Math).GetRuntimeMethod(nameof(Math.Abs), new[] { typeof(float) }), ("ABS", true, false) },
+            { typeof(Math).GetRuntimeMethod(nameof(Math.Abs), new[] { typeof(int) }), ("ABS", true, false) },
+            { typeof(Math).GetRuntimeMethod(nameof(Math.Abs), new[] { typeof(long) }), ("ABS", true, false) },
+            { typeof(Math).GetRuntimeMethod(nameof(Math.Abs), new[] { typeof(short) }), ("ABS", true, false) },
+            { typeof(MathF).GetRuntimeMethod(nameof(MathF.Abs), new[] { typeof(float) }), ("ABS", true, false) },
+
+            { typeof(Math).GetRuntimeMethod(nameof(Math.Acos), new[] { typeof(double) }), ("ACOS", false, false) },
+            { typeof(MathF).GetRuntimeMethod(nameof(MathF.Acos), new[] { typeof(float) }), ("ACOS", false, false) },
+
+            { typeof(Math).GetRuntimeMethod(nameof(Math.Asin), new[] { typeof(double) }), ("ASIN", false, false) },
+            { typeof(MathF).GetRuntimeMethod(nameof(MathF.Asin), new[] { typeof(float) }), ("ASIN", false, false) },
+
+            { typeof(Math).GetRuntimeMethod(nameof(Math.Atan), new[] { typeof(double) }), ("ATAN", true, false) },
+            { typeof(MathF).GetRuntimeMethod(nameof(MathF.Atan), new[] { typeof(float) }), ("ATAN", true, false) },
+
+            { typeof(Math).GetRuntimeMethod(nameof(Math.Atan2), new[] { typeof(double), typeof(double) }), ("ATAN2", true, false) },
+            { typeof(MathF).GetRuntimeMethod(nameof(MathF.Atan2), new[] { typeof(float), typeof(float) }), ("ATAN2", true, false) },
+
+            { typeof(Math).GetRuntimeMethod(nameof(Math.Ceiling), new[] { typeof(decimal) }), ("CEILING", true, false) },
+            { typeof(Math).GetRuntimeMethod(nameof(Math.Ceiling), new[] { typeof(double) }), ("CEILING", true, false) },
+            { typeof(MathF).GetRuntimeMethod(nameof(MathF.Ceiling), new[] { typeof(float) }), ("CEILING", true, false) },
+
+            { typeof(Math).GetRuntimeMethod(nameof(Math.Cos), new[] { typeof(double) }), ("COS", true, false) },
+            { typeof(MathF).GetRuntimeMethod(nameof(MathF.Cos), new[] { typeof(float) }), ("COS", true, false) },
+
+            { typeof(double).GetRuntimeMethod(nameof(double.DegreesToRadians), new[] { typeof(double) })!, ("RADIANS", true, false) },
+            { typeof(float).GetRuntimeMethod(nameof(float.DegreesToRadians), new[] { typeof(float) })!, ("RADIANS", true, false) },
+            { typeof(double).GetRuntimeMethod(nameof(double.RadiansToDegrees), new[] { typeof(double) })!, ("DEGREES", true, false) },
+            { typeof(float).GetRuntimeMethod(nameof(float.RadiansToDegrees), new[] { typeof(float) })!, ("DEGREES", true, false) },
+
+            { typeof(Math).GetRuntimeMethod(nameof(Math.Exp), new[] { typeof(double) }), ("EXP", true, false) },
+            { typeof(MathF).GetRuntimeMethod(nameof(MathF.Exp), new[] { typeof(float) }), ("EXP", true, false) },
+
+            { typeof(Math).GetRuntimeMethod(nameof(Math.Floor), new[] { typeof(decimal) }), ("FLOOR", true, false) },
+            { typeof(Math).GetRuntimeMethod(nameof(Math.Floor), new[] { typeof(double) }), ("FLOOR", true, false) },
+            { typeof(MathF).GetRuntimeMethod(nameof(MathF.Floor), new[] { typeof(float) }), ("FLOOR", true, false) },
+
+            { typeof(Math).GetRuntimeMethod(nameof(Math.Log), new[] { typeof(double) }), ("LOG", true, false) },
+            { typeof(Math).GetRuntimeMethod(nameof(Math.Log), new[] { typeof(double), typeof(double) }), ("LOG", false, true) },
+            { typeof(MathF).GetRuntimeMethod(nameof(MathF.Log), new[] { typeof(float) }), ("LOG", true, false) },
+            { typeof(MathF).GetRuntimeMethod(nameof(MathF.Log), new[] { typeof(float), typeof(float) }), ("LOG", false, true) },
+
+            { typeof(Math).GetRuntimeMethod(nameof(Math.Log10), new[] { typeof(double) }), ("LOG10", false, false) },
+            { typeof(MathF).GetRuntimeMethod(nameof(MathF.Log10), new[] { typeof(float) }), ("LOG10", false, false) },
+
+            { typeof(Math).GetRuntimeMethod(nameof(Math.Max), new[] { typeof(decimal), typeof(decimal) }), ("GREATEST", true, false) },
+            { typeof(Math).GetRuntimeMethod(nameof(Math.Max), new[] { typeof(double), typeof(double) }), ("GREATEST", true, false) },
+            { typeof(Math).GetRuntimeMethod(nameof(Math.Max), new[] { typeof(float), typeof(float) }), ("GREATEST", true, false) },
+            { typeof(Math).GetRuntimeMethod(nameof(Math.Max), new[] { typeof(int), typeof(int) }), ("GREATEST", true, false) },
+            { typeof(Math).GetRuntimeMethod(nameof(Math.Max), new[] { typeof(long), typeof(long) }), ("GREATEST", true, false) },
+            { typeof(Math).GetRuntimeMethod(nameof(Math.Max), new[] { typeof(short), typeof(short) }), ("GREATEST", true, false) },
+            { typeof(MathF).GetRuntimeMethod(nameof(MathF.Max), new[] { typeof(float), typeof(float) }), ("GREATEST", true, false) },
+
+            { typeof(Math).GetRuntimeMethod(nameof(Math.Min), new[] { typeof(decimal), typeof(decimal) }), ("LEAST", true, false) },
+            { typeof(Math).GetRuntimeMethod(nameof(Math.Min), new[] { typeof(double), typeof(double) }), ("LEAST", true, false) },
+            { typeof(Math).GetRuntimeMethod(nameof(Math.Min), new[] { typeof(float), typeof(float) }), ("LEAST", true, false) },
+            { typeof(Math).GetRuntimeMethod(nameof(Math.Min), new[] { typeof(int), typeof(int) }), ("LEAST", true, false) },
+            { typeof(Math).GetRuntimeMethod(nameof(Math.Min), new[] { typeof(long), typeof(long) }), ("LEAST", true, false) },
+            { typeof(Math).GetRuntimeMethod(nameof(Math.Min), new[] { typeof(short), typeof(short) }), ("LEAST", true, false) },
+            { typeof(MathF).GetRuntimeMethod(nameof(MathF.Min), new[] { typeof(float), typeof(float) }), ("LEAST", true, false) },
+
+            { typeof(Math).GetRuntimeMethod(nameof(Math.Pow), new[] { typeof(double), typeof(double) }), ("POWER", true, false) },
+            { typeof(MathF).GetRuntimeMethod(nameof(MathF.Pow), new[] { typeof(float), typeof(float) }), ("POWER", true, false) },
+
+            { typeof(Math).GetRuntimeMethod(nameof(Math.Round), new[] { typeof(double) }), ("ROUND", true, false) },
+            { typeof(Math).GetRuntimeMethod(nameof(Math.Round), new[] { typeof(double), typeof(int) }), ("ROUND", true, false) },
+            { typeof(Math).GetRuntimeMethod(nameof(Math.Round), new[] { typeof(decimal) }), ("ROUND", true, false) },
+            { typeof(Math).GetRuntimeMethod(nameof(Math.Round), new[] { typeof(decimal), typeof(int) }), ("ROUND", true, false) },
+            { typeof(MathF).GetRuntimeMethod(nameof(MathF.Round), new[] { typeof(float) }), ("ROUND", true, false) },
+            { typeof(MathF).GetRuntimeMethod(nameof(MathF.Round), new[] { typeof(float), typeof(int) }), ("ROUND", true, false) },
+
+            { typeof(Math).GetRuntimeMethod(nameof(Math.Sign), new[] { typeof(decimal) }), ("SIGN", true, false) },
+            { typeof(Math).GetRuntimeMethod(nameof(Math.Sign), new[] { typeof(double) }), ("SIGN", true, false) },
+            { typeof(Math).GetRuntimeMethod(nameof(Math.Sign), new[] { typeof(float) }), ("SIGN", true, false) },
+            { typeof(Math).GetRuntimeMethod(nameof(Math.Sign), new[] { typeof(int) }), ("SIGN", true, false) },
+            { typeof(Math).GetRuntimeMethod(nameof(Math.Sign), new[] { typeof(long) }), ("SIGN", true, false) },
+            { typeof(Math).GetRuntimeMethod(nameof(Math.Sign), new[] { typeof(sbyte) }), ("SIGN", true, false) },
+            { typeof(Math).GetRuntimeMethod(nameof(Math.Sign), new[] { typeof(short) }), ("SIGN", true, false) },
+            { typeof(MathF).GetRuntimeMethod(nameof(MathF.Sign), new[] { typeof(float) }), ("SIGN", true, false) },
+
+            { typeof(Math).GetRuntimeMethod(nameof(Math.Sin), new[] { typeof(double) }), ("SIN", true, false) },
+            { typeof(MathF).GetRuntimeMethod(nameof(MathF.Sin), new[] { typeof(float) }), ("SIN", true, false) },
+
+            { typeof(Math).GetRuntimeMethod(nameof(Math.Sqrt), new[] { typeof(double) }), ("SQRT", false, false) },
+            { typeof(MathF).GetRuntimeMethod(nameof(MathF.Sqrt), new[] { typeof(float) }), ("SQRT", false, false) },
+
+            { typeof(Math).GetRuntimeMethod(nameof(Math.Tan), new[] { typeof(double) }), ("TAN", true, false) },
+            { typeof(MathF).GetRuntimeMethod(nameof(MathF.Tan), new[] { typeof(float) }), ("TAN", true, false) },
+
+            { typeof(Math).GetRuntimeMethod(nameof(Math.Truncate), new[] { typeof(double) }), ("TRUNCATE", true, false) },
+            { typeof(Math).GetRuntimeMethod(nameof(Math.Truncate), new[] { typeof(decimal) }), ("TRUNCATE", true, false) },
+            { typeof(MathF).GetRuntimeMethod(nameof(MathF.Truncate), new[] { typeof(float) }), ("TRUNCATE", true, false) },
         };
 
         private readonly SingleStoreSqlExpressionFactory _sqlExpressionFactory;
@@ -133,18 +134,20 @@ public virtual SqlExpression Translate(
                     targetArgumentsCount = 2;
                 }
 
+                Debug.Assert(targetArgumentsCount is >= 1 and <= 2);
+
                 var newArguments = new SqlExpression[targetArgumentsCount];
                 newArguments[0] = arguments[0];
 
                 if (targetArgumentsCount == 2)
                 {
-                    if (arguments.Count == 2)
-                    {
-                        newArguments[1] = arguments[1];
-                    }
-                    else
+                    newArguments[1] = arguments.Count == 2
+                        ? arguments[1]
+                        : _sqlExpressionFactory.Constant(0);
+
+                    if (mapping.ReverseArgs)
                     {
-                        newArguments[1] = _sqlExpressionFactory.Constant(0);
+                        (newArguments[0], newArguments[1]) = (newArguments[1], newArguments[0]);
                     }
                 }
 
diff --git a/src/EFCore.SingleStore/Storage/Internal/SingleStoreConnectionStringOptionsValidator.cs b/src/EFCore.SingleStore/Storage/Internal/SingleStoreConnectionStringOptionsValidator.cs
index 373d5f1c9..dc65ac522 100644
--- a/src/EFCore.SingleStore/Storage/Internal/SingleStoreConnectionStringOptionsValidator.cs
+++ b/src/EFCore.SingleStore/Storage/Internal/SingleStoreConnectionStringOptionsValidator.cs
@@ -3,6 +3,7 @@
 // Licensed under the MIT. See LICENSE in the project root for license information.
 
 using System;
+using System.Data;
 using System.Data.Common;
 using System.Linq;
 using System.Reflection;
@@ -17,15 +18,20 @@ public virtual bool EnsureMandatoryOptions(ref string connectionString)
         if (connectionString is not null)
         {
             var csb = new SingleStoreConnectionStringBuilder(connectionString);
-            AddConnectionAttributes(csb);
+
+            var attrsChanged = AddConnectionAttributes(csb);
+            var flagsChanged = false;
 
             if (!ValidateMandatoryOptions(csb))
             {
                 csb.AllowUserVariables = true;
                 csb.UseAffectedRows = false;
+                flagsChanged = true;
+            }
 
+            if (attrsChanged || flagsChanged)
+            {
                 connectionString = csb.ConnectionString;
-
                 return true;
             }
         }
@@ -35,26 +41,26 @@ public virtual bool EnsureMandatoryOptions(ref string connectionString)
 
     public virtual bool EnsureMandatoryOptions(DbConnection connection)
     {
-        if (connection is not null)
+        if (connection is null)
         {
-            var csb = new SingleStoreConnectionStringBuilder(connection.ConnectionString);
-            AddConnectionAttributes(csb);
+            return false;
+        }
 
-            if (!ValidateMandatoryOptions(csb))
+        var csb = new SingleStoreConnectionStringBuilder(connection.ConnectionString);
+
+        if (!ValidateMandatoryOptions(csb))
+        {
+            try
             {
-                try
-                {
-                    csb.AllowUserVariables = true;
-                    csb.UseAffectedRows = false;
-
-                    connection.ConnectionString = csb.ConnectionString;
-
-                    return true;
-                }
-                catch (Exception e)
-                {
-                    ThrowException(e);
-                }
+                csb.AllowUserVariables = true;
+                csb.UseAffectedRows = false;
+
+                connection.ConnectionString = csb.ConnectionString;
+                return true;
+            }
+            catch (Exception e)
+            {
+                ThrowException(e);
             }
         }
 
@@ -69,37 +75,39 @@ public virtual bool EnsureMandatoryOptions(DbDataSource dataSource)
         }
 
         var csb = new SingleStoreConnectionStringBuilder(dataSource.ConnectionString);
-        AddConnectionAttributes(csb);
 
+        // We can’t persist ConnectionAttributes changes back to the data source, so don’t attempt.
         if (!ValidateMandatoryOptions(csb))
         {
-            // We can't alter the connection string of a DbDataSource/SingleStoreDataSource as we do for DbConnection/SingleStoreConnection in cases
-            // where the necessary connection string options have not been set.
-            // We can only throw.
             ThrowException();
         }
 
         return true;
     }
 
-    static void AddConnectionAttributes(SingleStoreConnectionStringBuilder csb)
+    private static bool AddConnectionAttributes(SingleStoreConnectionStringBuilder csb)
     {
         var existing = csb.ConnectionAttributes?.TrimEnd(',') ?? "";
 
-        var programVersion = Assembly.GetExecutingAssembly().GetName().Version;
-        var connAttrs = $"_connector_name:SingleStore Entity Framework Core provider,_connector_version:{programVersion}";
-
-        var existingConnAttrs = existing
+        var existingAttrs = existing
             .Split(',', StringSplitOptions.RemoveEmptyEntries)
             .Select(attr => attr.Trim())
+            .Where(attr => !string.IsNullOrEmpty(attr))
             .ToHashSet(StringComparer.OrdinalIgnoreCase);
 
-        if (!existingConnAttrs.Contains(connAttrs))
+        var programVersion = typeof(SingleStoreConnectionStringOptionsValidator).Assembly.GetName().Version;
+        var nameAttr = "_connector_name:SingleStore Entity Framework Core provider";
+        var versionAttr = $"_connector_version:{programVersion}";
+
+        var changed = existingAttrs.Add(nameAttr) | existingAttrs.Add(versionAttr);
+
+        if (changed)
         {
-            csb.ConnectionAttributes = string.IsNullOrEmpty(existing)
-                ? connAttrs
-                : $"{existing},{connAttrs}";
+            csb.ConnectionAttributes = string.Join(",", existingAttrs);
+            return true;
         }
+
+        return false;
     }
 
     public virtual void ThrowException(Exception innerException = null)
diff --git a/src/EFCore.SingleStore/Storage/Internal/SingleStoreRelationalConnection.cs b/src/EFCore.SingleStore/Storage/Internal/SingleStoreRelationalConnection.cs
index d0299f250..a394c5ec1 100644
--- a/src/EFCore.SingleStore/Storage/Internal/SingleStoreRelationalConnection.cs
+++ b/src/EFCore.SingleStore/Storage/Internal/SingleStoreRelationalConnection.cs
@@ -5,6 +5,7 @@
 using System;
 using System.Data.Common;
 using System.Diagnostics.CodeAnalysis;
+using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
 using System.Transactions;
@@ -191,10 +192,31 @@ protected virtual ISingleStoreRelationalConnection CreateMasterConnectionCore(
                 IsMasterConnection = true
             };
 
+        private static void AddConnectionAttributes(SingleStoreConnectionStringBuilder csb)
+        {
+            var existing = csb.ConnectionAttributes?.TrimEnd(',') ?? "";
+
+            var existingAttrs = existing
+                .Split(',', StringSplitOptions.RemoveEmptyEntries)
+                .Select(attr => attr.Trim())
+                .Where(attr => !string.IsNullOrEmpty(attr))
+                .ToHashSet(StringComparer.OrdinalIgnoreCase);
+
+            var programVersion = typeof(SingleStoreConnectionStringOptionsValidator).Assembly.GetName().Version;
+            var nameAttr = "_connector_name:SingleStore Entity Framework Core provider";
+            var versionAttr = $"_connector_version:{programVersion}";
+
+            var changed = existingAttrs.Add(nameAttr) | existingAttrs.Add(versionAttr);
+
+            if (changed)
+            {
+                csb.ConnectionAttributes = string.Join(",", existingAttrs);
+            }
+        }
+
         protected virtual SingleStoreConnectionStringBuilder AddConnectionStringOptions(SingleStoreConnectionStringBuilder builder)
         {
-            var program_version = Assembly.GetExecutingAssembly().GetName().Version.ToString();
-            builder.ConnectionAttributes = $"_connector_name:SingleStore Entity Framework Core provider,_connector_version:{program_version}";
+            AddConnectionAttributes(builder);
 
             if (CommandTimeout != null)
             {
diff --git a/test/EFCore.SingleStore.FunctionalTests/BadDataJsonDeserializationSingleStoreTest.cs b/test/EFCore.SingleStore.FunctionalTests/BadDataJsonDeserializationSingleStoreTest.cs
index 7a0651a76..cb6e45006 100644
--- a/test/EFCore.SingleStore.FunctionalTests/BadDataJsonDeserializationSingleStoreTest.cs
+++ b/test/EFCore.SingleStore.FunctionalTests/BadDataJsonDeserializationSingleStoreTest.cs
@@ -1,10 +1,17 @@
 using Microsoft.EntityFrameworkCore;
 using EntityFrameworkCore.SingleStore.Tests;
+using Xunit;
 
 namespace EntityFrameworkCore.SingleStore.FunctionalTests;
 
-public class BadDataJsonDeserializationMySqlTest : BadDataJsonDeserializationTestBase
+public class BadDataJsonDeserializationSingleStoreTest : BadDataJsonDeserializationTestBase
 {
+    [ConditionalTheory(Skip = "Geospatial types aren't supported by this provider yet.")]
+    public override void Throws_for_bad_point_as_GeoJson(string json)
+    {
+        base.Throws_for_bad_point_as_GeoJson(json);
+    }
+
     protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
         => base.OnConfiguring(optionsBuilder.UseSingleStore(b => b.UseNetTopologySuite()));
 }
diff --git a/test/EFCore.SingleStore.FunctionalTests/ConnectionSettingsSingleStoreTest.cs b/test/EFCore.SingleStore.FunctionalTests/ConnectionSettingsSingleStoreTest.cs
index 369a8712b..a732e0576 100644
--- a/test/EFCore.SingleStore.FunctionalTests/ConnectionSettingsSingleStoreTest.cs
+++ b/test/EFCore.SingleStore.FunctionalTests/ConnectionSettingsSingleStoreTest.cs
@@ -12,8 +12,8 @@ namespace EntityFrameworkCore.SingleStore.FunctionalTests
     public class ConnectionSettingsSingleStoreTest
     {
         [ConditionalTheory]
-        [InlineData(SingleStoreGuidFormat.Char36, "'850368D8-93EA-4023-ACC7-6FA6E4C3B27F'", null)]
-        [InlineData(SingleStoreGuidFormat.Char32, "'850368D893EA4023ACC76FA6E4C3B27F'", null)]
+        [InlineData(SingleStoreGuidFormat.Char36, "'850368d8-93ea-4023-acc7-6fa6e4c3b27f'", null)]
+        [InlineData(SingleStoreGuidFormat.Char32, "'850368d893ea4023acc76fa6e4c3b27f'", null)]
         [InlineData(SingleStoreGuidFormat.Binary16, "X'850368D893EA4023ACC76FA6E4C3B27F'", null)]
         [InlineData(SingleStoreGuidFormat.TimeSwapBinary16, "X'402393EA850368D8ACC76FA6E4C3B27F'", null)]
         [InlineData(SingleStoreGuidFormat.LittleEndianBinary16, "X'D8680385EA932340ACC76FA6E4C3B27F'", null)]
diff --git a/test/EFCore.SingleStore.FunctionalTests/MigrationsInfrastructureSingleStoreTest.cs b/test/EFCore.SingleStore.FunctionalTests/MigrationsInfrastructureSingleStoreTest.cs
index 6f2334429..d09bdcdda 100644
--- a/test/EFCore.SingleStore.FunctionalTests/MigrationsInfrastructureSingleStoreTest.cs
+++ b/test/EFCore.SingleStore.FunctionalTests/MigrationsInfrastructureSingleStoreTest.cs
@@ -1,6 +1,8 @@
 using System;
+using System.Threading.Tasks;
 using Microsoft.EntityFrameworkCore.Migrations;
 using Microsoft.EntityFrameworkCore.TestUtilities;
+using SingleStoreConnector;
 using EntityFrameworkCore.SingleStore.FunctionalTests.TestUtilities;
 using EntityFrameworkCore.SingleStore.Infrastructure;
 using EntityFrameworkCore.SingleStore.Tests.TestUtilities.Attributes;
@@ -67,6 +69,7 @@ public override void Can_generate_up_scripts()
 CREATE TABLE `Table1` (
     `Id` int NOT NULL,
     `Foo` int NOT NULL,
+    `Description` longtext NOT NULL,
     CONSTRAINT `PK_Table1` PRIMARY KEY (`Id`)
 );
 
@@ -98,6 +101,44 @@ public override void Can_generate_up_scripts()
 
 COMMIT;
 
+START TRANSACTION;
+
+INSERT INTO Table1 (Id, Bar, Description) VALUES (-1, ' ', 'Value With
+
+Empty Lines')
+
+INSERT INTO `__EFMigrationsHistory` (`MigrationId`, `ProductVersion`)
+VALUES ('00000000000005_Migration5', '7.0.0-test');
+
+COMMIT;
+
+START TRANSACTION;
+
+INSERT INTO Table1 (Id, Bar, Description) VALUES (-2, ' ', 'GO
+Value With
+
+Empty Lines')
+
+INSERT INTO `__EFMigrationsHistory` (`MigrationId`, `ProductVersion`)
+VALUES ('00000000000006_Migration6', '7.0.0-test');
+
+COMMIT;
+
+START TRANSACTION;
+
+INSERT INTO Table1 (Id, Bar, Description) VALUES (-3, ' ', 'GO
+Value With
+
+GO
+
+Empty Lines
+GO')
+
+INSERT INTO `__EFMigrationsHistory` (`MigrationId`, `ProductVersion`)
+VALUES ('00000000000007_Migration7', '7.0.0-test');
+
+COMMIT;
+
 
 """,
                 Sql,
@@ -165,6 +206,7 @@ IF NOT EXISTS(SELECT 1 FROM `__EFMigrationsHistory` WHERE `MigrationId` = '00000
     CREATE TABLE `Table1` (
         `Id` int NOT NULL,
         `Foo` int NOT NULL,
+        `Description` longtext NOT NULL,
         CONSTRAINT `PK_Table1` PRIMARY KEY (`Id`)
     );
 
@@ -262,6 +304,116 @@ IF NOT EXISTS(SELECT 1 FROM `__EFMigrationsHistory` WHERE `MigrationId` = '00000
 
 COMMIT;
 
+START TRANSACTION;
+
+DROP PROCEDURE IF EXISTS MigrationsScript;
+DELIMITER //
+CREATE PROCEDURE MigrationsScript()
+BEGIN
+    IF NOT EXISTS(SELECT 1 FROM `__EFMigrationsHistory` WHERE `MigrationId` = '00000000000005_Migration5') THEN
+
+    INSERT INTO Table1 (Id, Bar, Description) VALUES (-1, ' ', 'Value With
+
+    Empty Lines')
+
+    END IF;
+END //
+DELIMITER ;
+CALL MigrationsScript();
+DROP PROCEDURE MigrationsScript;
+
+DROP PROCEDURE IF EXISTS MigrationsScript;
+DELIMITER //
+CREATE PROCEDURE MigrationsScript()
+BEGIN
+    IF NOT EXISTS(SELECT 1 FROM `__EFMigrationsHistory` WHERE `MigrationId` = '00000000000005_Migration5') THEN
+
+    INSERT INTO `__EFMigrationsHistory` (`MigrationId`, `ProductVersion`)
+    VALUES ('00000000000005_Migration5', '7.0.0-test');
+
+    END IF;
+END //
+DELIMITER ;
+CALL MigrationsScript();
+DROP PROCEDURE MigrationsScript;
+
+COMMIT;
+
+START TRANSACTION;
+
+DROP PROCEDURE IF EXISTS MigrationsScript;
+DELIMITER //
+CREATE PROCEDURE MigrationsScript()
+BEGIN
+    IF NOT EXISTS(SELECT 1 FROM `__EFMigrationsHistory` WHERE `MigrationId` = '00000000000006_Migration6') THEN
+
+    INSERT INTO Table1 (Id, Bar, Description) VALUES (-2, ' ', 'GO
+    Value With
+
+    Empty Lines')
+
+    END IF;
+END //
+DELIMITER ;
+CALL MigrationsScript();
+DROP PROCEDURE MigrationsScript;
+
+DROP PROCEDURE IF EXISTS MigrationsScript;
+DELIMITER //
+CREATE PROCEDURE MigrationsScript()
+BEGIN
+    IF NOT EXISTS(SELECT 1 FROM `__EFMigrationsHistory` WHERE `MigrationId` = '00000000000006_Migration6') THEN
+
+    INSERT INTO `__EFMigrationsHistory` (`MigrationId`, `ProductVersion`)
+    VALUES ('00000000000006_Migration6', '7.0.0-test');
+
+    END IF;
+END //
+DELIMITER ;
+CALL MigrationsScript();
+DROP PROCEDURE MigrationsScript;
+
+COMMIT;
+
+START TRANSACTION;
+
+DROP PROCEDURE IF EXISTS MigrationsScript;
+DELIMITER //
+CREATE PROCEDURE MigrationsScript()
+BEGIN
+    IF NOT EXISTS(SELECT 1 FROM `__EFMigrationsHistory` WHERE `MigrationId` = '00000000000007_Migration7') THEN
+
+    INSERT INTO Table1 (Id, Bar, Description) VALUES (-3, ' ', 'GO
+    Value With
+
+    GO
+
+    Empty Lines
+    GO')
+
+    END IF;
+END //
+DELIMITER ;
+CALL MigrationsScript();
+DROP PROCEDURE MigrationsScript;
+
+DROP PROCEDURE IF EXISTS MigrationsScript;
+DELIMITER //
+CREATE PROCEDURE MigrationsScript()
+BEGIN
+    IF NOT EXISTS(SELECT 1 FROM `__EFMigrationsHistory` WHERE `MigrationId` = '00000000000007_Migration7') THEN
+
+    INSERT INTO `__EFMigrationsHistory` (`MigrationId`, `ProductVersion`)
+    VALUES ('00000000000007_Migration7', '7.0.0-test');
+
+    END IF;
+END //
+DELIMITER ;
+CALL MigrationsScript();
+DROP PROCEDURE MigrationsScript;
+
+COMMIT;
+
 
 """,
                 Sql,
@@ -432,6 +584,7 @@ public override void Can_generate_up_scripts_noTransactions()
 CREATE TABLE `Table1` (
     `Id` int NOT NULL,
     `Foo` int NOT NULL,
+    `Description` longtext NOT NULL,
     CONSTRAINT `PK_Table1` PRIMARY KEY (`Id`)
 );
 
@@ -449,6 +602,32 @@ public override void Can_generate_up_scripts_noTransactions()
 INSERT INTO `__EFMigrationsHistory` (`MigrationId`, `ProductVersion`)
 VALUES ('00000000000004_Migration4', '7.0.0-test');
 
+INSERT INTO Table1 (Id, Bar, Description) VALUES (-1, ' ', 'Value With
+
+Empty Lines')
+
+INSERT INTO `__EFMigrationsHistory` (`MigrationId`, `ProductVersion`)
+VALUES ('00000000000005_Migration5', '7.0.0-test');
+
+INSERT INTO Table1 (Id, Bar, Description) VALUES (-2, ' ', 'GO
+Value With
+
+Empty Lines')
+
+INSERT INTO `__EFMigrationsHistory` (`MigrationId`, `ProductVersion`)
+VALUES ('00000000000006_Migration6', '7.0.0-test');
+
+INSERT INTO Table1 (Id, Bar, Description) VALUES (-3, ' ', 'GO
+Value With
+
+GO
+
+Empty Lines
+GO')
+
+INSERT INTO `__EFMigrationsHistory` (`MigrationId`, `ProductVersion`)
+VALUES ('00000000000007_Migration7', '7.0.0-test');
+
 
 """,
                 Sql,
@@ -476,6 +655,7 @@ IF NOT EXISTS(SELECT 1 FROM `__EFMigrationsHistory` WHERE `MigrationId` = '00000
     CREATE TABLE `Table1` (
         `Id` int NOT NULL,
         `Foo` int NOT NULL,
+        `Description` longtext NOT NULL,
         CONSTRAINT `PK_Table1` PRIMARY KEY (`Id`)
     );
 
@@ -559,12 +739,121 @@ IF NOT EXISTS(SELECT 1 FROM `__EFMigrationsHistory` WHERE `MigrationId` = '00000
 CALL MigrationsScript();
 DROP PROCEDURE MigrationsScript;
 
+DROP PROCEDURE IF EXISTS MigrationsScript;
+DELIMITER //
+CREATE PROCEDURE MigrationsScript()
+BEGIN
+    IF NOT EXISTS(SELECT 1 FROM `__EFMigrationsHistory` WHERE `MigrationId` = '00000000000005_Migration5') THEN
+
+    INSERT INTO Table1 (Id, Bar, Description) VALUES (-1, ' ', 'Value With
+
+    Empty Lines')
+
+    END IF;
+END //
+DELIMITER ;
+CALL MigrationsScript();
+DROP PROCEDURE MigrationsScript;
+
+DROP PROCEDURE IF EXISTS MigrationsScript;
+DELIMITER //
+CREATE PROCEDURE MigrationsScript()
+BEGIN
+    IF NOT EXISTS(SELECT 1 FROM `__EFMigrationsHistory` WHERE `MigrationId` = '00000000000005_Migration5') THEN
+
+    INSERT INTO `__EFMigrationsHistory` (`MigrationId`, `ProductVersion`)
+    VALUES ('00000000000005_Migration5', '7.0.0-test');
+
+    END IF;
+END //
+DELIMITER ;
+CALL MigrationsScript();
+DROP PROCEDURE MigrationsScript;
+
+DROP PROCEDURE IF EXISTS MigrationsScript;
+DELIMITER //
+CREATE PROCEDURE MigrationsScript()
+BEGIN
+    IF NOT EXISTS(SELECT 1 FROM `__EFMigrationsHistory` WHERE `MigrationId` = '00000000000006_Migration6') THEN
+
+    INSERT INTO Table1 (Id, Bar, Description) VALUES (-2, ' ', 'GO
+    Value With
+
+    Empty Lines')
+
+    END IF;
+END //
+DELIMITER ;
+CALL MigrationsScript();
+DROP PROCEDURE MigrationsScript;
+
+DROP PROCEDURE IF EXISTS MigrationsScript;
+DELIMITER //
+CREATE PROCEDURE MigrationsScript()
+BEGIN
+    IF NOT EXISTS(SELECT 1 FROM `__EFMigrationsHistory` WHERE `MigrationId` = '00000000000006_Migration6') THEN
+
+    INSERT INTO `__EFMigrationsHistory` (`MigrationId`, `ProductVersion`)
+    VALUES ('00000000000006_Migration6', '7.0.0-test');
+
+    END IF;
+END //
+DELIMITER ;
+CALL MigrationsScript();
+DROP PROCEDURE MigrationsScript;
+
+DROP PROCEDURE IF EXISTS MigrationsScript;
+DELIMITER //
+CREATE PROCEDURE MigrationsScript()
+BEGIN
+    IF NOT EXISTS(SELECT 1 FROM `__EFMigrationsHistory` WHERE `MigrationId` = '00000000000007_Migration7') THEN
+
+    INSERT INTO Table1 (Id, Bar, Description) VALUES (-3, ' ', 'GO
+    Value With
+
+    GO
+
+    Empty Lines
+    GO')
+
+    END IF;
+END //
+DELIMITER ;
+CALL MigrationsScript();
+DROP PROCEDURE MigrationsScript;
+
+DROP PROCEDURE IF EXISTS MigrationsScript;
+DELIMITER //
+CREATE PROCEDURE MigrationsScript()
+BEGIN
+    IF NOT EXISTS(SELECT 1 FROM `__EFMigrationsHistory` WHERE `MigrationId` = '00000000000007_Migration7') THEN
+
+    INSERT INTO `__EFMigrationsHistory` (`MigrationId`, `ProductVersion`)
+    VALUES ('00000000000007_Migration7', '7.0.0-test');
+
+    END IF;
+END //
+DELIMITER ;
+CALL MigrationsScript();
+DROP PROCEDURE MigrationsScript;
+
 
 """,
                 Sql,
                 ignoreLineEndingDifferences: true);
         }
 
+        public override void Can_apply_one_migration()
+        {
+            base.Can_apply_one_migration();
+
+            Assert.Null(Sql);
+        }
+
+        // Issue https://github.com/dotnet/efcore/issues/33331 isn’t applicable in our CI runs because the
+        // test environment sets `data_conversion_compatibility_level = '6.0'`, which avoids the overflow
+        // behavior the tests were asserting.
+
         [ConditionalFact(Skip = "TODO: Implement")]
         public override void Can_diff_against_2_2_model()
         {
diff --git a/test/EFCore.SingleStore.FunctionalTests/MigrationsSingleStoreTest.cs b/test/EFCore.SingleStore.FunctionalTests/MigrationsSingleStoreTest.cs
index 4c556f36a..33388293b 100644
--- a/test/EFCore.SingleStore.FunctionalTests/MigrationsSingleStoreTest.cs
+++ b/test/EFCore.SingleStore.FunctionalTests/MigrationsSingleStoreTest.cs
@@ -1,4 +1,5 @@
 using System;
+using System.Collections.Generic;
 using System.Linq;
 using System.Threading.Tasks;
 using Microsoft.EntityFrameworkCore;
@@ -9,6 +10,7 @@
 using Microsoft.EntityFrameworkCore.Migrations.Design;
 using Microsoft.EntityFrameworkCore.Scaffolding;
 using Microsoft.EntityFrameworkCore.Scaffolding.Metadata;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
 using Microsoft.EntityFrameworkCore.Storage;
 using Microsoft.EntityFrameworkCore.TestUtilities;
 using Microsoft.Extensions.DependencyInjection;
@@ -193,7 +195,7 @@ await Test(
                 });
 
             AssertSql(
-                @"ALTER TABLE `People` ADD `Name` varchar(128) CHARACTER SET utf8 NOT NULL DEFAULT 'John Doe';");
+                @"ALTER TABLE `People` ADD `Name` varchar(128) CHARACTER SET utf8mb4 NOT NULL DEFAULT 'John Doe';");
         }
 
         [ConditionalFact]
@@ -498,12 +500,12 @@ public override async Task Create_table_with_multiline_comments()
             AssertSql(
                 @"CREATE TABLE `People` (
     `Id` int NOT NULL,
-    `Name` longtext CHARACTER SET utf8 NULL COMMENT 'This is a multi-line
+    `Name` longtext CHARACTER SET utf8mb4 NULL COMMENT 'This is a multi-line
 column comment.
 More information can
 be found in the docs.',
     CONSTRAINT `PK_People` PRIMARY KEY (`Id`)
-) CHARACTER SET=utf8 COMMENT='This is a multi-line
+) CHARACTER SET=utf8mb4 COMMENT='This is a multi-line
 table comment.
 More information can
 be found in the docs.';");
@@ -777,12 +779,12 @@ await Test(
                     var table = Assert.Single(result.Tables);
                     var iceCreamIdColumn = Assert.Single(table.Columns.Where(c => c.Name == "IceCreamId"));
 
-                    Assert.Equal(S2ServerVersion.Supports.DefaultCharSetUtf8Mb4? "utf8_general_ci" : null, iceCreamIdColumn.Collation);
+                    Assert.Equal(S2ServerVersion.Supports.DefaultCharSetUtf8Mb4? "utf8mb4_bin" : null, iceCreamIdColumn.Collation);
                 });
 
             AssertSql(
                 $@"CREATE TABLE `IceCream` (
-    `IceCreamId` char(36) COLLATE utf8_general_ci NOT NULL,
+    `IceCreamId` char(36) COLLATE utf8mb4_bin NOT NULL,
     CONSTRAINT `PK_IceCream` PRIMARY KEY (`IceCreamId`)
 ) COLLATE={DefaultCollation};");
         }
@@ -1045,7 +1047,7 @@ public virtual void Upgrade_legacy_charset_to_annotation_charset_only_does_not_g
                                     .HasColumnType("int");
 
                                 b.Property<string>("Name")
-                                    .HasColumnType("longtext CHARACTER SET utf8");
+                                    .HasColumnType("longtext CHARACTER SET utf8mb4");
 
                                 b.HasKey("IceCreamId");
 
@@ -1193,7 +1195,14 @@ await Test(
                     var table = Assert.Single(result.Tables);
                     var nameColumn = Assert.Single(table.Columns.Where(c => c.Name == "Name"));
 
-                    Assert.Equal(S2ServerVersion.Supports.DefaultCharSetUtf8Mb4? null : NonDefaultCharSet, nameColumn[SingleStoreAnnotationNames.CharSet]);
+                    if (S2ServerVersion.Supports.Version(ServerVersion.Parse("9.0")))
+                    {
+                        Assert.Equal(NonDefaultCharSet, nameColumn[SingleStoreAnnotationNames.CharSet]);
+                    }
+                    else
+                    {
+                        Assert.Equal(S2ServerVersion.Supports.DefaultCharSetUtf8Mb4 ? null : NonDefaultCharSet, nameColumn[SingleStoreAnnotationNames.CharSet]);
+                    }
                     Assert.Equal("longtext", nameColumn.StoreType);
                 });
 
@@ -1202,7 +1211,7 @@ await Test(
     `IceCreamId` int NOT NULL,
     `Name` longtext CHARACTER SET {NonDefaultCharSet} NULL,
     CONSTRAINT `PK_IceCream` PRIMARY KEY (`IceCreamId`)
-) CHARACTER SET=utf8;");
+) CHARACTER SET=utf8mb4;");
         }
 
         [ConditionalFact]
@@ -1393,6 +1402,125 @@ public override Task Rename_table()
                 },
                 withConventions: false);
 
+        public override async Task Add_required_primitve_collection_with_custom_default_value_sql_to_existing_table()
+        {
+            await Add_required_primitve_collection_with_custom_default_value_sql_to_existing_table_core("'[3, 2, 1]'");
+
+            AssertSql(
+                """
+                ALTER TABLE `Customers` ADD `Numbers` varchar(127) CHARACTER SET utf8mb4 NOT NULL DEFAULT '[3, 2, 1]';
+                """);
+        }
+
+        protected override Task Add_required_primitve_collection_with_custom_default_value_sql_to_existing_table_core(string defaultValueSql)
+            => Test(
+                builder => builder.Entity(
+                    "Customer", e =>
+                    {
+                        e.Property<int>("Id").ValueGeneratedOnAdd();
+                        e.HasKey("Id");
+                        e.Property<string>("Name");
+                        e.ToTable("Customers");
+                    }),
+                builder => builder.Entity(
+                    "Customer", e =>
+                    {
+                        e.Property<int>("Id").ValueGeneratedOnAdd();
+                        e.HasKey("Id");
+                        e.Property<string>("Name");
+                        e.Property<List<int>>("Numbers").IsRequired()
+                            .HasMaxLength(127) // <-- MySQL requires a `varchar(n)` instead of a `longtext` type for default value support
+                            .HasDefaultValueSql(defaultValueSql);
+                        e.ToTable("Customers");
+                    }),
+                model =>
+                {
+                    var customersTable = Assert.Single(model.Tables.Where(t => t.Name == "Customers"));
+
+                    Assert.Collection(
+                        customersTable.Columns,
+                        c => Assert.Equal("Id", c.Name),
+                        c => Assert.Equal("Name", c.Name),
+                        c => Assert.Equal("Numbers", c.Name));
+                    Assert.Same(
+                        customersTable.Columns.Single(c => c.Name == "Id"),
+                        Assert.Single(customersTable.PrimaryKey!.Columns));
+                });
+
+        public override Task Add_required_primitve_collection_with_custom_converter_and_custom_default_value_to_existing_table()
+            => Test(
+                builder => builder.Entity(
+                    "Customer", e =>
+                    {
+                        e.Property<int>("Id").ValueGeneratedOnAdd();
+                        e.HasKey("Id");
+                        e.Property<string>("Name");
+                        e.ToTable("Customers");
+                    }),
+                builder => builder.Entity(
+                    "Customer", e =>
+                    {
+                        e.Property<int>("Id").ValueGeneratedOnAdd();
+                        e.HasKey("Id");
+                        e.Property<string>("Name");
+                        e.Property<List<int>>("Numbers")
+                            .HasMaxLength(127) // <-- MySQL requires a `varchar(n)` instead of a `longtext` type for default value support
+                            .HasConversion(new ValueConverter<List<int>, string>(
+                                convertToProviderExpression: x => x != null && x.Count > 0 ? "some numbers" : "nothing",
+                                convertFromProviderExpression: x => x == "nothing" ? new List<int> { } : new List<int> { 7, 8, 9 }))
+                            .HasDefaultValue(new List<int> { 42 })
+                            .IsRequired();
+                        e.ToTable("Customers");
+                    }),
+                model =>
+                {
+                    var customersTable = Assert.Single(model.Tables.Where(t => t.Name == "Customers"));
+
+                    Assert.Collection(
+                        customersTable.Columns,
+                        c => Assert.Equal("Id", c.Name),
+                        c => Assert.Equal("Name", c.Name),
+                        c => Assert.Equal("Numbers", c.Name));
+                    Assert.Same(
+                        customersTable.Columns.Single(c => c.Name == "Id"),
+                        Assert.Single(customersTable.PrimaryKey!.Columns));
+                });
+
+        public override Task Add_required_primitve_collection_with_custom_default_value_to_existing_table()
+            => Test(
+                builder => builder.Entity(
+                    "Customer", e =>
+                    {
+                        e.Property<int>("Id").ValueGeneratedOnAdd();
+                        e.HasKey("Id");
+                        e.Property<string>("Name");
+                        e.ToTable("Customers");
+                    }),
+                builder => builder.Entity(
+                    "Customer", e =>
+                    {
+                        e.Property<int>("Id").ValueGeneratedOnAdd();
+                        e.HasKey("Id");
+                        e.Property<string>("Name");
+                        e.Property<List<int>>("Numbers")
+                            .HasMaxLength(127) // <-- MySQL requires a `varchar(n)` instead of a `longtext` type for default value support
+                            .IsRequired().HasDefaultValue(new List<int> { 1, 2, 3 });
+                        e.ToTable("Customers");
+                    }),
+                model =>
+                {
+                    var customersTable = Assert.Single(model.Tables.Where(t => t.Name == "Customers"));
+
+                    Assert.Collection(
+                        customersTable.Columns,
+                        c => Assert.Equal("Id", c.Name),
+                        c => Assert.Equal("Name", c.Name),
+                        c => Assert.Equal("Numbers", c.Name));
+                    Assert.Same(
+                        customersTable.Columns.Single(c => c.Name == "Id"),
+                        Assert.Single(customersTable.PrimaryKey!.Columns));
+                });
+
         // The constraint name for a primary key is always PRIMARY in MySQL.
         protected override bool AssertConstraintNames
             => false;
diff --git a/test/EFCore.SingleStore.FunctionalTests/Query/AdHocAdvancedMappingsQuerySingleStoreTest.cs b/test/EFCore.SingleStore.FunctionalTests/Query/AdHocAdvancedMappingsQuerySingleStoreTest.cs
new file mode 100644
index 000000000..d690d2375
--- /dev/null
+++ b/test/EFCore.SingleStore.FunctionalTests/Query/AdHocAdvancedMappingsQuerySingleStoreTest.cs
@@ -0,0 +1,87 @@
+using System.Threading.Tasks;
+using Microsoft.EntityFrameworkCore.Query;
+using Microsoft.EntityFrameworkCore.TestUtilities;
+using EntityFrameworkCore.SingleStore.FunctionalTests.TestUtilities;
+
+namespace EntityFrameworkCore.SingleStore.FunctionalTests.Query;
+
+public class AdHocAdvancedMappingsQuerySingleStoreTest : AdHocAdvancedMappingsQueryRelationalTestBase
+{
+    protected override ITestStoreFactory TestStoreFactory
+        => SingleStoreTestStoreFactory.Instance;
+
+    public override async Task Two_similar_complex_properties_projected_with_split_query1()
+    {
+        await base.Two_similar_complex_properties_projected_with_split_query1();
+
+        AssertSql(
+"""
+SELECT `o`.`Id`
+FROM `Offers` AS `o`
+ORDER BY `o`.`Id`
+""",
+                //
+                """
+SELECT `t`.`Id`, `t`.`NestedId`, `t`.`OfferId`, `t`.`payment_brutto`, `t`.`payment_netto`, `t`.`Id0`, `t`.`payment_brutto0`, `t`.`payment_netto0`, `o`.`Id`
+FROM `Offers` AS `o`
+INNER JOIN (
+    SELECT `v`.`Id`, `v`.`NestedId`, `v`.`OfferId`, `v`.`payment_brutto`, `v`.`payment_netto`, `n`.`Id` AS `Id0`, `n`.`payment_brutto` AS `payment_brutto0`, `n`.`payment_netto` AS `payment_netto0`
+    FROM `Variation` AS `v`
+    LEFT JOIN `NestedEntity` AS `n` ON `v`.`NestedId` = `n`.`Id`
+) AS `t` ON `o`.`Id` = `t`.`OfferId`
+ORDER BY `o`.`Id`
+""");
+    }
+
+    public override async Task Two_similar_complex_properties_projected_with_split_query2()
+    {
+        await base.Two_similar_complex_properties_projected_with_split_query2();
+
+        AssertSql(
+"""
+SELECT `o`.`Id`
+FROM `Offers` AS `o`
+WHERE `o`.`Id` = 1
+ORDER BY `o`.`Id`
+LIMIT 2
+""",
+                //
+                """
+SELECT `t0`.`Id`, `t0`.`NestedId`, `t0`.`OfferId`, `t0`.`payment_brutto`, `t0`.`payment_netto`, `t0`.`Id0`, `t0`.`payment_brutto0`, `t0`.`payment_netto0`, `t`.`Id`
+FROM (
+    SELECT `o`.`Id`
+    FROM `Offers` AS `o`
+    WHERE `o`.`Id` = 1
+    LIMIT 1
+) AS `t`
+INNER JOIN (
+    SELECT `v`.`Id`, `v`.`NestedId`, `v`.`OfferId`, `v`.`payment_brutto`, `v`.`payment_netto`, `n`.`Id` AS `Id0`, `n`.`payment_brutto` AS `payment_brutto0`, `n`.`payment_netto` AS `payment_netto0`
+    FROM `Variation` AS `v`
+    LEFT JOIN `NestedEntity` AS `n` ON `v`.`NestedId` = `n`.`Id`
+) AS `t0` ON `t`.`Id` = `t0`.`OfferId`
+ORDER BY `t`.`Id`
+""");
+    }
+
+    public override async Task Projecting_one_of_two_similar_complex_types_picks_the_correct_one()
+    {
+        await base.Projecting_one_of_two_similar_complex_types_picks_the_correct_one();
+
+        AssertSql(
+"""
+@__p_0='10'
+
+SELECT `a`.`Id`, `t`.`Info_Created0` AS `Created`
+FROM (
+    SELECT `c`.`Id`, `b`.`AId`, `b`.`Info_Created` AS `Info_Created0`
+    FROM `Cs` AS `c`
+    INNER JOIN `Bs` AS `b` ON `c`.`BId` = `b`.`Id`
+    WHERE `b`.`AId` = 1
+    ORDER BY `c`.`Id`
+    LIMIT @__p_0
+) AS `t`
+LEFT JOIN `As` AS `a` ON `t`.`AId` = `a`.`Id`
+ORDER BY `t`.`Id`
+""");
+    }
+}
diff --git a/test/EFCore.SingleStore.FunctionalTests/Query/AdHocComplexTypeQuerySingleStoreTest.cs b/test/EFCore.SingleStore.FunctionalTests/Query/AdHocComplexTypeQuerySingleStoreTest.cs
new file mode 100644
index 000000000..d865777ea
--- /dev/null
+++ b/test/EFCore.SingleStore.FunctionalTests/Query/AdHocComplexTypeQuerySingleStoreTest.cs
@@ -0,0 +1,41 @@
+using System.Threading.Tasks;
+using Microsoft.EntityFrameworkCore.Query;
+using Microsoft.EntityFrameworkCore.TestUtilities;
+using EntityFrameworkCore.SingleStore.FunctionalTests.TestUtilities;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Metadata;
+using Xunit;
+
+namespace EntityFrameworkCore.SingleStore.FunctionalTests.Query;
+
+public class AdHocComplexTypeQuerySingleStoreTest : AdHocComplexTypeQueryTestBase
+{
+    [ConditionalTheory(Skip =
+        "SingleStore: disabled due to distributed-table identity constraints for int keys. " +
+        "With explicit mapping to BIGINT or sequence-based identity (AUTO_INCREMENT AS SEQUENCE), this passes.")]
+    public override async Task Complex_type_equals_parameter_with_nested_types_with_property_of_same_name()
+    {
+        await base.Complex_type_equals_parameter_with_nested_types_with_property_of_same_name();
+
+        AssertSql(
+            """
+            @__entity_equality_container_0_Id='1' (Nullable = true)
+            @__entity_equality_container_0_Containee1_Id='2' (Nullable = true)
+            @__entity_equality_container_0_Containee2_Id='3' (Nullable = true)
+
+            SELECT `e`.`Id`, `e`.`ComplexContainer_Id`, `e`.`ComplexContainer_Containee1_Id`, `e`.`ComplexContainer_Containee2_Id`
+            FROM `EntityType` AS `e`
+            WHERE ((`e`.`ComplexContainer_Id` = @__entity_equality_container_0_Id) AND (`e`.`ComplexContainer_Containee1_Id` = @__entity_equality_container_0_Containee1_Id)) AND (`e`.`ComplexContainer_Containee2_Id` = @__entity_equality_container_0_Containee2_Id)
+            LIMIT 2
+            """);
+    }
+
+    protected TestSqlLoggerFactory TestSqlLoggerFactory
+        => (TestSqlLoggerFactory)ListLoggerFactory;
+
+    protected void AssertSql(params string[] expected)
+        => TestSqlLoggerFactory.AssertBaseline(expected);
+
+    protected override ITestStoreFactory TestStoreFactory
+        => SingleStoreTestStoreFactory.Instance;
+}
diff --git a/test/EFCore.SingleStore.FunctionalTests/Query/ComplexTypeQuerySingleStoreTest.cs b/test/EFCore.SingleStore.FunctionalTests/Query/ComplexTypeQuerySingleStoreTest.cs
index 0a80bef5e..d47c423f5 100644
--- a/test/EFCore.SingleStore.FunctionalTests/Query/ComplexTypeQuerySingleStoreTest.cs
+++ b/test/EFCore.SingleStore.FunctionalTests/Query/ComplexTypeQuerySingleStoreTest.cs
@@ -50,6 +50,7 @@ public override async Task Filter_on_property_inside_complex_type_after_subquery
         AssertSql(
 """
 @__p_0='1'
+
 SELECT DISTINCT `t`.`Id`, `t`.`Name`, `t`.`BillingAddress_AddressLine1`, `t`.`BillingAddress_AddressLine2`, `t`.`BillingAddress_ZipCode`, `t`.`BillingAddress_Country_Code`, `t`.`BillingAddress_Country_FullName`, `t`.`ShippingAddress_AddressLine1`, `t`.`ShippingAddress_AddressLine2`, `t`.`ShippingAddress_ZipCode`, `t`.`ShippingAddress_Country_Code`, `t`.`ShippingAddress_Country_FullName`
 FROM (
     SELECT `c`.`Id`, `c`.`Name`, `c`.`BillingAddress_AddressLine1`, `c`.`BillingAddress_AddressLine2`, `c`.`BillingAddress_ZipCode`, `c`.`BillingAddress_Country_Code`, `c`.`BillingAddress_Country_FullName`, `c`.`ShippingAddress_AddressLine1`, `c`.`ShippingAddress_AddressLine2`, `c`.`ShippingAddress_ZipCode`, `c`.`ShippingAddress_Country_Code`, `c`.`ShippingAddress_Country_FullName`
@@ -68,6 +69,7 @@ public override async Task Filter_on_property_inside_nested_complex_type_after_s
         AssertSql(
 """
 @__p_0='1'
+
 SELECT DISTINCT `t`.`Id`, `t`.`Name`, `t`.`BillingAddress_AddressLine1`, `t`.`BillingAddress_AddressLine2`, `t`.`BillingAddress_ZipCode`, `t`.`BillingAddress_Country_Code`, `t`.`BillingAddress_Country_FullName`, `t`.`ShippingAddress_AddressLine1`, `t`.`ShippingAddress_AddressLine2`, `t`.`ShippingAddress_ZipCode`, `t`.`ShippingAddress_Country_Code`, `t`.`ShippingAddress_Country_FullName`
 FROM (
     SELECT `c`.`Id`, `c`.`Name`, `c`.`BillingAddress_AddressLine1`, `c`.`BillingAddress_AddressLine2`, `c`.`BillingAddress_ZipCode`, `c`.`BillingAddress_Country_Code`, `c`.`BillingAddress_Country_FullName`, `c`.`ShippingAddress_AddressLine1`, `c`.`ShippingAddress_AddressLine2`, `c`.`ShippingAddress_ZipCode`, `c`.`ShippingAddress_Country_Code`, `c`.`ShippingAddress_Country_FullName`
@@ -136,6 +138,7 @@ public override async Task Load_complex_type_after_subquery_on_entity_type(bool
         AssertSql(
 """
 @__p_0='1'
+
 SELECT DISTINCT `t`.`Id`, `t`.`Name`, `t`.`BillingAddress_AddressLine1`, `t`.`BillingAddress_AddressLine2`, `t`.`BillingAddress_ZipCode`, `t`.`BillingAddress_Country_Code`, `t`.`BillingAddress_Country_FullName`, `t`.`ShippingAddress_AddressLine1`, `t`.`ShippingAddress_AddressLine2`, `t`.`ShippingAddress_ZipCode`, `t`.`ShippingAddress_Country_Code`, `t`.`ShippingAddress_Country_FullName`
 FROM (
     SELECT `c`.`Id`, `c`.`Name`, `c`.`BillingAddress_AddressLine1`, `c`.`BillingAddress_AddressLine2`, `c`.`BillingAddress_ZipCode`, `c`.`BillingAddress_Country_Code`, `c`.`BillingAddress_Country_FullName`, `c`.`ShippingAddress_AddressLine1`, `c`.`ShippingAddress_AddressLine2`, `c`.`ShippingAddress_ZipCode`, `c`.`ShippingAddress_Country_Code`, `c`.`ShippingAddress_Country_FullName`
@@ -234,11 +237,12 @@ public override async Task Complex_type_equals_parameter(bool async)
 """
 @__entity_equality_address_0_AddressLine1='804 S. Lakeshore Road' (Size = 4000)
 @__entity_equality_address_0_ZipCode='38654' (Nullable = true)
-@__entity_equality_address_0_Code='US' (Size = 4000)
-@__entity_equality_address_0_FullName='United States' (Size = 4000)
+@__entity_equality_address_0_Country_Code='US' (Size = 4000)
+@__entity_equality_address_0_Country_FullName='United States' (Size = 4000)
+
 SELECT `c`.`Id`, `c`.`Name`, `c`.`BillingAddress_AddressLine1`, `c`.`BillingAddress_AddressLine2`, `c`.`BillingAddress_ZipCode`, `c`.`BillingAddress_Country_Code`, `c`.`BillingAddress_Country_FullName`, `c`.`ShippingAddress_AddressLine1`, `c`.`ShippingAddress_AddressLine2`, `c`.`ShippingAddress_ZipCode`, `c`.`ShippingAddress_Country_Code`, `c`.`ShippingAddress_Country_FullName`
 FROM `Customer` AS `c`
-WHERE ((((`c`.`ShippingAddress_AddressLine1` = @__entity_equality_address_0_AddressLine1) AND `c`.`ShippingAddress_AddressLine2` IS NULL) AND (`c`.`ShippingAddress_ZipCode` = @__entity_equality_address_0_ZipCode)) AND (`c`.`ShippingAddress_Country_Code` = @__entity_equality_address_0_Code)) AND (`c`.`ShippingAddress_Country_FullName` = @__entity_equality_address_0_FullName)
+WHERE ((((`c`.`ShippingAddress_AddressLine1` = @__entity_equality_address_0_AddressLine1) AND `c`.`ShippingAddress_AddressLine2` IS NULL) AND (`c`.`ShippingAddress_ZipCode` = @__entity_equality_address_0_ZipCode)) AND (`c`.`ShippingAddress_Country_Code` = @__entity_equality_address_0_Country_Code)) AND (`c`.`ShippingAddress_Country_FullName` = @__entity_equality_address_0_Country_FullName)
 """);
     }
 
@@ -258,14 +262,15 @@ public override async Task Contains_over_complex_type(bool async)
 """
 @__entity_equality_address_0_AddressLine1='804 S. Lakeshore Road' (Size = 4000)
 @__entity_equality_address_0_ZipCode='38654' (Nullable = true)
-@__entity_equality_address_0_Code='US' (Size = 4000)
-@__entity_equality_address_0_FullName='United States' (Size = 4000)
+@__entity_equality_address_0_Country_Code='US' (Size = 4000)
+@__entity_equality_address_0_Country_FullName='United States' (Size = 4000)
+
 SELECT `c`.`Id`, `c`.`Name`, `c`.`BillingAddress_AddressLine1`, `c`.`BillingAddress_AddressLine2`, `c`.`BillingAddress_ZipCode`, `c`.`BillingAddress_Country_Code`, `c`.`BillingAddress_Country_FullName`, `c`.`ShippingAddress_AddressLine1`, `c`.`ShippingAddress_AddressLine2`, `c`.`ShippingAddress_ZipCode`, `c`.`ShippingAddress_Country_Code`, `c`.`ShippingAddress_Country_FullName`
 FROM `Customer` AS `c`
 WHERE EXISTS (
     SELECT 1
     FROM `Customer` AS `c0`
-    WHERE ((((`c0`.`ShippingAddress_AddressLine1` = @__entity_equality_address_0_AddressLine1) AND `c0`.`ShippingAddress_AddressLine2` IS NULL) AND (`c0`.`ShippingAddress_ZipCode` = @__entity_equality_address_0_ZipCode)) AND (`c0`.`ShippingAddress_Country_Code` = @__entity_equality_address_0_Code)) AND (`c0`.`ShippingAddress_Country_FullName` = @__entity_equality_address_0_FullName))
+    WHERE ((((`c0`.`ShippingAddress_AddressLine1` = @__entity_equality_address_0_AddressLine1) AND `c0`.`ShippingAddress_AddressLine2` IS NULL) AND (`c0`.`ShippingAddress_ZipCode` = @__entity_equality_address_0_ZipCode)) AND (`c0`.`ShippingAddress_Country_Code` = @__entity_equality_address_0_Country_Code)) AND (`c0`.`ShippingAddress_Country_FullName` = @__entity_equality_address_0_Country_FullName))
 """);
     }
 
@@ -439,6 +444,7 @@ public override async Task Filter_on_property_inside_struct_complex_type_after_s
         AssertSql(
 """
 @__p_0='1'
+
 SELECT DISTINCT `t`.`Id`, `t`.`Name`, `t`.`BillingAddress_AddressLine1`, `t`.`BillingAddress_AddressLine2`, `t`.`BillingAddress_ZipCode`, `t`.`BillingAddress_Country_Code`, `t`.`BillingAddress_Country_FullName`, `t`.`ShippingAddress_AddressLine1`, `t`.`ShippingAddress_AddressLine2`, `t`.`ShippingAddress_ZipCode`, `t`.`ShippingAddress_Country_Code`, `t`.`ShippingAddress_Country_FullName`
 FROM (
     SELECT `v`.`Id`, `v`.`Name`, `v`.`BillingAddress_AddressLine1`, `v`.`BillingAddress_AddressLine2`, `v`.`BillingAddress_ZipCode`, `v`.`BillingAddress_Country_Code`, `v`.`BillingAddress_Country_FullName`, `v`.`ShippingAddress_AddressLine1`, `v`.`ShippingAddress_AddressLine2`, `v`.`ShippingAddress_ZipCode`, `v`.`ShippingAddress_Country_Code`, `v`.`ShippingAddress_Country_FullName`
@@ -457,6 +463,7 @@ public override async Task Filter_on_property_inside_nested_struct_complex_type_
         AssertSql(
 """
 @__p_0='1'
+
 SELECT DISTINCT `t`.`Id`, `t`.`Name`, `t`.`BillingAddress_AddressLine1`, `t`.`BillingAddress_AddressLine2`, `t`.`BillingAddress_ZipCode`, `t`.`BillingAddress_Country_Code`, `t`.`BillingAddress_Country_FullName`, `t`.`ShippingAddress_AddressLine1`, `t`.`ShippingAddress_AddressLine2`, `t`.`ShippingAddress_ZipCode`, `t`.`ShippingAddress_Country_Code`, `t`.`ShippingAddress_Country_FullName`
 FROM (
     SELECT `v`.`Id`, `v`.`Name`, `v`.`BillingAddress_AddressLine1`, `v`.`BillingAddress_AddressLine2`, `v`.`BillingAddress_ZipCode`, `v`.`BillingAddress_Country_Code`, `v`.`BillingAddress_Country_FullName`, `v`.`ShippingAddress_AddressLine1`, `v`.`ShippingAddress_AddressLine2`, `v`.`ShippingAddress_ZipCode`, `v`.`ShippingAddress_Country_Code`, `v`.`ShippingAddress_Country_FullName`
@@ -524,6 +531,7 @@ public override async Task Load_struct_complex_type_after_subquery_on_entity_typ
         AssertSql(
 """
 @__p_0='1'
+
 SELECT DISTINCT `t`.`Id`, `t`.`Name`, `t`.`BillingAddress_AddressLine1`, `t`.`BillingAddress_AddressLine2`, `t`.`BillingAddress_ZipCode`, `t`.`BillingAddress_Country_Code`, `t`.`BillingAddress_Country_FullName`, `t`.`ShippingAddress_AddressLine1`, `t`.`ShippingAddress_AddressLine2`, `t`.`ShippingAddress_ZipCode`, `t`.`ShippingAddress_Country_Code`, `t`.`ShippingAddress_Country_FullName`
 FROM (
     SELECT `v`.`Id`, `v`.`Name`, `v`.`BillingAddress_AddressLine1`, `v`.`BillingAddress_AddressLine2`, `v`.`BillingAddress_ZipCode`, `v`.`BillingAddress_Country_Code`, `v`.`BillingAddress_Country_FullName`, `v`.`ShippingAddress_AddressLine1`, `v`.`ShippingAddress_AddressLine2`, `v`.`ShippingAddress_ZipCode`, `v`.`ShippingAddress_Country_Code`, `v`.`ShippingAddress_Country_FullName`
@@ -618,11 +626,12 @@ public override async Task Struct_complex_type_equals_parameter(bool async)
 """
 @__entity_equality_address_0_AddressLine1='804 S. Lakeshore Road' (Size = 4000)
 @__entity_equality_address_0_ZipCode='38654' (Nullable = true)
-@__entity_equality_address_0_Code='US' (Size = 4000)
-@__entity_equality_address_0_FullName='United States' (Size = 4000)
+@__entity_equality_address_0_Country_Code='US' (Size = 4000)
+@__entity_equality_address_0_Country_FullName='United States' (Size = 4000)
+
 SELECT `v`.`Id`, `v`.`Name`, `v`.`BillingAddress_AddressLine1`, `v`.`BillingAddress_AddressLine2`, `v`.`BillingAddress_ZipCode`, `v`.`BillingAddress_Country_Code`, `v`.`BillingAddress_Country_FullName`, `v`.`ShippingAddress_AddressLine1`, `v`.`ShippingAddress_AddressLine2`, `v`.`ShippingAddress_ZipCode`, `v`.`ShippingAddress_Country_Code`, `v`.`ShippingAddress_Country_FullName`
 FROM `ValuedCustomer` AS `v`
-WHERE ((((`v`.`ShippingAddress_AddressLine1` = @__entity_equality_address_0_AddressLine1) AND `v`.`ShippingAddress_AddressLine2` IS NULL) AND (`v`.`ShippingAddress_ZipCode` = @__entity_equality_address_0_ZipCode)) AND (`v`.`ShippingAddress_Country_Code` = @__entity_equality_address_0_Code)) AND (`v`.`ShippingAddress_Country_FullName` = @__entity_equality_address_0_FullName)
+WHERE ((((`v`.`ShippingAddress_AddressLine1` = @__entity_equality_address_0_AddressLine1) AND `v`.`ShippingAddress_AddressLine2` IS NULL) AND (`v`.`ShippingAddress_ZipCode` = @__entity_equality_address_0_ZipCode)) AND (`v`.`ShippingAddress_Country_Code` = @__entity_equality_address_0_Country_Code)) AND (`v`.`ShippingAddress_Country_FullName` = @__entity_equality_address_0_Country_FullName)
 """);
     }
 
@@ -634,14 +643,15 @@ public override async Task Contains_over_struct_complex_type(bool async)
 """
 @__entity_equality_address_0_AddressLine1='804 S. Lakeshore Road' (Size = 4000)
 @__entity_equality_address_0_ZipCode='38654' (Nullable = true)
-@__entity_equality_address_0_Code='US' (Size = 4000)
-@__entity_equality_address_0_FullName='United States' (Size = 4000)
+@__entity_equality_address_0_Country_Code='US' (Size = 4000)
+@__entity_equality_address_0_Country_FullName='United States' (Size = 4000)
+
 SELECT `v`.`Id`, `v`.`Name`, `v`.`BillingAddress_AddressLine1`, `v`.`BillingAddress_AddressLine2`, `v`.`BillingAddress_ZipCode`, `v`.`BillingAddress_Country_Code`, `v`.`BillingAddress_Country_FullName`, `v`.`ShippingAddress_AddressLine1`, `v`.`ShippingAddress_AddressLine2`, `v`.`ShippingAddress_ZipCode`, `v`.`ShippingAddress_Country_Code`, `v`.`ShippingAddress_Country_FullName`
 FROM `ValuedCustomer` AS `v`
 WHERE EXISTS (
     SELECT 1
     FROM `ValuedCustomer` AS `v0`
-    WHERE ((((`v0`.`ShippingAddress_AddressLine1` = @__entity_equality_address_0_AddressLine1) AND `v0`.`ShippingAddress_AddressLine2` IS NULL) AND (`v0`.`ShippingAddress_ZipCode` = @__entity_equality_address_0_ZipCode)) AND (`v0`.`ShippingAddress_Country_Code` = @__entity_equality_address_0_Code)) AND (`v0`.`ShippingAddress_Country_FullName` = @__entity_equality_address_0_FullName))
+    WHERE ((((`v0`.`ShippingAddress_AddressLine1` = @__entity_equality_address_0_AddressLine1) AND `v0`.`ShippingAddress_AddressLine2` IS NULL) AND (`v0`.`ShippingAddress_ZipCode` = @__entity_equality_address_0_ZipCode)) AND (`v0`.`ShippingAddress_Country_Code` = @__entity_equality_address_0_Country_Code)) AND (`v0`.`ShippingAddress_Country_FullName` = @__entity_equality_address_0_Country_FullName))
 """);
     }
 
@@ -736,6 +746,356 @@ public override async Task Union_property_in_struct_complex_type(bool async)
 """);
     }
 
+    public override async Task Project_same_nested_complex_type_twice_with_pushdown(bool async)
+    {
+        await base.Project_same_nested_complex_type_twice_with_pushdown(async);
+
+        AssertSql(
+"""
+SELECT `t`.`BillingAddress_AddressLine1`, `t`.`BillingAddress_AddressLine2`, `t`.`BillingAddress_ZipCode`, `t`.`BillingAddress_Country_Code`, `t`.`BillingAddress_Country_FullName`, `t`.`BillingAddress_AddressLine10`, `t`.`BillingAddress_AddressLine20`, `t`.`BillingAddress_ZipCode0`, `t`.`BillingAddress_Country_Code0`, `t`.`BillingAddress_Country_FullName0`
+FROM (
+    SELECT DISTINCT `c`.`BillingAddress_AddressLine1`, `c`.`BillingAddress_AddressLine2`, `c`.`BillingAddress_ZipCode`, `c`.`BillingAddress_Country_Code`, `c`.`BillingAddress_Country_FullName`, `c0`.`BillingAddress_AddressLine1` AS `BillingAddress_AddressLine10`, `c0`.`BillingAddress_AddressLine2` AS `BillingAddress_AddressLine20`, `c0`.`BillingAddress_ZipCode` AS `BillingAddress_ZipCode0`, `c0`.`BillingAddress_Country_Code` AS `BillingAddress_Country_Code0`, `c0`.`BillingAddress_Country_FullName` AS `BillingAddress_Country_FullName0`
+    FROM `Customer` AS `c`
+    CROSS JOIN `Customer` AS `c0`
+) AS `t`
+""");
+    }
+
+    public override async Task Project_same_entity_with_nested_complex_type_twice_with_pushdown(bool async)
+    {
+        await base.Project_same_entity_with_nested_complex_type_twice_with_pushdown(async);
+
+        AssertSql(
+"""
+SELECT `t`.`Id`, `t`.`Name`, `t`.`BillingAddress_AddressLine1`, `t`.`BillingAddress_AddressLine2`, `t`.`BillingAddress_ZipCode`, `t`.`BillingAddress_Country_Code`, `t`.`BillingAddress_Country_FullName`, `t`.`ShippingAddress_AddressLine1`, `t`.`ShippingAddress_AddressLine2`, `t`.`ShippingAddress_ZipCode`, `t`.`ShippingAddress_Country_Code`, `t`.`ShippingAddress_Country_FullName`, `t`.`Id0`, `t`.`Name0`, `t`.`BillingAddress_AddressLine10`, `t`.`BillingAddress_AddressLine20`, `t`.`BillingAddress_ZipCode0`, `t`.`BillingAddress_Country_Code0`, `t`.`BillingAddress_Country_FullName0`, `t`.`ShippingAddress_AddressLine10`, `t`.`ShippingAddress_AddressLine20`, `t`.`ShippingAddress_ZipCode0`, `t`.`ShippingAddress_Country_Code0`, `t`.`ShippingAddress_Country_FullName0`
+FROM (
+    SELECT DISTINCT `c`.`Id`, `c`.`Name`, `c`.`BillingAddress_AddressLine1`, `c`.`BillingAddress_AddressLine2`, `c`.`BillingAddress_ZipCode`, `c`.`BillingAddress_Country_Code`, `c`.`BillingAddress_Country_FullName`, `c`.`ShippingAddress_AddressLine1`, `c`.`ShippingAddress_AddressLine2`, `c`.`ShippingAddress_ZipCode`, `c`.`ShippingAddress_Country_Code`, `c`.`ShippingAddress_Country_FullName`, `c0`.`Id` AS `Id0`, `c0`.`Name` AS `Name0`, `c0`.`BillingAddress_AddressLine1` AS `BillingAddress_AddressLine10`, `c0`.`BillingAddress_AddressLine2` AS `BillingAddress_AddressLine20`, `c0`.`BillingAddress_ZipCode` AS `BillingAddress_ZipCode0`, `c0`.`BillingAddress_Country_Code` AS `BillingAddress_Country_Code0`, `c0`.`BillingAddress_Country_FullName` AS `BillingAddress_Country_FullName0`, `c0`.`ShippingAddress_AddressLine1` AS `ShippingAddress_AddressLine10`, `c0`.`ShippingAddress_AddressLine2` AS `ShippingAddress_AddressLine20`, `c0`.`ShippingAddress_ZipCode` AS `ShippingAddress_ZipCode0`, `c0`.`ShippingAddress_Country_Code` AS `ShippingAddress_Country_Code0`, `c0`.`ShippingAddress_Country_FullName` AS `ShippingAddress_Country_FullName0`
+    FROM `Customer` AS `c`
+    CROSS JOIN `Customer` AS `c0`
+) AS `t`
+""");
+    }
+
+    public override async Task Project_same_nested_complex_type_twice_with_double_pushdown(bool async)
+    {
+        await base.Project_same_nested_complex_type_twice_with_double_pushdown(async);
+
+        AssertSql(
+"""
+@__p_0='50'
+
+SELECT `t0`.`BillingAddress_AddressLine1`, `t0`.`BillingAddress_AddressLine2`, `t0`.`BillingAddress_ZipCode`, `t0`.`BillingAddress_Country_Code`, `t0`.`BillingAddress_Country_FullName`, `t0`.`BillingAddress_AddressLine10`, `t0`.`BillingAddress_AddressLine20`, `t0`.`BillingAddress_ZipCode0`, `t0`.`BillingAddress_Country_Code0`, `t0`.`BillingAddress_Country_FullName0`
+FROM (
+    SELECT DISTINCT `t`.`BillingAddress_AddressLine1`, `t`.`BillingAddress_AddressLine2`, `t`.`BillingAddress_ZipCode`, `t`.`BillingAddress_Country_Code`, `t`.`BillingAddress_Country_FullName`, `t`.`BillingAddress_AddressLine10`, `t`.`BillingAddress_AddressLine20`, `t`.`BillingAddress_ZipCode0`, `t`.`BillingAddress_Country_Code0`, `t`.`BillingAddress_Country_FullName0`
+    FROM (
+        SELECT `c`.`BillingAddress_AddressLine1`, `c`.`BillingAddress_AddressLine2`, `c`.`BillingAddress_ZipCode`, `c`.`BillingAddress_Country_Code`, `c`.`BillingAddress_Country_FullName`, `c0`.`BillingAddress_AddressLine1` AS `BillingAddress_AddressLine10`, `c0`.`BillingAddress_AddressLine2` AS `BillingAddress_AddressLine20`, `c0`.`BillingAddress_ZipCode` AS `BillingAddress_ZipCode0`, `c0`.`BillingAddress_Country_Code` AS `BillingAddress_Country_Code0`, `c0`.`BillingAddress_Country_FullName` AS `BillingAddress_Country_FullName0`
+        FROM `Customer` AS `c`
+        CROSS JOIN `Customer` AS `c0`
+        ORDER BY `c`.`Id`, `c0`.`Id`
+        LIMIT @__p_0
+    ) AS `t`
+) AS `t0`
+""");
+    }
+
+    public override async Task Project_same_entity_with_nested_complex_type_twice_with_double_pushdown(bool async)
+    {
+        await base.Project_same_entity_with_nested_complex_type_twice_with_double_pushdown(async);
+
+        AssertSql(
+"""
+@__p_0='50'
+
+SELECT `t0`.`Id`, `t0`.`Name`, `t0`.`BillingAddress_AddressLine1`, `t0`.`BillingAddress_AddressLine2`, `t0`.`BillingAddress_ZipCode`, `t0`.`BillingAddress_Country_Code`, `t0`.`BillingAddress_Country_FullName`, `t0`.`ShippingAddress_AddressLine1`, `t0`.`ShippingAddress_AddressLine2`, `t0`.`ShippingAddress_ZipCode`, `t0`.`ShippingAddress_Country_Code`, `t0`.`ShippingAddress_Country_FullName`, `t0`.`Id0`, `t0`.`Name0`, `t0`.`BillingAddress_AddressLine10`, `t0`.`BillingAddress_AddressLine20`, `t0`.`BillingAddress_ZipCode0`, `t0`.`BillingAddress_Country_Code0`, `t0`.`BillingAddress_Country_FullName0`, `t0`.`ShippingAddress_AddressLine10`, `t0`.`ShippingAddress_AddressLine20`, `t0`.`ShippingAddress_ZipCode0`, `t0`.`ShippingAddress_Country_Code0`, `t0`.`ShippingAddress_Country_FullName0`
+FROM (
+    SELECT DISTINCT `t`.`Id`, `t`.`Name`, `t`.`BillingAddress_AddressLine1`, `t`.`BillingAddress_AddressLine2`, `t`.`BillingAddress_ZipCode`, `t`.`BillingAddress_Country_Code`, `t`.`BillingAddress_Country_FullName`, `t`.`ShippingAddress_AddressLine1`, `t`.`ShippingAddress_AddressLine2`, `t`.`ShippingAddress_ZipCode`, `t`.`ShippingAddress_Country_Code`, `t`.`ShippingAddress_Country_FullName`, `t`.`Id0`, `t`.`Name0`, `t`.`BillingAddress_AddressLine10`, `t`.`BillingAddress_AddressLine20`, `t`.`BillingAddress_ZipCode0`, `t`.`BillingAddress_Country_Code0`, `t`.`BillingAddress_Country_FullName0`, `t`.`ShippingAddress_AddressLine10`, `t`.`ShippingAddress_AddressLine20`, `t`.`ShippingAddress_ZipCode0`, `t`.`ShippingAddress_Country_Code0`, `t`.`ShippingAddress_Country_FullName0`
+    FROM (
+        SELECT `c`.`Id`, `c`.`Name`, `c`.`BillingAddress_AddressLine1`, `c`.`BillingAddress_AddressLine2`, `c`.`BillingAddress_ZipCode`, `c`.`BillingAddress_Country_Code`, `c`.`BillingAddress_Country_FullName`, `c`.`ShippingAddress_AddressLine1`, `c`.`ShippingAddress_AddressLine2`, `c`.`ShippingAddress_ZipCode`, `c`.`ShippingAddress_Country_Code`, `c`.`ShippingAddress_Country_FullName`, `c0`.`Id` AS `Id0`, `c0`.`Name` AS `Name0`, `c0`.`BillingAddress_AddressLine1` AS `BillingAddress_AddressLine10`, `c0`.`BillingAddress_AddressLine2` AS `BillingAddress_AddressLine20`, `c0`.`BillingAddress_ZipCode` AS `BillingAddress_ZipCode0`, `c0`.`BillingAddress_Country_Code` AS `BillingAddress_Country_Code0`, `c0`.`BillingAddress_Country_FullName` AS `BillingAddress_Country_FullName0`, `c0`.`ShippingAddress_AddressLine1` AS `ShippingAddress_AddressLine10`, `c0`.`ShippingAddress_AddressLine2` AS `ShippingAddress_AddressLine20`, `c0`.`ShippingAddress_ZipCode` AS `ShippingAddress_ZipCode0`, `c0`.`ShippingAddress_Country_Code` AS `ShippingAddress_Country_Code0`, `c0`.`ShippingAddress_Country_FullName` AS `ShippingAddress_Country_FullName0`
+        FROM `Customer` AS `c`
+        CROSS JOIN `Customer` AS `c0`
+        ORDER BY `c`.`Id`, `c0`.`Id`
+        LIMIT @__p_0
+    ) AS `t`
+) AS `t0`
+""");
+    }
+
+    public override async Task Project_same_struct_nested_complex_type_twice_with_pushdown(bool async)
+    {
+        await base.Project_same_struct_nested_complex_type_twice_with_pushdown(async);
+
+        AssertSql(
+"""
+SELECT `t`.`BillingAddress_AddressLine1`, `t`.`BillingAddress_AddressLine2`, `t`.`BillingAddress_ZipCode`, `t`.`BillingAddress_Country_Code`, `t`.`BillingAddress_Country_FullName`, `t`.`BillingAddress_AddressLine10`, `t`.`BillingAddress_AddressLine20`, `t`.`BillingAddress_ZipCode0`, `t`.`BillingAddress_Country_Code0`, `t`.`BillingAddress_Country_FullName0`
+FROM (
+    SELECT DISTINCT `v`.`BillingAddress_AddressLine1`, `v`.`BillingAddress_AddressLine2`, `v`.`BillingAddress_ZipCode`, `v`.`BillingAddress_Country_Code`, `v`.`BillingAddress_Country_FullName`, `v0`.`BillingAddress_AddressLine1` AS `BillingAddress_AddressLine10`, `v0`.`BillingAddress_AddressLine2` AS `BillingAddress_AddressLine20`, `v0`.`BillingAddress_ZipCode` AS `BillingAddress_ZipCode0`, `v0`.`BillingAddress_Country_Code` AS `BillingAddress_Country_Code0`, `v0`.`BillingAddress_Country_FullName` AS `BillingAddress_Country_FullName0`
+    FROM `ValuedCustomer` AS `v`
+    CROSS JOIN `ValuedCustomer` AS `v0`
+) AS `t`
+""");
+    }
+
+    public override async Task Project_same_entity_with_struct_nested_complex_type_twice_with_pushdown(bool async)
+    {
+        await base.Project_same_entity_with_struct_nested_complex_type_twice_with_pushdown(async);
+
+        AssertSql(
+"""
+SELECT `t`.`Id`, `t`.`Name`, `t`.`BillingAddress_AddressLine1`, `t`.`BillingAddress_AddressLine2`, `t`.`BillingAddress_ZipCode`, `t`.`BillingAddress_Country_Code`, `t`.`BillingAddress_Country_FullName`, `t`.`ShippingAddress_AddressLine1`, `t`.`ShippingAddress_AddressLine2`, `t`.`ShippingAddress_ZipCode`, `t`.`ShippingAddress_Country_Code`, `t`.`ShippingAddress_Country_FullName`, `t`.`Id0`, `t`.`Name0`, `t`.`BillingAddress_AddressLine10`, `t`.`BillingAddress_AddressLine20`, `t`.`BillingAddress_ZipCode0`, `t`.`BillingAddress_Country_Code0`, `t`.`BillingAddress_Country_FullName0`, `t`.`ShippingAddress_AddressLine10`, `t`.`ShippingAddress_AddressLine20`, `t`.`ShippingAddress_ZipCode0`, `t`.`ShippingAddress_Country_Code0`, `t`.`ShippingAddress_Country_FullName0`
+FROM (
+    SELECT DISTINCT `v`.`Id`, `v`.`Name`, `v`.`BillingAddress_AddressLine1`, `v`.`BillingAddress_AddressLine2`, `v`.`BillingAddress_ZipCode`, `v`.`BillingAddress_Country_Code`, `v`.`BillingAddress_Country_FullName`, `v`.`ShippingAddress_AddressLine1`, `v`.`ShippingAddress_AddressLine2`, `v`.`ShippingAddress_ZipCode`, `v`.`ShippingAddress_Country_Code`, `v`.`ShippingAddress_Country_FullName`, `v0`.`Id` AS `Id0`, `v0`.`Name` AS `Name0`, `v0`.`BillingAddress_AddressLine1` AS `BillingAddress_AddressLine10`, `v0`.`BillingAddress_AddressLine2` AS `BillingAddress_AddressLine20`, `v0`.`BillingAddress_ZipCode` AS `BillingAddress_ZipCode0`, `v0`.`BillingAddress_Country_Code` AS `BillingAddress_Country_Code0`, `v0`.`BillingAddress_Country_FullName` AS `BillingAddress_Country_FullName0`, `v0`.`ShippingAddress_AddressLine1` AS `ShippingAddress_AddressLine10`, `v0`.`ShippingAddress_AddressLine2` AS `ShippingAddress_AddressLine20`, `v0`.`ShippingAddress_ZipCode` AS `ShippingAddress_ZipCode0`, `v0`.`ShippingAddress_Country_Code` AS `ShippingAddress_Country_Code0`, `v0`.`ShippingAddress_Country_FullName` AS `ShippingAddress_Country_FullName0`
+    FROM `ValuedCustomer` AS `v`
+    CROSS JOIN `ValuedCustomer` AS `v0`
+) AS `t`
+""");
+    }
+
+    public override async Task Project_same_struct_nested_complex_type_twice_with_double_pushdown(bool async)
+    {
+        await base.Project_same_struct_nested_complex_type_twice_with_double_pushdown(async);
+
+        AssertSql(
+"""
+@__p_0='50'
+
+SELECT `t0`.`BillingAddress_AddressLine1`, `t0`.`BillingAddress_AddressLine2`, `t0`.`BillingAddress_ZipCode`, `t0`.`BillingAddress_Country_Code`, `t0`.`BillingAddress_Country_FullName`, `t0`.`BillingAddress_AddressLine10`, `t0`.`BillingAddress_AddressLine20`, `t0`.`BillingAddress_ZipCode0`, `t0`.`BillingAddress_Country_Code0`, `t0`.`BillingAddress_Country_FullName0`
+FROM (
+    SELECT DISTINCT `t`.`BillingAddress_AddressLine1`, `t`.`BillingAddress_AddressLine2`, `t`.`BillingAddress_ZipCode`, `t`.`BillingAddress_Country_Code`, `t`.`BillingAddress_Country_FullName`, `t`.`BillingAddress_AddressLine10`, `t`.`BillingAddress_AddressLine20`, `t`.`BillingAddress_ZipCode0`, `t`.`BillingAddress_Country_Code0`, `t`.`BillingAddress_Country_FullName0`
+    FROM (
+        SELECT `v`.`BillingAddress_AddressLine1`, `v`.`BillingAddress_AddressLine2`, `v`.`BillingAddress_ZipCode`, `v`.`BillingAddress_Country_Code`, `v`.`BillingAddress_Country_FullName`, `v0`.`BillingAddress_AddressLine1` AS `BillingAddress_AddressLine10`, `v0`.`BillingAddress_AddressLine2` AS `BillingAddress_AddressLine20`, `v0`.`BillingAddress_ZipCode` AS `BillingAddress_ZipCode0`, `v0`.`BillingAddress_Country_Code` AS `BillingAddress_Country_Code0`, `v0`.`BillingAddress_Country_FullName` AS `BillingAddress_Country_FullName0`
+        FROM `ValuedCustomer` AS `v`
+        CROSS JOIN `ValuedCustomer` AS `v0`
+        ORDER BY `v`.`Id`, `v0`.`Id`
+        LIMIT @__p_0
+    ) AS `t`
+) AS `t0`
+""");
+    }
+
+    public override async Task Project_same_entity_with_struct_nested_complex_type_twice_with_double_pushdown(bool async)
+    {
+        await base.Project_same_entity_with_struct_nested_complex_type_twice_with_double_pushdown(async);
+
+        AssertSql(
+"""
+@__p_0='50'
+
+SELECT `t0`.`Id`, `t0`.`Name`, `t0`.`BillingAddress_AddressLine1`, `t0`.`BillingAddress_AddressLine2`, `t0`.`BillingAddress_ZipCode`, `t0`.`BillingAddress_Country_Code`, `t0`.`BillingAddress_Country_FullName`, `t0`.`ShippingAddress_AddressLine1`, `t0`.`ShippingAddress_AddressLine2`, `t0`.`ShippingAddress_ZipCode`, `t0`.`ShippingAddress_Country_Code`, `t0`.`ShippingAddress_Country_FullName`, `t0`.`Id0`, `t0`.`Name0`, `t0`.`BillingAddress_AddressLine10`, `t0`.`BillingAddress_AddressLine20`, `t0`.`BillingAddress_ZipCode0`, `t0`.`BillingAddress_Country_Code0`, `t0`.`BillingAddress_Country_FullName0`, `t0`.`ShippingAddress_AddressLine10`, `t0`.`ShippingAddress_AddressLine20`, `t0`.`ShippingAddress_ZipCode0`, `t0`.`ShippingAddress_Country_Code0`, `t0`.`ShippingAddress_Country_FullName0`
+FROM (
+    SELECT DISTINCT `t`.`Id`, `t`.`Name`, `t`.`BillingAddress_AddressLine1`, `t`.`BillingAddress_AddressLine2`, `t`.`BillingAddress_ZipCode`, `t`.`BillingAddress_Country_Code`, `t`.`BillingAddress_Country_FullName`, `t`.`ShippingAddress_AddressLine1`, `t`.`ShippingAddress_AddressLine2`, `t`.`ShippingAddress_ZipCode`, `t`.`ShippingAddress_Country_Code`, `t`.`ShippingAddress_Country_FullName`, `t`.`Id0`, `t`.`Name0`, `t`.`BillingAddress_AddressLine10`, `t`.`BillingAddress_AddressLine20`, `t`.`BillingAddress_ZipCode0`, `t`.`BillingAddress_Country_Code0`, `t`.`BillingAddress_Country_FullName0`, `t`.`ShippingAddress_AddressLine10`, `t`.`ShippingAddress_AddressLine20`, `t`.`ShippingAddress_ZipCode0`, `t`.`ShippingAddress_Country_Code0`, `t`.`ShippingAddress_Country_FullName0`
+    FROM (
+        SELECT `v`.`Id`, `v`.`Name`, `v`.`BillingAddress_AddressLine1`, `v`.`BillingAddress_AddressLine2`, `v`.`BillingAddress_ZipCode`, `v`.`BillingAddress_Country_Code`, `v`.`BillingAddress_Country_FullName`, `v`.`ShippingAddress_AddressLine1`, `v`.`ShippingAddress_AddressLine2`, `v`.`ShippingAddress_ZipCode`, `v`.`ShippingAddress_Country_Code`, `v`.`ShippingAddress_Country_FullName`, `v0`.`Id` AS `Id0`, `v0`.`Name` AS `Name0`, `v0`.`BillingAddress_AddressLine1` AS `BillingAddress_AddressLine10`, `v0`.`BillingAddress_AddressLine2` AS `BillingAddress_AddressLine20`, `v0`.`BillingAddress_ZipCode` AS `BillingAddress_ZipCode0`, `v0`.`BillingAddress_Country_Code` AS `BillingAddress_Country_Code0`, `v0`.`BillingAddress_Country_FullName` AS `BillingAddress_Country_FullName0`, `v0`.`ShippingAddress_AddressLine1` AS `ShippingAddress_AddressLine10`, `v0`.`ShippingAddress_AddressLine2` AS `ShippingAddress_AddressLine20`, `v0`.`ShippingAddress_ZipCode` AS `ShippingAddress_ZipCode0`, `v0`.`ShippingAddress_Country_Code` AS `ShippingAddress_Country_Code0`, `v0`.`ShippingAddress_Country_FullName` AS `ShippingAddress_Country_FullName0`
+        FROM `ValuedCustomer` AS `v`
+        CROSS JOIN `ValuedCustomer` AS `v0`
+        ORDER BY `v`.`Id`, `v0`.`Id`
+        LIMIT @__p_0
+    ) AS `t`
+) AS `t0`
+""");
+    }
+
+    public override async Task Union_of_same_entity_with_nested_complex_type_projected_twice_with_pushdown(bool async)
+    {
+        await base.Union_of_same_entity_with_nested_complex_type_projected_twice_with_pushdown(async);
+
+        AssertSql(
+"""
+@__p_0='50'
+
+SELECT `t`.`Id`, `t`.`Name`, `t`.`BillingAddress_AddressLine1`, `t`.`BillingAddress_AddressLine2`, `t`.`BillingAddress_ZipCode`, `t`.`BillingAddress_Country_Code`, `t`.`BillingAddress_Country_FullName`, `t`.`ShippingAddress_AddressLine1`, `t`.`ShippingAddress_AddressLine2`, `t`.`ShippingAddress_ZipCode`, `t`.`ShippingAddress_Country_Code`, `t`.`ShippingAddress_Country_FullName`, `t`.`Id0`, `t`.`Name0`, `t`.`BillingAddress_AddressLine10`, `t`.`BillingAddress_AddressLine20`, `t`.`BillingAddress_ZipCode0`, `t`.`BillingAddress_Country_Code0`, `t`.`BillingAddress_Country_FullName0`, `t`.`ShippingAddress_AddressLine10`, `t`.`ShippingAddress_AddressLine20`, `t`.`ShippingAddress_ZipCode0`, `t`.`ShippingAddress_Country_Code0`, `t`.`ShippingAddress_Country_FullName0`
+FROM (
+    SELECT `c`.`Id`, `c`.`Name`, `c`.`BillingAddress_AddressLine1`, `c`.`BillingAddress_AddressLine2`, `c`.`BillingAddress_ZipCode`, `c`.`BillingAddress_Country_Code`, `c`.`BillingAddress_Country_FullName`, `c`.`ShippingAddress_AddressLine1`, `c`.`ShippingAddress_AddressLine2`, `c`.`ShippingAddress_ZipCode`, `c`.`ShippingAddress_Country_Code`, `c`.`ShippingAddress_Country_FullName`, `c0`.`Id` AS `Id0`, `c0`.`Name` AS `Name0`, `c0`.`BillingAddress_AddressLine1` AS `BillingAddress_AddressLine10`, `c0`.`BillingAddress_AddressLine2` AS `BillingAddress_AddressLine20`, `c0`.`BillingAddress_ZipCode` AS `BillingAddress_ZipCode0`, `c0`.`BillingAddress_Country_Code` AS `BillingAddress_Country_Code0`, `c0`.`BillingAddress_Country_FullName` AS `BillingAddress_Country_FullName0`, `c0`.`ShippingAddress_AddressLine1` AS `ShippingAddress_AddressLine10`, `c0`.`ShippingAddress_AddressLine2` AS `ShippingAddress_AddressLine20`, `c0`.`ShippingAddress_ZipCode` AS `ShippingAddress_ZipCode0`, `c0`.`ShippingAddress_Country_Code` AS `ShippingAddress_Country_Code0`, `c0`.`ShippingAddress_Country_FullName` AS `ShippingAddress_Country_FullName0`
+    FROM `Customer` AS `c`
+    CROSS JOIN `Customer` AS `c0`
+    UNION
+    SELECT `c1`.`Id`, `c1`.`Name`, `c1`.`BillingAddress_AddressLine1`, `c1`.`BillingAddress_AddressLine2`, `c1`.`BillingAddress_ZipCode`, `c1`.`BillingAddress_Country_Code`, `c1`.`BillingAddress_Country_FullName`, `c1`.`ShippingAddress_AddressLine1`, `c1`.`ShippingAddress_AddressLine2`, `c1`.`ShippingAddress_ZipCode`, `c1`.`ShippingAddress_Country_Code`, `c1`.`ShippingAddress_Country_FullName`, `c2`.`Id` AS `Id0`, `c2`.`Name` AS `Name0`, `c2`.`BillingAddress_AddressLine1` AS `BillingAddress_AddressLine10`, `c2`.`BillingAddress_AddressLine2` AS `BillingAddress_AddressLine20`, `c2`.`BillingAddress_ZipCode` AS `BillingAddress_ZipCode0`, `c2`.`BillingAddress_Country_Code` AS `BillingAddress_Country_Code0`, `c2`.`BillingAddress_Country_FullName` AS `BillingAddress_Country_FullName0`, `c2`.`ShippingAddress_AddressLine1` AS `ShippingAddress_AddressLine10`, `c2`.`ShippingAddress_AddressLine2` AS `ShippingAddress_AddressLine20`, `c2`.`ShippingAddress_ZipCode` AS `ShippingAddress_ZipCode0`, `c2`.`ShippingAddress_Country_Code` AS `ShippingAddress_Country_Code0`, `c2`.`ShippingAddress_Country_FullName` AS `ShippingAddress_Country_FullName0`
+    FROM `Customer` AS `c1`
+    CROSS JOIN `Customer` AS `c2`
+) AS `t`
+ORDER BY `t`.`Id`, `t`.`Id0`
+LIMIT @__p_0
+""");
+    }
+
+    public override async Task Union_of_same_entity_with_nested_complex_type_projected_twice_with_double_pushdown(bool async)
+    {
+        await base.Union_of_same_entity_with_nested_complex_type_projected_twice_with_double_pushdown(async);
+
+        AssertSql(
+"""
+@__p_0='50'
+
+SELECT `t1`.`Id`, `t1`.`Name`, `t1`.`BillingAddress_AddressLine1`, `t1`.`BillingAddress_AddressLine2`, `t1`.`BillingAddress_ZipCode`, `t1`.`BillingAddress_Country_Code`, `t1`.`BillingAddress_Country_FullName`, `t1`.`ShippingAddress_AddressLine1`, `t1`.`ShippingAddress_AddressLine2`, `t1`.`ShippingAddress_ZipCode`, `t1`.`ShippingAddress_Country_Code`, `t1`.`ShippingAddress_Country_FullName`, `t1`.`Id0`, `t1`.`Name0`, `t1`.`BillingAddress_AddressLine10`, `t1`.`BillingAddress_AddressLine20`, `t1`.`BillingAddress_ZipCode0`, `t1`.`BillingAddress_Country_Code0`, `t1`.`BillingAddress_Country_FullName0`, `t1`.`ShippingAddress_AddressLine10`, `t1`.`ShippingAddress_AddressLine20`, `t1`.`ShippingAddress_ZipCode0`, `t1`.`ShippingAddress_Country_Code0`, `t1`.`ShippingAddress_Country_FullName0`
+FROM (
+    SELECT DISTINCT `t0`.`Id`, `t0`.`Name`, `t0`.`BillingAddress_AddressLine1`, `t0`.`BillingAddress_AddressLine2`, `t0`.`BillingAddress_ZipCode`, `t0`.`BillingAddress_Country_Code`, `t0`.`BillingAddress_Country_FullName`, `t0`.`ShippingAddress_AddressLine1`, `t0`.`ShippingAddress_AddressLine2`, `t0`.`ShippingAddress_ZipCode`, `t0`.`ShippingAddress_Country_Code`, `t0`.`ShippingAddress_Country_FullName`, `t0`.`Id0`, `t0`.`Name0`, `t0`.`BillingAddress_AddressLine10`, `t0`.`BillingAddress_AddressLine20`, `t0`.`BillingAddress_ZipCode0`, `t0`.`BillingAddress_Country_Code0`, `t0`.`BillingAddress_Country_FullName0`, `t0`.`ShippingAddress_AddressLine10`, `t0`.`ShippingAddress_AddressLine20`, `t0`.`ShippingAddress_ZipCode0`, `t0`.`ShippingAddress_Country_Code0`, `t0`.`ShippingAddress_Country_FullName0`
+    FROM (
+        SELECT `t`.`Id`, `t`.`Name`, `t`.`BillingAddress_AddressLine1`, `t`.`BillingAddress_AddressLine2`, `t`.`BillingAddress_ZipCode`, `t`.`BillingAddress_Country_Code`, `t`.`BillingAddress_Country_FullName`, `t`.`ShippingAddress_AddressLine1`, `t`.`ShippingAddress_AddressLine2`, `t`.`ShippingAddress_ZipCode`, `t`.`ShippingAddress_Country_Code`, `t`.`ShippingAddress_Country_FullName`, `t`.`Id0`, `t`.`Name0`, `t`.`BillingAddress_AddressLine10`, `t`.`BillingAddress_AddressLine20`, `t`.`BillingAddress_ZipCode0`, `t`.`BillingAddress_Country_Code0`, `t`.`BillingAddress_Country_FullName0`, `t`.`ShippingAddress_AddressLine10`, `t`.`ShippingAddress_AddressLine20`, `t`.`ShippingAddress_ZipCode0`, `t`.`ShippingAddress_Country_Code0`, `t`.`ShippingAddress_Country_FullName0`
+        FROM (
+            SELECT `c`.`Id`, `c`.`Name`, `c`.`BillingAddress_AddressLine1`, `c`.`BillingAddress_AddressLine2`, `c`.`BillingAddress_ZipCode`, `c`.`BillingAddress_Country_Code`, `c`.`BillingAddress_Country_FullName`, `c`.`ShippingAddress_AddressLine1`, `c`.`ShippingAddress_AddressLine2`, `c`.`ShippingAddress_ZipCode`, `c`.`ShippingAddress_Country_Code`, `c`.`ShippingAddress_Country_FullName`, `c0`.`Id` AS `Id0`, `c0`.`Name` AS `Name0`, `c0`.`BillingAddress_AddressLine1` AS `BillingAddress_AddressLine10`, `c0`.`BillingAddress_AddressLine2` AS `BillingAddress_AddressLine20`, `c0`.`BillingAddress_ZipCode` AS `BillingAddress_ZipCode0`, `c0`.`BillingAddress_Country_Code` AS `BillingAddress_Country_Code0`, `c0`.`BillingAddress_Country_FullName` AS `BillingAddress_Country_FullName0`, `c0`.`ShippingAddress_AddressLine1` AS `ShippingAddress_AddressLine10`, `c0`.`ShippingAddress_AddressLine2` AS `ShippingAddress_AddressLine20`, `c0`.`ShippingAddress_ZipCode` AS `ShippingAddress_ZipCode0`, `c0`.`ShippingAddress_Country_Code` AS `ShippingAddress_Country_Code0`, `c0`.`ShippingAddress_Country_FullName` AS `ShippingAddress_Country_FullName0`
+            FROM `Customer` AS `c`
+            CROSS JOIN `Customer` AS `c0`
+            UNION
+            SELECT `c1`.`Id`, `c1`.`Name`, `c1`.`BillingAddress_AddressLine1`, `c1`.`BillingAddress_AddressLine2`, `c1`.`BillingAddress_ZipCode`, `c1`.`BillingAddress_Country_Code`, `c1`.`BillingAddress_Country_FullName`, `c1`.`ShippingAddress_AddressLine1`, `c1`.`ShippingAddress_AddressLine2`, `c1`.`ShippingAddress_ZipCode`, `c1`.`ShippingAddress_Country_Code`, `c1`.`ShippingAddress_Country_FullName`, `c2`.`Id` AS `Id0`, `c2`.`Name` AS `Name0`, `c2`.`BillingAddress_AddressLine1` AS `BillingAddress_AddressLine10`, `c2`.`BillingAddress_AddressLine2` AS `BillingAddress_AddressLine20`, `c2`.`BillingAddress_ZipCode` AS `BillingAddress_ZipCode0`, `c2`.`BillingAddress_Country_Code` AS `BillingAddress_Country_Code0`, `c2`.`BillingAddress_Country_FullName` AS `BillingAddress_Country_FullName0`, `c2`.`ShippingAddress_AddressLine1` AS `ShippingAddress_AddressLine10`, `c2`.`ShippingAddress_AddressLine2` AS `ShippingAddress_AddressLine20`, `c2`.`ShippingAddress_ZipCode` AS `ShippingAddress_ZipCode0`, `c2`.`ShippingAddress_Country_Code` AS `ShippingAddress_Country_Code0`, `c2`.`ShippingAddress_Country_FullName` AS `ShippingAddress_Country_FullName0`
+            FROM `Customer` AS `c1`
+            CROSS JOIN `Customer` AS `c2`
+        ) AS `t`
+        ORDER BY `t`.`Id`, `t`.`Id0`
+        LIMIT @__p_0
+    ) AS `t0`
+) AS `t1`
+ORDER BY `t1`.`Id`, `t1`.`Id0`
+LIMIT @__p_0
+""");
+    }
+
+    public override async Task Union_of_same_nested_complex_type_projected_twice_with_pushdown(bool async)
+    {
+        await base.Union_of_same_nested_complex_type_projected_twice_with_pushdown(async);
+
+        AssertSql(
+"""
+@__p_0='50'
+
+SELECT `t`.`BillingAddress_AddressLine1`, `t`.`BillingAddress_AddressLine2`, `t`.`BillingAddress_ZipCode`, `t`.`BillingAddress_Country_Code`, `t`.`BillingAddress_Country_FullName`, `t`.`BillingAddress_AddressLine10`, `t`.`BillingAddress_AddressLine20`, `t`.`BillingAddress_ZipCode0`, `t`.`BillingAddress_Country_Code0`, `t`.`BillingAddress_Country_FullName0`
+FROM (
+    SELECT `c`.`BillingAddress_AddressLine1`, `c`.`BillingAddress_AddressLine2`, `c`.`BillingAddress_ZipCode`, `c`.`BillingAddress_Country_Code`, `c`.`BillingAddress_Country_FullName`, `c0`.`BillingAddress_AddressLine1` AS `BillingAddress_AddressLine10`, `c0`.`BillingAddress_AddressLine2` AS `BillingAddress_AddressLine20`, `c0`.`BillingAddress_ZipCode` AS `BillingAddress_ZipCode0`, `c0`.`BillingAddress_Country_Code` AS `BillingAddress_Country_Code0`, `c0`.`BillingAddress_Country_FullName` AS `BillingAddress_Country_FullName0`
+    FROM `Customer` AS `c`
+    CROSS JOIN `Customer` AS `c0`
+    UNION
+    SELECT `c1`.`BillingAddress_AddressLine1`, `c1`.`BillingAddress_AddressLine2`, `c1`.`BillingAddress_ZipCode`, `c1`.`BillingAddress_Country_Code`, `c1`.`BillingAddress_Country_FullName`, `c2`.`BillingAddress_AddressLine1` AS `BillingAddress_AddressLine10`, `c2`.`BillingAddress_AddressLine2` AS `BillingAddress_AddressLine20`, `c2`.`BillingAddress_ZipCode` AS `BillingAddress_ZipCode0`, `c2`.`BillingAddress_Country_Code` AS `BillingAddress_Country_Code0`, `c2`.`BillingAddress_Country_FullName` AS `BillingAddress_Country_FullName0`
+    FROM `Customer` AS `c1`
+    CROSS JOIN `Customer` AS `c2`
+) AS `t`
+ORDER BY `t`.`BillingAddress_ZipCode`, `t`.`BillingAddress_ZipCode0`
+LIMIT @__p_0
+""");
+    }
+
+    public override async Task Union_of_same_nested_complex_type_projected_twice_with_double_pushdown(bool async)
+    {
+        await base.Union_of_same_nested_complex_type_projected_twice_with_double_pushdown(async);
+
+        AssertSql(
+"""
+@__p_0='50'
+
+SELECT `t1`.`BillingAddress_AddressLine1`, `t1`.`BillingAddress_AddressLine2`, `t1`.`BillingAddress_ZipCode`, `t1`.`BillingAddress_Country_Code`, `t1`.`BillingAddress_Country_FullName`, `t1`.`BillingAddress_AddressLine10`, `t1`.`BillingAddress_AddressLine20`, `t1`.`BillingAddress_ZipCode0`, `t1`.`BillingAddress_Country_Code0`, `t1`.`BillingAddress_Country_FullName0`
+FROM (
+    SELECT DISTINCT `t0`.`BillingAddress_AddressLine1`, `t0`.`BillingAddress_AddressLine2`, `t0`.`BillingAddress_ZipCode`, `t0`.`BillingAddress_Country_Code`, `t0`.`BillingAddress_Country_FullName`, `t0`.`BillingAddress_AddressLine10`, `t0`.`BillingAddress_AddressLine20`, `t0`.`BillingAddress_ZipCode0`, `t0`.`BillingAddress_Country_Code0`, `t0`.`BillingAddress_Country_FullName0`
+    FROM (
+        SELECT `t`.`BillingAddress_AddressLine1`, `t`.`BillingAddress_AddressLine2`, `t`.`BillingAddress_ZipCode`, `t`.`BillingAddress_Country_Code`, `t`.`BillingAddress_Country_FullName`, `t`.`BillingAddress_AddressLine10`, `t`.`BillingAddress_AddressLine20`, `t`.`BillingAddress_ZipCode0`, `t`.`BillingAddress_Country_Code0`, `t`.`BillingAddress_Country_FullName0`
+        FROM (
+            SELECT `c`.`BillingAddress_AddressLine1`, `c`.`BillingAddress_AddressLine2`, `c`.`BillingAddress_ZipCode`, `c`.`BillingAddress_Country_Code`, `c`.`BillingAddress_Country_FullName`, `c0`.`BillingAddress_AddressLine1` AS `BillingAddress_AddressLine10`, `c0`.`BillingAddress_AddressLine2` AS `BillingAddress_AddressLine20`, `c0`.`BillingAddress_ZipCode` AS `BillingAddress_ZipCode0`, `c0`.`BillingAddress_Country_Code` AS `BillingAddress_Country_Code0`, `c0`.`BillingAddress_Country_FullName` AS `BillingAddress_Country_FullName0`
+            FROM `Customer` AS `c`
+            CROSS JOIN `Customer` AS `c0`
+            UNION
+            SELECT `c1`.`BillingAddress_AddressLine1`, `c1`.`BillingAddress_AddressLine2`, `c1`.`BillingAddress_ZipCode`, `c1`.`BillingAddress_Country_Code`, `c1`.`BillingAddress_Country_FullName`, `c2`.`BillingAddress_AddressLine1` AS `BillingAddress_AddressLine10`, `c2`.`BillingAddress_AddressLine2` AS `BillingAddress_AddressLine20`, `c2`.`BillingAddress_ZipCode` AS `BillingAddress_ZipCode0`, `c2`.`BillingAddress_Country_Code` AS `BillingAddress_Country_Code0`, `c2`.`BillingAddress_Country_FullName` AS `BillingAddress_Country_FullName0`
+            FROM `Customer` AS `c1`
+            CROSS JOIN `Customer` AS `c2`
+        ) AS `t`
+        ORDER BY `t`.`BillingAddress_ZipCode`, `t`.`BillingAddress_ZipCode0`
+        LIMIT @__p_0
+    ) AS `t0`
+) AS `t1`
+ORDER BY `t1`.`BillingAddress_ZipCode`, `t1`.`BillingAddress_ZipCode0`
+LIMIT @__p_0
+""");
+    }
+
+    public override async Task Same_entity_with_complex_type_projected_twice_with_pushdown_as_part_of_another_projection(bool async)
+    {
+        await base.Same_entity_with_complex_type_projected_twice_with_pushdown_as_part_of_another_projection(async);
+
+        AssertSql(
+"""
+SELECT `c`.`Id`, `t`.`Id`, `t`.`Name`, `t`.`BillingAddress_AddressLine1`, `t`.`BillingAddress_AddressLine2`, `t`.`BillingAddress_ZipCode`, `t`.`BillingAddress_Country_Code`, `t`.`BillingAddress_Country_FullName`, `t`.`ShippingAddress_AddressLine1`, `t`.`ShippingAddress_AddressLine2`, `t`.`ShippingAddress_ZipCode`, `t`.`ShippingAddress_Country_Code`, `t`.`ShippingAddress_Country_FullName`, `t`.`Id0`, `t`.`Name0`, `t`.`BillingAddress_AddressLine10`, `t`.`BillingAddress_AddressLine20`, `t`.`BillingAddress_ZipCode0`, `t`.`BillingAddress_Country_Code0`, `t`.`BillingAddress_Country_FullName0`, `t`.`ShippingAddress_AddressLine10`, `t`.`ShippingAddress_AddressLine20`, `t`.`ShippingAddress_ZipCode0`, `t`.`ShippingAddress_Country_Code0`, `t`.`ShippingAddress_Country_FullName0`, `t`.`c`
+FROM `Customer` AS `c`
+LEFT JOIN LATERAL (
+    SELECT `c0`.`Id`, `c0`.`Name`, `c0`.`BillingAddress_AddressLine1`, `c0`.`BillingAddress_AddressLine2`, `c0`.`BillingAddress_ZipCode`, `c0`.`BillingAddress_Country_Code`, `c0`.`BillingAddress_Country_FullName`, `c0`.`ShippingAddress_AddressLine1`, `c0`.`ShippingAddress_AddressLine2`, `c0`.`ShippingAddress_ZipCode`, `c0`.`ShippingAddress_Country_Code`, `c0`.`ShippingAddress_Country_FullName`, `c1`.`Id` AS `Id0`, `c1`.`Name` AS `Name0`, `c1`.`BillingAddress_AddressLine1` AS `BillingAddress_AddressLine10`, `c1`.`BillingAddress_AddressLine2` AS `BillingAddress_AddressLine20`, `c1`.`BillingAddress_ZipCode` AS `BillingAddress_ZipCode0`, `c1`.`BillingAddress_Country_Code` AS `BillingAddress_Country_Code0`, `c1`.`BillingAddress_Country_FullName` AS `BillingAddress_Country_FullName0`, `c1`.`ShippingAddress_AddressLine1` AS `ShippingAddress_AddressLine10`, `c1`.`ShippingAddress_AddressLine2` AS `ShippingAddress_AddressLine20`, `c1`.`ShippingAddress_ZipCode` AS `ShippingAddress_ZipCode0`, `c1`.`ShippingAddress_Country_Code` AS `ShippingAddress_Country_Code0`, `c1`.`ShippingAddress_Country_FullName` AS `ShippingAddress_Country_FullName0`, 1 AS `c`
+    FROM `Customer` AS `c0`
+    CROSS JOIN `Customer` AS `c1`
+    ORDER BY `c0`.`Id`, `c1`.`Id` DESC
+    LIMIT 1
+) AS `t` ON TRUE
+""");
+    }
+
+    public override async Task Same_complex_type_projected_twice_with_pushdown_as_part_of_another_projection(bool async)
+    {
+        await base.Same_complex_type_projected_twice_with_pushdown_as_part_of_another_projection(async);
+
+        AssertSql("");
+    }
+
+    public override async Task Projecting_property_of_complex_type_using_left_join_with_pushdown(bool async)
+    {
+        await base.Projecting_property_of_complex_type_using_left_join_with_pushdown(async);
+
+        AssertSql(
+"""
+SELECT `t`.`BillingAddress_ZipCode`
+FROM `CustomerGroup` AS `c`
+LEFT JOIN (
+    SELECT `c0`.`Id`, `c0`.`BillingAddress_ZipCode`
+    FROM `Customer` AS `c0`
+    WHERE `c0`.`Id` > 5
+) AS `t` ON `c`.`Id` = `t`.`Id`
+""");
+    }
+
+    public override async Task Projecting_complex_from_optional_navigation_using_conditional(bool async)
+    {
+        await base.Projecting_complex_from_optional_navigation_using_conditional(async);
+
+        AssertSql(
+"""
+@__p_0='20'
+
+SELECT `t0`.`ShippingAddress_ZipCode`
+FROM (
+    SELECT DISTINCT `t`.`ShippingAddress_AddressLine1`, `t`.`ShippingAddress_AddressLine2`, `t`.`ShippingAddress_ZipCode`, `t`.`ShippingAddress_Country_Code`, `t`.`ShippingAddress_Country_FullName`
+    FROM (
+        SELECT `c0`.`ShippingAddress_AddressLine1`, `c0`.`ShippingAddress_AddressLine2`, `c0`.`ShippingAddress_ZipCode`, `c0`.`ShippingAddress_Country_Code`, `c0`.`ShippingAddress_Country_FullName`
+        FROM `CustomerGroup` AS `c`
+        LEFT JOIN `Customer` AS `c0` ON `c`.`OptionalCustomerId` = `c0`.`Id`
+        ORDER BY `c0`.`ShippingAddress_ZipCode`
+        LIMIT @__p_0
+    ) AS `t`
+) AS `t0`
+""");
+    }
+
+    public override async Task Project_entity_with_complex_type_pushdown_and_then_left_join(bool async)
+    {
+        await base.Project_entity_with_complex_type_pushdown_and_then_left_join(async);
+
+        AssertSql(
+"""
+@__p_0='20'
+@__p_1='30'
+
+SELECT `t0`.`BillingAddress_ZipCode` AS `Zip1`, `t1`.`ShippingAddress_ZipCode` AS `Zip2`
+FROM (
+    SELECT DISTINCT `t`.`Id`, `t`.`Name`, `t`.`BillingAddress_AddressLine1`, `t`.`BillingAddress_AddressLine2`, `t`.`BillingAddress_ZipCode`, `t`.`BillingAddress_Country_Code`, `t`.`BillingAddress_Country_FullName`, `t`.`ShippingAddress_AddressLine1`, `t`.`ShippingAddress_AddressLine2`, `t`.`ShippingAddress_ZipCode`, `t`.`ShippingAddress_Country_Code`, `t`.`ShippingAddress_Country_FullName`
+    FROM (
+        SELECT `c`.`Id`, `c`.`Name`, `c`.`BillingAddress_AddressLine1`, `c`.`BillingAddress_AddressLine2`, `c`.`BillingAddress_ZipCode`, `c`.`BillingAddress_Country_Code`, `c`.`BillingAddress_Country_FullName`, `c`.`ShippingAddress_AddressLine1`, `c`.`ShippingAddress_AddressLine2`, `c`.`ShippingAddress_ZipCode`, `c`.`ShippingAddress_Country_Code`, `c`.`ShippingAddress_Country_FullName`
+        FROM `Customer` AS `c`
+        ORDER BY `c`.`Id`
+        LIMIT @__p_0
+    ) AS `t`
+) AS `t0`
+LEFT JOIN (
+    SELECT DISTINCT `t2`.`Id`, `t2`.`Name`, `t2`.`BillingAddress_AddressLine1`, `t2`.`BillingAddress_AddressLine2`, `t2`.`BillingAddress_ZipCode`, `t2`.`BillingAddress_Country_Code`, `t2`.`BillingAddress_Country_FullName`, `t2`.`ShippingAddress_AddressLine1`, `t2`.`ShippingAddress_AddressLine2`, `t2`.`ShippingAddress_ZipCode`, `t2`.`ShippingAddress_Country_Code`, `t2`.`ShippingAddress_Country_FullName`
+    FROM (
+        SELECT `c0`.`Id`, `c0`.`Name`, `c0`.`BillingAddress_AddressLine1`, `c0`.`BillingAddress_AddressLine2`, `c0`.`BillingAddress_ZipCode`, `c0`.`BillingAddress_Country_Code`, `c0`.`BillingAddress_Country_FullName`, `c0`.`ShippingAddress_AddressLine1`, `c0`.`ShippingAddress_AddressLine2`, `c0`.`ShippingAddress_ZipCode`, `c0`.`ShippingAddress_Country_Code`, `c0`.`ShippingAddress_Country_FullName`
+        FROM `Customer` AS `c0`
+        ORDER BY `c0`.`Id` DESC
+        LIMIT @__p_1
+    ) AS `t2`
+) AS `t1` ON `t0`.`Id` = `t1`.`Id`
+""");
+    }
+
     [ConditionalFact]
     public virtual void Check_all_tests_overridden()
         => TestHelpers.AssertAllMethodsOverridden(GetType());
diff --git a/test/EFCore.SingleStore.FunctionalTests/Query/NorthwindFunctionsQuerySingleStoreTest.SingleStore.cs b/test/EFCore.SingleStore.FunctionalTests/Query/NorthwindFunctionsQuerySingleStoreTest.SingleStore.cs
index b74bd2f2e..45a619f28 100644
--- a/test/EFCore.SingleStore.FunctionalTests/Query/NorthwindFunctionsQuerySingleStoreTest.SingleStore.cs
+++ b/test/EFCore.SingleStore.FunctionalTests/Query/NorthwindFunctionsQuerySingleStoreTest.SingleStore.cs
@@ -2,6 +2,7 @@
 using System.Linq;
 using System.Threading.Tasks;
 using Microsoft.EntityFrameworkCore.TestModels.Northwind;
+using EntityFrameworkCore.SingleStore.FunctionalTests.TestUtilities;
 using Xunit;
 
 namespace EntityFrameworkCore.SingleStore.FunctionalTests.Query
@@ -62,5 +63,23 @@ await AssertQuery(
 FROM `Customers` AS `c`
 WHERE RPAD(`c`.`CustomerID`, 8, 'c') = 'ALFKIccc'");
         }
+
+
+        [ConditionalTheory]
+        [MemberData(nameof(IsAsyncData))]
+        public virtual async Task Where_math_log_new_base2(bool async)
+        {
+            // The original `Where_math_log_new_base` test will succeed even if the number and base are swapped by accident.
+            await AssertQueryScalar(
+                async,
+                ss => ss.Set<OrderDetail>().Where(od => od.OrderID == 11077 && od.Discount > 0).Where(od => Math.Log(od.Discount, 7) < -1).Select(od => Math.Log(od.Discount, 7)));
+
+            AssertSql(
+                $"""
+                 SELECT LOG(7.0, {SingleStoreTestHelpers.CastAsDouble("`o`.`Discount`")})
+                 FROM `Order Details` AS `o`
+                 WHERE ((`o`.`OrderID` = 11077) AND (`o`.`Discount` > 0)) AND (LOG(7.0, {SingleStoreTestHelpers.CastAsDouble("`o`.`Discount`")}) < -1.0)
+                 """);
+        }
     }
 }
diff --git a/test/EFCore.SingleStore.FunctionalTests/Query/NorthwindFunctionsQuerySingleStoreTest.cs b/test/EFCore.SingleStore.FunctionalTests/Query/NorthwindFunctionsQuerySingleStoreTest.cs
index eef5342a3..83f7f68d7 100644
--- a/test/EFCore.SingleStore.FunctionalTests/Query/NorthwindFunctionsQuerySingleStoreTest.cs
+++ b/test/EFCore.SingleStore.FunctionalTests/Query/NorthwindFunctionsQuerySingleStoreTest.cs
@@ -680,7 +680,7 @@ public override async Task Where_math_log_new_base(bool async)
             AssertSql(
                 $@"SELECT `o`.`OrderID`, `o`.`ProductID`, `o`.`Discount`, `o`.`Quantity`, `o`.`UnitPrice`
 FROM `Order Details` AS `o`
-WHERE ((`o`.`OrderID` = 11077) AND (`o`.`Discount` > 0)) AND (LOG({SingleStoreTestHelpers.CastAsDouble("`o`.`Discount`")}, 7.0) < 0.0)");
+WHERE ((`o`.`OrderID` = 11077) AND (`o`.`Discount` > 0)) AND (LOG(7.0, {SingleStoreTestHelpers.CastAsDouble("`o`.`Discount`")}) < 0.0)");
         }
 
         public override async Task Where_math_sqrt(bool async)
@@ -2184,7 +2184,7 @@ public override async Task Where_mathf_log_new_base(bool async)
 """
 SELECT `o`.`OrderID`, `o`.`ProductID`, `o`.`Discount`, `o`.`Quantity`, `o`.`UnitPrice`
 FROM `Order Details` AS `o`
-WHERE ((`o`.`OrderID` = 11077) AND (`o`.`Discount` > 0)) AND (LOG(`o`.`Discount`, 7) < 0)
+WHERE ((`o`.`OrderID` = 11077) AND (`o`.`Discount` > 0)) AND (LOG(7, `o`.`Discount`) < 0)
 """);
         }
 
diff --git a/test/EFCore.SingleStore.FunctionalTests/Query/OperatorsQuerySingleStoreTest.cs b/test/EFCore.SingleStore.FunctionalTests/Query/OperatorsQuerySingleStoreTest.cs
index 0690a9842..24544e428 100644
--- a/test/EFCore.SingleStore.FunctionalTests/Query/OperatorsQuerySingleStoreTest.cs
+++ b/test/EFCore.SingleStore.FunctionalTests/Query/OperatorsQuerySingleStoreTest.cs
@@ -1,4 +1,5 @@
 using System;
+using System.Linq;
 using System.Threading.Tasks;
 using Microsoft.EntityFrameworkCore.Query;
 using Microsoft.EntityFrameworkCore.TestModels.Operators;
@@ -82,13 +83,31 @@ public override async Task Negate_on_column(bool async)
 
     public override async Task Double_negate_on_column()
     {
-        await base.Double_negate_on_column();
+        var contextFactory = await InitializeAsync<OperatorsContext>(seed: Seed);
+        using var context = contextFactory.CreateContext();
+
+        var expected = (from e in ExpectedData.OperatorEntitiesInt
+            where -(-e.Value) == e.Value
+            orderby e.Id
+            select e.Id).ToList();
+
+        var actual = (from e in context.Set<OperatorEntityInt>()
+            where -(-e.Value) == e.Value
+            orderby e.Id
+            select e.Id).ToList();
+
+        Assert.Equal(expected.Count, actual.Count);
+        for (var i = 0; i < expected.Count; i++)
+        {
+            Assert.Equal(expected[i], actual[i]);
+        }
 
         AssertSql(
 """
 SELECT `o`.`Id`
 FROM `OperatorEntityInt` AS `o`
 WHERE -(-`o`.`Value`) = `o`.`Value`
+ORDER BY `o`.`Id`
 """);
     }
 
diff --git a/test/EFCore.SingleStore.FunctionalTests/Query/PrimitiveCollectionsQuerySingleStoreTest.cs b/test/EFCore.SingleStore.FunctionalTests/Query/PrimitiveCollectionsQuerySingleStoreTest.cs
index 4dd921e0f..2f9ef57a3 100644
--- a/test/EFCore.SingleStore.FunctionalTests/Query/PrimitiveCollectionsQuerySingleStoreTest.cs
+++ b/test/EFCore.SingleStore.FunctionalTests/Query/PrimitiveCollectionsQuerySingleStoreTest.cs
@@ -1787,6 +1787,20 @@ public override async Task Parameter_collection_of_nullable_strings_Contains_nul
 """);
     }
 
+    public override async Task Column_collection_Count_with_predicate(bool async)
+    {
+        await base.Column_collection_Count_with_predicate(async);
+
+        AssertSql("");
+    }
+
+    public override async Task Column_collection_Where_Count(bool async)
+    {
+        await base.Column_collection_Where_Count(async);
+
+        AssertSql("");
+    }
+
     [ConditionalFact]
     public virtual void Check_all_tests_overridden()
         => TestHelpers.AssertAllMethodsOverridden(GetType());
diff --git a/test/EFCore.SingleStore.FunctionalTests/Query/SqlQuerySingleStoreTest.cs b/test/EFCore.SingleStore.FunctionalTests/Query/SqlQuerySingleStoreTest.cs
index 47ede1345..b9f9511d2 100644
--- a/test/EFCore.SingleStore.FunctionalTests/Query/SqlQuerySingleStoreTest.cs
+++ b/test/EFCore.SingleStore.FunctionalTests/Query/SqlQuerySingleStoreTest.cs
@@ -90,6 +90,7 @@ public override async Task SqlQueryRaw_queryable_composed_compiled_with_DbParame
         AssertSql(
 """
 customer='CONSH' (Nullable = false)
+
 SELECT `m`.`Address`, `m`.`City`, `m`.`CompanyName`, `m`.`ContactName`, `m`.`ContactTitle`, `m`.`Country`, `m`.`CustomerID`, `m`.`Fax`, `m`.`Phone`, `m`.`Region`, `m`.`PostalCode`
 FROM (
     SELECT * FROM `Customers` WHERE `CustomerID` = @customer
@@ -105,6 +106,7 @@ public override async Task SqlQueryRaw_queryable_composed_compiled_with_nameless
         AssertSql(
 """
 p0='CONSH' (Nullable = false)
+
 SELECT `m`.`Address`, `m`.`City`, `m`.`CompanyName`, `m`.`ContactName`, `m`.`ContactTitle`, `m`.`Country`, `m`.`CustomerID`, `m`.`Fax`, `m`.`Phone`, `m`.`Region`, `m`.`PostalCode`
 FROM (
     SELECT * FROM `Customers` WHERE `CustomerID` = @p0
@@ -210,6 +212,7 @@ public override async Task SqlQueryRaw_queryable_with_parameters(bool async)
 """
 p0='London' (Size = 4000)
 p1='Sales Representative' (Size = 4000)
+
 SELECT * FROM `Customers` WHERE `City` = @p0 AND `ContactTitle` = @p1
 """);
     }
@@ -222,6 +225,7 @@ public override async Task SqlQueryRaw_queryable_with_parameters_inline(bool asy
 """
 p0='London' (Size = 4000)
 p1='Sales Representative' (Size = 4000)
+
 SELECT * FROM `Customers` WHERE `City` = @p0 AND `ContactTitle` = @p1
 """);
     }
@@ -234,6 +238,7 @@ public override async Task SqlQuery_queryable_with_parameters_interpolated(bool
 """
 p0='London' (Size = 4000)
 p1='Sales Representative' (Size = 4000)
+
 SELECT * FROM `Customers` WHERE `City` = @p0 AND `ContactTitle` = @p1
 """);
     }
@@ -246,6 +251,7 @@ public override async Task SqlQuery_queryable_with_parameters_inline_interpolate
 """
 p0='London' (Size = 4000)
 p1='Sales Representative' (Size = 4000)
+
 SELECT * FROM `Customers` WHERE `City` = @p0 AND `ContactTitle` = @p1
 """);
     }
@@ -263,6 +269,7 @@ public override async Task SqlQueryRaw_queryable_with_null_parameter(bool async)
         AssertSql(
 """
 p0=NULL (Nullable = false)
+
 SELECT * FROM `Employees` WHERE `ReportsTo` = @p0 OR (`ReportsTo` IS NULL AND @p0 IS NULL)
 """);
     }
@@ -275,6 +282,7 @@ public override async Task<string> SqlQueryRaw_queryable_with_parameters_and_clo
 """
 p0='London' (Size = 4000)
 @__contactTitle_1='Sales Representative' (Size = 30)
+
 SELECT `m`.`Address`, `m`.`City`, `m`.`CompanyName`, `m`.`ContactName`, `m`.`ContactTitle`, `m`.`Country`, `m`.`CustomerID`, `m`.`Fax`, `m`.`Phone`, `m`.`Region`, `m`.`PostalCode`
 FROM (
     SELECT * FROM `Customers` WHERE `City` = @p0
@@ -307,12 +315,14 @@ public override async Task SqlQueryRaw_queryable_with_parameters_cache_key_inclu
 """
 p0='London' (Size = 4000)
 p1='Sales Representative' (Size = 4000)
+
 SELECT * FROM `Customers` WHERE `City` = @p0 AND `ContactTitle` = @p1
 """,
                 //
                 """
 p0='Madrid' (Size = 4000)
 p1='Accounting Manager' (Size = 4000)
+
 SELECT * FROM `Customers` WHERE `City` = @p0 AND `ContactTitle` = @p1
 """);
     }
@@ -392,6 +402,7 @@ public override async Task SqlQueryRaw_with_dbParameter(bool async)
         AssertSql(
 """
 @city='London' (Nullable = false)
+
 SELECT * FROM `Customers` WHERE `City` = @city
 """);
     }
@@ -402,6 +413,7 @@ public override async Task SqlQueryRaw_with_dbParameter_without_name_prefix(bool
         AssertSql(
 """
 city='London' (Nullable = false)
+
 SELECT * FROM `Customers` WHERE `City` = @city
 """);
     }
@@ -414,12 +426,14 @@ public override async Task SqlQueryRaw_with_dbParameter_mixed(bool async)
 """
 p0='London' (Size = 4000)
 @title='Sales Representative' (Nullable = false)
+
 SELECT * FROM `Customers` WHERE `City` = @p0 AND `ContactTitle` = @title
 """,
                 //
                 """
 @city='London' (Nullable = false)
 p1='Sales Representative' (Size = 4000)
+
 SELECT * FROM `Customers` WHERE `City` = @city AND `ContactTitle` = @p1
 """);
     }
@@ -431,11 +445,13 @@ public override async Task SqlQueryRaw_with_db_parameters_called_multiple_times(
         AssertSql(
 """
 @id='ALFKI' (Nullable = false)
+
 SELECT * FROM `Customers` WHERE `CustomerID` = @id
 """,
                 //
                 """
 @id='ALFKI' (Nullable = false)
+
 SELECT * FROM `Customers` WHERE `CustomerID` = @id
 """);
     }
@@ -447,6 +463,7 @@ public override async Task SqlQuery_with_inlined_db_parameter(bool async)
         AssertSql(
 """
 @somename='ALFKI' (Nullable = false)
+
 SELECT * FROM `Customers` WHERE `CustomerID` = @somename
 """);
     }
@@ -458,6 +475,7 @@ public override async Task SqlQuery_with_inlined_db_parameter_without_name_prefi
         AssertSql(
 """
 somename='ALFKI' (Nullable = false)
+
 SELECT * FROM `Customers` WHERE `CustomerID` = @somename
 """);
     }
@@ -469,6 +487,7 @@ public override async Task SqlQuery_parameterization_issue_12213(bool async)
         AssertSql(
 """
 p0='10300'
+
 SELECT `m`.`OrderID`
 FROM (
     SELECT * FROM `Orders` WHERE `OrderID` >= @p0
@@ -478,6 +497,7 @@ public override async Task SqlQuery_parameterization_issue_12213(bool async)
                 """
 @__max_1='10400'
 p0='10300'
+
 SELECT `m`.`OrderID`
 FROM (
     SELECT * FROM `Orders`
@@ -493,6 +513,7 @@ public override async Task SqlQuery_parameterization_issue_12213(bool async)
                 """
 @__max_1='10400'
 p0='10300'
+
 SELECT `m`.`OrderID`
 FROM (
     SELECT * FROM `Orders`
@@ -513,6 +534,7 @@ public override async Task SqlQueryRaw_does_not_parameterize_interpolated_string
         AssertSql(
 """
 p0='10250'
+
 SELECT * FROM `Orders` WHERE `OrderID` < @p0
 """);
     }
@@ -557,6 +579,7 @@ public override async Task SqlQueryRaw_in_subquery_with_dbParameter(bool async)
         AssertSql(
 """
 @city='London' (Nullable = false)
+
 SELECT `m`.`CustomerID`, `m`.`EmployeeID`, `m`.`Freight`, `m`.`OrderDate`, `m`.`OrderID`, `m`.`RequiredDate`, `m`.`ShipAddress`, `m`.`ShipCity`, `m`.`ShipCountry`, `m`.`ShipName`, `m`.`ShipPostalCode`, `m`.`ShipRegion`, `m`.`ShipVia`, `m`.`ShippedDate`
 FROM (
     SELECT * FROM `Orders`
@@ -577,6 +600,7 @@ public override async Task SqlQueryRaw_in_subquery_with_positional_dbParameter_w
         AssertSql(
 """
 p0='London' (Nullable = false)
+
 SELECT `m`.`CustomerID`, `m`.`EmployeeID`, `m`.`Freight`, `m`.`OrderDate`, `m`.`OrderID`, `m`.`RequiredDate`, `m`.`ShipAddress`, `m`.`ShipCity`, `m`.`ShipCountry`, `m`.`ShipName`, `m`.`ShipPostalCode`, `m`.`ShipRegion`, `m`.`ShipVia`, `m`.`ShippedDate`
 FROM (
     SELECT * FROM `Orders`
@@ -597,6 +621,7 @@ public override async Task SqlQueryRaw_in_subquery_with_positional_dbParameter_w
         AssertSql(
 """
 @city='London' (Nullable = false)
+
 SELECT `m`.`CustomerID`, `m`.`EmployeeID`, `m`.`Freight`, `m`.`OrderDate`, `m`.`OrderID`, `m`.`RequiredDate`, `m`.`ShipAddress`, `m`.`ShipCity`, `m`.`ShipCountry`, `m`.`ShipName`, `m`.`ShipPostalCode`, `m`.`ShipRegion`, `m`.`ShipVia`, `m`.`ShippedDate`
 FROM (
     SELECT * FROM `Orders`
@@ -618,6 +643,7 @@ public override async Task SqlQueryRaw_with_dbParameter_mixed_in_subquery(bool a
 """
 p0='London' (Size = 4000)
 @title='Sales Representative' (Nullable = false)
+
 SELECT `m`.`CustomerID`, `m`.`EmployeeID`, `m`.`Freight`, `m`.`OrderDate`, `m`.`OrderID`, `m`.`RequiredDate`, `m`.`ShipAddress`, `m`.`ShipCity`, `m`.`ShipCountry`, `m`.`ShipName`, `m`.`ShipPostalCode`, `m`.`ShipRegion`, `m`.`ShipVia`, `m`.`ShippedDate`
 FROM (
     SELECT * FROM `Orders`
@@ -633,6 +659,7 @@ public override async Task SqlQueryRaw_with_dbParameter_mixed_in_subquery(bool a
                 """
 @city='London' (Nullable = false)
 p1='Sales Representative' (Size = 4000)
+
 SELECT `m`.`CustomerID`, `m`.`EmployeeID`, `m`.`Freight`, `m`.`OrderDate`, `m`.`OrderID`, `m`.`RequiredDate`, `m`.`ShipAddress`, `m`.`ShipCity`, `m`.`ShipCountry`, `m`.`ShipName`, `m`.`ShipPostalCode`, `m`.`ShipRegion`, `m`.`ShipVia`, `m`.`ShippedDate`
 FROM (
     SELECT * FROM `Orders`
@@ -653,6 +680,7 @@ public override async Task Multiple_occurrences_of_SqlQuery_with_db_parameter_ad
         AssertSql(
 """
 city='Seattle' (Nullable = false)
+
 SELECT `m`.`Address`, `m`.`City`, `m`.`CompanyName`, `m`.`ContactName`, `m`.`ContactTitle`, `m`.`Country`, `m`.`CustomerID`, `m`.`Fax`, `m`.`Phone`, `m`.`Region`, `m`.`PostalCode`
 FROM (
     SELECT * FROM `Customers` WHERE `City` = @city
diff --git a/test/EFCore.SingleStore.FunctionalTests/Query/TPHInheritanceQuerySingleStoreFixture.cs b/test/EFCore.SingleStore.FunctionalTests/Query/TPHInheritanceQuerySingleStoreFixture.cs
index 6c1316a6a..5848accc3 100644
--- a/test/EFCore.SingleStore.FunctionalTests/Query/TPHInheritanceQuerySingleStoreFixture.cs
+++ b/test/EFCore.SingleStore.FunctionalTests/Query/TPHInheritanceQuerySingleStoreFixture.cs
@@ -1,10 +1,55 @@
 using Microsoft.EntityFrameworkCore.Query;
 using Microsoft.EntityFrameworkCore.TestUtilities;
 using EntityFrameworkCore.SingleStore.FunctionalTests.TestUtilities;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.TestModels.InheritanceModel;
 
 namespace EntityFrameworkCore.SingleStore.FunctionalTests.Query;
 
 public class TPHInheritanceQuerySingleStoreFixture : TPHInheritanceQueryFixture
 {
     protected override ITestStoreFactory TestStoreFactory =>  SingleStoreTestStoreFactory.Instance;
+
+    protected override void OnModelCreating(ModelBuilder modelBuilder, DbContext context)
+    {
+        base.OnModelCreating(modelBuilder, context);
+
+        // We're changing the data type of the fields from INT to BIGINT, because in SingleStore
+        // on a sharded (distributed) table, AUTO_INCREMENT can only be used on a BIGINT column
+        modelBuilder.Entity<Country>()
+            .Property(e => e.Id)
+            .HasColumnType("bigint");
+
+        modelBuilder.Entity<Drink>()
+            .Property(e => e.Id)
+            .HasColumnType("bigint");
+
+        modelBuilder.Entity<Animal>()
+            .Property(e => e.Id)
+            .HasColumnType("bigint");
+
+        modelBuilder.Entity<Coke>()
+            .Property(e => e.Id)
+            .HasColumnType("bigint");
+
+        modelBuilder.Entity<Lilt>()
+            .Property(e => e.Id)
+            .HasColumnType("bigint");
+
+        modelBuilder.Entity<Tea>()
+            .Property(e => e.Id)
+            .HasColumnType("bigint");
+
+        modelBuilder.Entity<Bird>()
+            .Property(e => e.Id)
+            .HasColumnType("bigint");
+
+        modelBuilder.Entity<Eagle>()
+            .Property(e => e.Id)
+            .HasColumnType("bigint");
+
+        modelBuilder.Entity<Kiwi>()
+            .Property(e => e.Id)
+            .HasColumnType("bigint");
+    }
 }
diff --git a/test/EFCore.SingleStore.FunctionalTests/Query/TPHInheritanceQuerySingleStoreTest.cs b/test/EFCore.SingleStore.FunctionalTests/Query/TPHInheritanceQuerySingleStoreTest.cs
index 245d9bb5d..e89cc2ac5 100644
--- a/test/EFCore.SingleStore.FunctionalTests/Query/TPHInheritanceQuerySingleStoreTest.cs
+++ b/test/EFCore.SingleStore.FunctionalTests/Query/TPHInheritanceQuerySingleStoreTest.cs
@@ -1,4 +1,7 @@
+using System.Threading.Tasks;
+using EntityFrameworkCore.SingleStore.Tests;
 using Microsoft.EntityFrameworkCore.Query;
+using Xunit;
 using Xunit.Abstractions;
 
 namespace EntityFrameworkCore.SingleStore.FunctionalTests.Query;
@@ -9,4 +12,37 @@ public TPHInheritanceQuerySingleStoreTest(TPHInheritanceQuerySingleStoreFixture
         : base(fixture, testOutputHelper)
     {
     }
+
+    [ConditionalFact(Skip = "Feature 'FOREIGN KEY' is not supported by SingleStore Distributed.")]
+    public override void Setting_foreign_key_to_a_different_type_throws()
+    {
+        base.Setting_foreign_key_to_a_different_type_throws();
+    }
+
+    [ConditionalTheory]
+    [MemberData(nameof(IsAsyncData))]
+    public override Task Can_include_prey(bool async)
+    {
+        // Skipping this test when running on Managed Service due to the specifics of
+        // how AUTO_INCREMENT works (https://docs.singlestore.com/cloud/reference/sql-reference/data-definition-language-ddl/create-table/#auto-increment-behavior)
+        if (AppConfig.ManagedService)
+        {
+            return Task.CompletedTask;
+        }
+
+        return base.Can_include_prey(async);
+    }
+
+    [ConditionalFact]
+    public override void Can_insert_update_delete()
+    {
+        // Skipping this test when running on Managed Service due to the specifics of
+        // how AUTO_INCREMENT works (https://docs.singlestore.com/cloud/reference/sql-reference/data-definition-language-ddl/create-table/#auto-increment-behavior)
+        if (AppConfig.ManagedService)
+        {
+            return;
+        }
+
+        base.Can_insert_update_delete();
+    }
 }
diff --git a/test/EFCore.SingleStore.FunctionalTests/SingleStoreConnectionStringOptionsValidatorTests.cs b/test/EFCore.SingleStore.FunctionalTests/SingleStoreConnectionStringOptionsValidatorTests.cs
index 53a832d0e..ba6f4919e 100644
--- a/test/EFCore.SingleStore.FunctionalTests/SingleStoreConnectionStringOptionsValidatorTests.cs
+++ b/test/EFCore.SingleStore.FunctionalTests/SingleStoreConnectionStringOptionsValidatorTests.cs
@@ -31,7 +31,8 @@ public void EnsureMandatoryOptions_AppendsConnectionAttributesWithoutRemovingExi
 
             Assert.Contains("foo:bar", parts);
             Assert.Contains("baz:qux", parts);
-            var programVersion = Assembly.GetExecutingAssembly().GetName().Version;
+
+            var programVersion = typeof(SingleStoreConnectionStringOptionsValidator).Assembly.GetName().Version;
             Assert.Contains(parts, p => p.StartsWith("_connector_name:SingleStore Entity Framework Core provider"));
             Assert.Contains(parts, p => p.StartsWith($"_connector_version:{programVersion}"));
         }
@@ -44,7 +45,6 @@ public void EnsureMandatoryOptions_DoesNotDuplicateConnectionAttributes_OnRepeat
             Assert.True(_validator.EnsureMandatoryOptions(ref cs));
             Assert.False(_validator.EnsureMandatoryOptions(ref cs));
 
-            var programVersion = Assembly.GetExecutingAssembly().GetName().Version;
             var parts = new SingleStoreConnectionStringBuilder(cs)
                 .ConnectionAttributes
                 .TrimEnd(',')
@@ -52,6 +52,7 @@ public void EnsureMandatoryOptions_DoesNotDuplicateConnectionAttributes_OnRepeat
                 .Select(p => p.Trim())
                 .ToArray();
 
+            var programVersion = typeof(SingleStoreConnectionStringOptionsValidator).Assembly.GetName().Version;
             Assert.Equal(1, parts.Count(p => p.StartsWith("_connector_name:SingleStore Entity Framework Core provider")));
             Assert.Equal(1, parts.Count(p => p.StartsWith($"_connector_version:{programVersion}")));
         }
@@ -72,6 +73,10 @@ public void EnsureMandatoryOptions_SetsMandatoryFlags_WhenMissing()
             var result = new SingleStoreConnectionStringBuilder(cs);
             Assert.True(result.AllowUserVariables);
             Assert.False(result.UseAffectedRows);
+
+            var programVersion = typeof(SingleStoreConnectionStringOptionsValidator).Assembly.GetName().Version;
+            Assert.Contains("_connector_name:SingleStore Entity Framework Core provider", result.ConnectionAttributes);
+            Assert.Contains($"_connector_version:{programVersion}", result.ConnectionAttributes);
         }
 
         [Fact]
@@ -85,9 +90,14 @@ public void EnsureMandatoryOptions_DbConnection_InjectsAttributesAndFlags()
             var result = new SingleStoreConnectionStringBuilder(conn.ConnectionString);
             Assert.True(result.AllowUserVariables);
             Assert.False(result.UseAffectedRows);
-            Assert.Contains("_connector_name:SingleStore Entity Framework Core provider", result.ConnectionAttributes);
-            var programVersion = Assembly.GetExecutingAssembly().GetName().Version;
-            Assert.Contains($"_connector_version:{programVersion}", result.ConnectionAttributes);
+
+            // NOTE: We intentionally don't assert ConnectionAttributes here.
+            // EnsureMandatoryOptions(DbConnection) is only allowed to mutate the connection string when it is safe to do so.
+            // In practice, EF Core (and the provider) may open the DbConnection before our validator runs (or a caller may pass
+            // an already-open connection)
+            // Assert.Contains("_connector_name:SingleStore Entity Framework Core provider", result.ConnectionAttributes);
+            // var programVersion = typeof(SingleStoreConnectionStringOptionsValidator).Assembly.GetName().Version;
+            // Assert.Contains($"_connector_version:{programVersion}", result.ConnectionAttributes);
         }
 
         [Fact]
diff --git a/test/EFCore.SingleStore.FunctionalTests/TestUtilities/SingleStoreTestStoreFactory.cs b/test/EFCore.SingleStore.FunctionalTests/TestUtilities/SingleStoreTestStoreFactory.cs
index 32d47c6aa..f1a31e51d 100644
--- a/test/EFCore.SingleStore.FunctionalTests/TestUtilities/SingleStoreTestStoreFactory.cs
+++ b/test/EFCore.SingleStore.FunctionalTests/TestUtilities/SingleStoreTestStoreFactory.cs
@@ -36,5 +36,6 @@ public override TestStore GetOrCreate(string storeName)
 
         public override IServiceCollection AddProviderServices(IServiceCollection serviceCollection)
             => serviceCollection.AddEntityFrameworkSingleStore();
+
     }
 }
diff --git a/test/EFCore.SingleStore.Tests/ValueGeneration/Internal/MysqlSequentialGuidValueGeneratorTest.cs b/test/EFCore.SingleStore.Tests/ValueGeneration/Internal/SingleStoreSequentialGuidValueGeneratorTest.cs
similarity index 98%
rename from test/EFCore.SingleStore.Tests/ValueGeneration/Internal/MysqlSequentialGuidValueGeneratorTest.cs
rename to test/EFCore.SingleStore.Tests/ValueGeneration/Internal/SingleStoreSequentialGuidValueGeneratorTest.cs
index 4aa196244..da733bbbe 100644
--- a/test/EFCore.SingleStore.Tests/ValueGeneration/Internal/MysqlSequentialGuidValueGeneratorTest.cs
+++ b/test/EFCore.SingleStore.Tests/ValueGeneration/Internal/SingleStoreSequentialGuidValueGeneratorTest.cs
@@ -9,7 +9,7 @@
 
 namespace EntityFrameworkCore.SingleStore.Tests.ValueGeneration.Internal
 {
-    public class MysqlSequentialGuidValueGeneratorTest
+    public class SingleStoreSequentialGuidValueGeneratorTest
     {
         private SingleStoreSequentialGuidValueGenerator GetGenerator(bool mysqlGuidFormatIsLittleEndianBinary16) {
             var connectionSettings = new Mock<SingleStoreConnectionSettings>();