Property encode JSON scalars in partial updates

And introduce new store type tests

Author: roji

src/EFCore.Relational/Properties/RelationalStrings.Designer.cs

@@ -433,6 +433,12 @@
   <data name="ExecuteOperationWithUnsupportedOperatorInSqlGeneration" xml:space="preserve">
     <value>The operation '{operation}' contains a select expression feature that isn't supported in the query SQL generator, but has been declared as supported by provider during translation phase. This is a bug in your EF Core provider, file an issue at https://aka.ms/efcorefeedback.</value>
   </data>
+  <data name="ExecuteUpdateCannotSetJsonPropertyToNonJsonColumn" xml:space="preserve">
+    <value>'ExecuteUpdate' cannot currently set a property in a JSON column to a regular, non-JSON column; see https://github.com/dotnet/efcore/issues/36688.</value>
+  </data>
+  <data name="ExecuteUpdateCannotSetJsonPropertyToArbitraryExpression" xml:space="preserve">
+    <value>'ExecuteUpdate' cannot currently set a property in a JSON column to arbitrary expressions; only constants, parameters and other JSON properties are supported; see https://github.com/dotnet/efcore/issues/36688.</value>
+  </data>
   <data name="ExecuteUpdateDeleteOnEntityNotMappedToTable" xml:space="preserve">
     <value>'ExecuteUpdate' or 'ExecuteDelete' was called on entity type '{entityType}', but that entity type is not mapped to a table.</value>
   </data>

src/EFCore.Relational/Properties/RelationalStrings.resx

@@ -123,6 +123,9 @@
   <data name="ApplyNotSupported" xml:space="preserve">
     <value>Translating this query requires the SQL APPLY operation, which is not supported on SQLite.</value>
   </data>
+  <data name="ExecuteUpdateJsonPartialUpdateDoesNotSupportUlong" xml:space="preserve">
+    <value>ExecuteUpdate partial updates of ulong properties within JSON columns is not supported.</value>
+  </data>
   <data name="DefaultNotSupported" xml:space="preserve">
     <value>Translating this operation requires the 'DEFAULT' keyword, which is not supported on SQLite.</value>
   </data>

src/EFCore.Relational/Query/RelationalQueryableMethodTranslatingExpressionVisitor.ExecuteUpdate.cs

@@ -580,6 +580,57 @@ [new PathSegment(translatedIndex)],
         }
     }
 
+    /// <summary>
+    ///     This is an internal API that supports the Entity Framework Core infrastructure and not subject to
+    ///     the same compatibility standards as public APIs. It may be changed or removed without notice in
+    ///     any release. You should only use it directly in your code with extreme caution and knowing that
+    ///     doing so can result in application failures when updating to a new Entity Framework Core release.
+    /// </summary>
+    protected override bool TrySerializeScalarToJson(
+        JsonScalarExpression target,
+        SqlExpression value,
+        [NotNullWhen(true)] out SqlExpression? jsonValue)
+    {
+        var providerClrType = (value.TypeMapping!.Converter?.ProviderClrType ?? value.Type).UnwrapNullableType();
+
+        // SQLite has no bool type, so if we simply sent the bool as-is, we'd get 1/0 in the JSON document.
+        // To get an actual unquoted true/false value, we pass "true"/"false" string through the json() minifier, which does this.
+        // See https://sqlite.org/forum/info/91d09974c3754ea6.
+        if (providerClrType == typeof(bool))
+        {
+            jsonValue = _sqlExpressionFactory.Function(
+                "json",
+                [
+                    value is SqlConstantExpression { Value: bool constant }
+                        ? _sqlExpressionFactory.Constant(constant ? "true" : "false")
+                        : _sqlExpressionFactory.Case(
+                        [
+                            new CaseWhenClause(
+                                _sqlExpressionFactory.Equal(value, _sqlExpressionFactory.Constant(true)),
+                                _sqlExpressionFactory.Constant("true")),
+                            new CaseWhenClause(
+                                _sqlExpressionFactory.Equal(value, _sqlExpressionFactory.Constant(false)),
+                                _sqlExpressionFactory.Constant("false"))
+                        ],
+                        elseResult: _sqlExpressionFactory.Constant("null"))
+                ],
+                nullable: true,
+                argumentsPropagateNullability: [true],
+                typeof(string),
+                _typeMappingSource.FindMapping(typeof(string)));
+
+            return true;
+        }
+
+        if (providerClrType == typeof(ulong))
+        {
+            // See #36689
+            throw new InvalidOperationException(SqliteStrings.ExecuteUpdateJsonPartialUpdateDoesNotSupportUlong);
+        }
+
+        return base.TrySerializeScalarToJson(target, value, out jsonValue);
+    }
+
     /// <summary>
     ///     This is an internal API that supports the Entity Framework Core infrastructure and not subject to
     ///     the same compatibility standards as public APIs. It may be changed or removed without notice in

src/EFCore.Sqlite.Core/Properties/SqliteStrings.Designer.cs

@@ -0,0 +1,16 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+namespace Microsoft.EntityFrameworkCore;
+
+public class StoreTypeCosmosTest : StoreTypeTestBase
+{
+    // #34395
+    public override Task ULong() => Task.CompletedTask;
+
+    protected override ITestStoreFactory TestStoreFactory => CosmosTestStoreFactory.Instance;
+
+    protected override DbContextOptionsBuilder AddOptions(DbContextOptionsBuilder builder)
+        => base.AddOptions(builder)
+            .ConfigureWarnings(o => o.Ignore(CosmosEventId.NoPartitionKeyDefined));
+}

src/EFCore.Sqlite.Core/Properties/SqliteStrings.resx

