Use our new JSON serialization infra for partial updates (#31232)

In addition, when the database's partial update function (e.g.
JSON_MODIFY) accepts a non-JSON relational value (e.g. int), simply
send that value via the property's regular type mapping.

Author: roji

src/EFCore.Relational/Update/ModificationCommand.cs

@@ -325,11 +325,24 @@ private List<IColumnModification> GenerateColumnModifications()
                 var jsonColumnTypeMapping = jsonColumn.StoreTypeMapping;
                 var navigationValue = finalUpdatePathElement.ParentEntry.GetCurrentValue(navigation);
                 var jsonPathString = string.Join(".", updateInfo.Path.Select(x => x.PropertyName + (x.Ordinal != null ? "[" + x.Ordinal + "]" : "")));
-                object? value;
-                if (updateInfo.Property is not null)
+                if (updateInfo.Property is IProperty property)
                 {
-                    value = GenerateValueForSinglePropertyUpdate(updateInfo.Property, updateInfo.PropertyValue);
-                    jsonPathString = jsonPathString + "." + updateInfo.Property.GetJsonPropertyName();
+                    var columnModificationParameters = new ColumnModificationParameters(
+                        jsonColumn.Name,
+                        value: updateInfo.PropertyValue,
+                        property: property,
+                        columnType: jsonColumnTypeMapping.StoreType,
+                        jsonColumnTypeMapping,
+                        jsonPath: jsonPathString + "." + updateInfo.Property.GetJsonPropertyName(),
+                        read: false,
+                        write: true,
+                        key: false,
+                        condition: false,
+                        _sensitiveLoggingEnabled) { GenerateParameterName = _generateParameterName };
+
+                    ProcessSinglePropertyJsonUpdate(ref columnModificationParameters);
+
+                    columnModifications.Add(new ColumnModification(columnModificationParameters));
                 }
                 else
                 {
@@ -371,26 +384,24 @@ private List<IColumnModification> GenerateColumnModifications()
 
                     writer.Flush();
 
-                    value = writer.BytesCommitted > 0
+                    var value = writer.BytesCommitted > 0
                         ? Encoding.UTF8.GetString(stream.ToArray())
                         : null;
-                }
 
-                var columnModificationParameters = new ColumnModificationParameters(
-                    jsonColumn.Name,
-                    value: value,
-                    property: updateInfo.Property,
-                    columnType: jsonColumnTypeMapping.StoreType,
-                    jsonColumnTypeMapping,
-                    jsonPath: jsonPathString,
-                    read: false,
-                    write: true,
-                    key: false,
-                    condition: false,
-                    _sensitiveLoggingEnabled)
-                { GenerateParameterName = _generateParameterName, };
-
-                columnModifications.Add(new ColumnModification(columnModificationParameters));
+                    columnModifications.Add(new ColumnModification(new ColumnModificationParameters(
+                            jsonColumn.Name,
+                            value: value,
+                            property: updateInfo.Property,
+                            columnType: jsonColumnTypeMapping.StoreType,
+                            jsonColumnTypeMapping,
+                            jsonPath: jsonPathString,
+                            read: false,
+                            write: true,
+                            key: false,
+                            condition: false,
+                            _sensitiveLoggingEnabled)
+                        { GenerateParameterName = _generateParameterName }));
+                }
             }
         }
 