@@ -29,6 +29,7 @@ public class InMemoryComplianceTest : ComplianceTestBase
         typeof(NorthwindBulkUpdatesTestBase<>),
         typeof(JsonQueryTestBase<>),
         typeof(AdHocJsonQueryTestBase),
+        typeof(StoreTypeTestBase),
 
         // Relationships tests - not implemented for InMemory
         typeof(AssociationsCollectionTestBase<>),

src/EFCore.Sqlite.Core/Query/Internal/SqliteQueryableMethodTranslatingExpressionVisitor.cs

@@ -0,0 +1,101 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+namespace Microsoft.EntityFrameworkCore;
+
+public abstract class StoreTypeRelationalTestBase : StoreTypeTestBase
+{
+    protected override async Task TestType<T>(
+        T value,
+        T otherValue,
+        ContextFactory<DbContext> contextFactory,
+        Func<T, T, bool> comparer)
+    {
+        await base.TestType<T>(value, otherValue, contextFactory, comparer);
+
+        // Extra test scenarios for relational
+        await TestExecuteUpdateWithinJsonToParameter(contextFactory, value, otherValue, comparer);
+        await TestExecuteUpdateWithinJsonToConstant(contextFactory, value, otherValue, comparer);
+        await TestExecuteUpdateWithinJsonToJsonProperty(contextFactory, value, otherValue, comparer);
+        await TestExecuteUpdateWithinJsonToNonJsonColumn(contextFactory, value, otherValue, comparer);
+    }
+
+    protected virtual async Task TestExecuteUpdateWithinJsonToParameter<T>(
+        ContextFactory<DbContext> contextFactory,
+        T value,
+        T otherValue,
+        Func<T, T, bool> comparer)
+        => await TestHelpers.ExecuteWithStrategyInTransactionAsync(
+            contextFactory.CreateContext,
+            UseTransaction,
+            async context =>
+            {
+                await context.Set<StoreTypeEntity<T>>().ExecuteUpdateAsync(s => s.SetProperty(e => e.Container.Value, e => otherValue));
+                var result = await context.Set<StoreTypeEntity<T>>().Where(e => e.Id == 1).SingleAsync();
+                Assert.Equal(otherValue, result.Container.Value, comparer);
+            });
+
+    protected virtual async Task TestExecuteUpdateWithinJsonToConstant<T>(
+        ContextFactory<DbContext> contextFactory,
+        T value,
+        T otherValue,
+        Func<T, T, bool> comparer)
+        => await TestHelpers.ExecuteWithStrategyInTransactionAsync(
+            contextFactory.CreateContext,
+            UseTransaction,
+            async context =>
+            {
+                var parameter = Expression.Parameter(typeof(StoreTypeEntity<T>));
+                var valueExpression = Expression.Lambda<Func<StoreTypeEntity<T>, T>>(
+                    Expression.Constant(otherValue, typeof(T)),
+                    parameter);
+
+                await context.Set<StoreTypeEntity<T>>().ExecuteUpdateAsync(s => s.SetProperty(e => e.Container.Value, valueExpression));
+                var result = await context.Set<StoreTypeEntity<T>>().Where(e => e.Id == 1).SingleAsync();
+                Assert.Equal(otherValue, result.Container.Value, comparer);
+            });
+
+    protected virtual async Task TestExecuteUpdateWithinJsonToJsonProperty<T>(
+        ContextFactory<DbContext> contextFactory,
+        T value,
+        T otherValue,
+        Func<T, T, bool> comparer)
+        => await TestHelpers.ExecuteWithStrategyInTransactionAsync(
+            contextFactory.CreateContext,
+            UseTransaction,
+            async context =>
+            {
+                await context.Set<StoreTypeEntity<T>>().ExecuteUpdateAsync(s => s.SetProperty(e => e.Container.Value, e => e.Container.OtherValue));
+                var result = await context.Set<StoreTypeEntity<T>>().Where(e => e.Id == 1).SingleAsync();
+                Assert.Equal(otherValue, result.Container.Value, comparer);
+            });
+
+    protected virtual async Task TestExecuteUpdateWithinJsonToNonJsonColumn<T>(
+        ContextFactory<DbContext> contextFactory,
+        T value,
+        T otherValue,
+        Func<T, T, bool> comparer)
+        => await TestHelpers.ExecuteWithStrategyInTransactionAsync(
+            contextFactory.CreateContext,
+            UseTransaction,
+            async context =>
+            {
+                await context.Set<StoreTypeEntity<T>>().ExecuteUpdateAsync(s => s.SetProperty(e => e.Container.Value, e => e.OtherValue));
+                var result = await context.Set<StoreTypeEntity<T>>().Where(e => e.Id == 1).SingleAsync();
+                Assert.Equal(otherValue, result.Container.Value, comparer);
+            });
+
+    public override void OnModelCreating<T>(ModelBuilder modelBuilder)
+    {
+        base.OnModelCreating<T>(modelBuilder);
+
+        modelBuilder.Entity<StoreTypeEntity<T>>(b =>
+        {
+            b.ToTable("StoreTypeEntity");
+            b.ComplexProperty(e => e.Container, cb => cb.ToJson());
+        });
+    }
+
+    public override void UseTransaction(DatabaseFacade facade, IDbContextTransaction transaction)
+        => facade.UseTransaction(transaction.GetDbTransaction());
+}

test/EFCore.Cosmos.FunctionalTests/StoreTypeCosmosTest.cs

@@ -37,7 +37,7 @@ protected NonSharedModelTestBase()
     {
     }
 
-    protected NonSharedModelTestBase(NonSharedFixture fixture)
+    protected NonSharedModelTestBase(NonSharedFixture? fixture)
         => Fixture = fixture;
 
     public virtual Task InitializeAsync()