@@ -659,7 +670,7 @@ void HandleColumnModification(IColumnMappingBase columnMapping)
             if (modifiedMembers.Count == 1)
             {
                 result.Property = modifiedMembers.Single().Metadata;
-                result.PropertyValue = entry.GetCurrentProviderValue(result.Property);
+                result.PropertyValue = entry.GetCurrentValue(result.Property);
             }
             else
             {
@@ -711,22 +722,56 @@ static JsonPartialUpdateInfo FindCommonJsonPartialUpdateInfo(
     }
 
     /// <summary>
-    ///     Generates value to use for update in case a single property is being updated.
+    ///     Performs processing specifically needed for column modifications that correspond to single-property JSON updates.
     /// </summary>
-    /// <param name="property">Property to be updated.</param>
-    /// <param name="propertyValue">Value object that the property will be updated to.</param>
-    /// <returns>Value that the property will be updated to.</returns>
-    [EntityFrameworkInternal]
-    protected virtual object? GenerateValueForSinglePropertyUpdate(IProperty property, object? propertyValue)
+    /// <remarks>
+    ///     By default, strings, numeric types and bool and sent as a regular relational parameter, since database functions responsible for
+    ///     patching JSON documents support this. Other types get converted to JSON via the normal means and sent as a string parameter.
+    /// </remarks>
+    protected virtual void ProcessSinglePropertyJsonUpdate(ref ColumnModificationParameters parameters)
     {
+        var property = parameters.Property!;
         var propertyProviderClrType = (property.GetTypeMapping().Converter?.ProviderClrType ?? property.ClrType).UnwrapNullableType();
 
-        return (propertyProviderClrType == typeof(DateTime)
-            || propertyProviderClrType == typeof(DateTimeOffset)
-            || propertyProviderClrType == typeof(TimeSpan)
-            || propertyProviderClrType == typeof(Guid))
-            ? JsonValue.Create(propertyValue)?.ToJsonString().Replace("\"", "")
-            : propertyValue;
+        // On most databases, the function which patches a JSON document (e.g. SQL Server JSON_MODIFY) accepts relational string, numeric
+        // and bool types directly, without serializing it to a JSON string. So by default, for those cases simply return the value as-is,
+        // with the property's type mapping which will take care of sending the parameter with the relational value.
+        // Note that we haven't yet applied a value converter if one is configured, in order to allow for it to get applied later with
+        // the regular parameter flow.
+        if (propertyProviderClrType == typeof(string)
+            || propertyProviderClrType == typeof(bool)
+            || propertyProviderClrType.IsNumeric())
+        {
+            parameters = parameters with { TypeMapping = property.GetRelationalTypeMapping() };
+            return;
+        }
+
+        // Other, non-JSON-native types need to be serialized to a JSON string.
+
+        // First, apply value conversion to get the provider value
+        var value = property.GetTypeMapping().Converter is ValueConverter converter
+            ? converter.ConvertToProvider(parameters.Value)
+            : parameters.Value;
+
+        var stream = new MemoryStream();
+        var writer = new Utf8JsonWriter(stream, new JsonWriterOptions { Indented = false });
+
+        if (value is null)
+        {
+            writer.WriteNullValue();
+        }
+        else
+        {
+            property.GetJsonValueReaderWriter()!.ToJson(writer, value);
+        }
+
+        writer.Flush();
+
+        // The JSON string contains enclosing quotes (JSON string representation), remove these.
+        parameters = parameters with
+        {
+            Value = Encoding.UTF8.GetString(stream.ToArray())[1..^1]
+        };
     }
 
     private void WriteJson(

src/EFCore.SqlServer/Update/Internal/SqlServerModificationCommand.cs

@@ -34,34 +34,4 @@ public SqlServerModificationCommand(in NonTrackedModificationCommandParameters m
         : base(modificationCommandParameters)
     {
     }
-
-    /// <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 object? GenerateValueForSinglePropertyUpdate(IProperty property, object? propertyValue)
-    {
-        var propertyProviderClrType = (property.GetTypeMapping().Converter?.ProviderClrType ?? property.ClrType).UnwrapNullableType();
-
-        // when we generate SqlParameter when updating single property in JSON entity
-        // we always use SqlServerJsonTypeMapping as type mapping for the parameter
-        // (since we don't have dedicated type mapping for individual JSON properties)
-        // later, when we generate DbParameter we assign the value and then the DbType from the type mapping.
-        // in case of byte value, when we assign the value to the DbParameter it sets its type to Byte and its size to 1
-        // then, we change DbType to String, but keep size as is
-        // so, if value was, say, 15 we initially generate DbParameter of type Byte, value 25 and size 1
-        // but when we change the type we end up with type String, value 25 and size 1, which effectively is "2"
-        // to mitigate this, we convert the value to string, to guarantee the correct parameter size.
-        // this can be removed when we have dedicated JSON type mapping for individual (leaf) properties
-        if (propertyProviderClrType == typeof(byte))
-        {
-            return JsonValue.Create(propertyValue)?.ToJsonString().Replace("\"", "");
-        }
-
-#pragma warning disable EF1001 // Internal EF Core API usage.
-        return base.GenerateValueForSinglePropertyUpdate(property, propertyValue);
-#pragma warning restore EF1001 // Internal EF Core API usage.
-    }
 }

src/EFCore.SqlServer/Update/Internal/SqlServerUpdateSqlGenerator.cs

@@ -154,24 +154,7 @@ protected override void AppendUpdateColumnValue(
 
             if (columnModification.Property != null)
             {
-                var propertyClrType = columnModification.Property.GetTypeMapping().Converter?.ProviderClrType
-                    ?? columnModification.Property.ClrType;
-
-                var needsTypeConversion = propertyClrType.IsNumeric() || propertyClrType == typeof(bool);
-
-                if (needsTypeConversion)
-                {
-                    stringBuilder.Append("CAST(");
-                }
-
                 base.AppendUpdateColumnValue(updateSqlGeneratorHelper, columnModification, stringBuilder, name, schema);
-
-                if (needsTypeConversion)
-                {
-                    stringBuilder.Append(" AS ");
-                    stringBuilder.Append(columnModification.Property.GetRelationalTypeMapping().StoreType);
-                    stringBuilder.Append(")");
-                }
             }
             else
             {

src/EFCore.Sqlite.Core/Update/Internal/SqliteModificationCommand.cs

@@ -39,22 +39,37 @@ public SqliteModificationCommand(in NonTrackedModificationCommandParameters modi
     ///     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 object? GenerateValueForSinglePropertyUpdate(IProperty property, object? propertyValue)
+    protected override void ProcessSinglePropertyJsonUpdate(ref ColumnModificationParameters parameters)
     {
+        var property = parameters.Property!;
+
         var propertyProviderClrType = (property.GetTypeMapping().Converter?.ProviderClrType ?? property.ClrType).UnwrapNullableType();
 
-        if (propertyProviderClrType == typeof(bool) && propertyValue is bool boolPropertyValue)
+        // 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.
+        // Here we convert the .NET bool to a "true"/"false" string, and SqliteUpdateSqlGenerator will add the enclosing json().
+        if (propertyProviderClrType == typeof(bool))
         {
-            // Sqlite converts true/false into native 0/1 when using json_extract
-            // so we convert those values to strings so that they stay as true/false
-            // which is what we want to store in json object in the end
-            return boolPropertyValue
-                ? "true"
-                : "false";
+            var value = property.GetTypeMapping().Converter is ValueConverter converter
+                ? converter.ConvertToProvider(parameters.Value)
+                : parameters.Value;
+
+            parameters = parameters with
+            {
+                Value = value switch
+                {
+                    true => "true",
+                    false => "false",
+                    _ => throw new Exception("IMPOSSIBLE")
+                }
+            };
+
+            return;
         }
 
 #pragma warning disable EF1001 // Internal EF Core API usage.
-        return base.GenerateValueForSinglePropertyUpdate(property, propertyValue);
+        base.ProcessSinglePropertyJsonUpdate(ref parameters);
 #pragma warning restore EF1001 // Internal EF Core API usage.
     }
 }

src/EFCore.Sqlite.Core/Update/Internal/SqliteUpdateSqlGenerator.cs

@@ -165,14 +165,13 @@ protected override void AppendUpdateColumnValue(
                 var providerClrType = (columnModification.Property.GetTypeMapping().Converter?.ProviderClrType
                     ?? columnModification.Property.ClrType).UnwrapNullableType();
 
-                // special handling for bool
-                // json_extract converts true/false into native 0/1 values,
-                // but we want to store the values as true/false in JSON
-                // in order to do that we modify the parameter value to "true"/"false"
-                // and wrap json() function around it to avoid conversion to 0/1
+                // 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.
+                // SqliteModificationCommand converted the .NET bool to a "true"/"false" string, here we add the enclosing json().
                 //
-                // for decimal, sqlite generates string parameter for decimal values
-                // but don't want to store the values as strings, we use json to "unwrap" it
+                // For decimal, Microsoft.Data.Sqlite maps decimal to TEXT instead of to REAL, but we don't want decimals to be stored as
+                // strings inside JSON. So we again use json() to "unwrap" it.
                 if (providerClrType == typeof(bool) || providerClrType == typeof(decimal))
                 {
                     stringBuilder.Append("json(");