Implement ExecuteUpdate support for complex JSON

Closes #28776

Author: roji

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

@@ -979,6 +979,9 @@
   <data name="MissingResultSetWhenSaving" xml:space="preserve">
     <value>A result set was missing when reading the results of a SaveChanges operation; this may indicate that a stored procedure was configured to return results in the EF model, but did not. Check your stored procedure definitions.</value>
   </data>
+  <data name="MultipleColumnsWithSameJsonContainerName" xml:space="preserve">
+    <value>Entity type '{entityType}' is mapped to multiple columns with name '{columnName}', and one of them is configured as a JSON column. Assign different names to the columns.</value>
+  </data>
   <data name="ModificationCommandBatchAlreadyComplete" xml:space="preserve">
     <value>Commands cannot be added to a completed 'ModificationCommandBatch'.</value>
   </data>
@@ -1072,6 +1075,9 @@
   <data name="ParameterNotObjectArray" xml:space="preserve">
     <value>The value provided for parameter '{parameter}' cannot be used because it isn't assignable to type 'object[]'.</value>
   </data>
+  <data name="JsonPartialUpdateNotSupportedByProvider" xml:space="preserve">
+    <value>The provider in use does not support partial updates within JSON columns.</value>
+  </data>
   <data name="PendingAmbientTransaction" xml:space="preserve">
     <value>This connection was used with an ambient transaction. The original ambient transaction needs to be completed before this connection can be used outside of it.</value>
   </data>

src/EFCore.Relational/Properties/RelationalStrings.resx

@@ -0,0 +1,119 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System.Collections;
+using System.Text;
+using System.Text.Json;
+
+namespace Microsoft.EntityFrameworkCore.Query.Internal;
+
+/// <summary>
+///     This is an internal API that supports the Entity Framework Core infrastructure and not subject to
+///     the same compatibility standards as public APIs. It may be changed or removed without notice in
+///     any release. You should only use it directly in your code with extreme caution and knowing that
+///     doing so can result in application failures when updating to a new Entity Framework Core release.
+/// </summary>
+public static class RelationalJsonUtilities
+{
+    /// <summary>
+    ///     This is an internal API that supports the Entity Framework Core infrastructure and not subject to
+    ///     the same compatibility standards as public APIs. It may be changed or removed without notice in
+    ///     any release. You should only use it directly in your code with extreme caution and knowing that
+    ///     doing so can result in application failures when updating to a new Entity Framework Core release.
+    /// </summary>
+    public static readonly MethodInfo SerializeComplexTypeToJsonMethod =
+        typeof(RelationalJsonUtilities).GetTypeInfo().GetDeclaredMethod(nameof(SerializeComplexTypeToJson))!;
+
+    /// <summary>
+    ///     This is an internal API that supports the Entity Framework Core infrastructure and not subject to
+    ///     the same compatibility standards as public APIs. It may be changed or removed without notice in
+    ///     any release. You should only use it directly in your code with extreme caution and knowing that
+    ///     doing so can result in application failures when updating to a new Entity Framework Core release.
+    /// </summary>
+    public static string? SerializeComplexTypeToJson(IComplexType complexType, object? value, bool collection)
+    {
+        // Note that we treat toplevel null differently: we return a relational NULL for that case. For nested nulls,
+        // we return JSON null string (so you get { "foo": null })
+        if (value is null)
+        {
+            return null;
+        }
+
+        var stream = new MemoryStream();
+        var writer = new Utf8JsonWriter(stream, new JsonWriterOptions { Indented = false });
+
+        WriteJson(writer, complexType, value, collection);
+
+        writer.Flush();
+
+        return Encoding.UTF8.GetString(stream.ToArray());
+
+        void WriteJson(Utf8JsonWriter writer, IComplexType complexType, object? value, bool collection)
+        {
+            if (collection)
+            {
+                if (value is null)
+                {
+                    writer.WriteNullValue();
+
+                    return;
+                }
+
+                writer.WriteStartArray();
+
+                foreach (var element in (IEnumerable)value)
+                {
+                    WriteJsonObject(writer, complexType, element);
+                }
+
+                writer.WriteEndArray();
+                return;
+            }
+
+            WriteJsonObject(writer, complexType, value);
+        }
+
+        void WriteJsonObject(Utf8JsonWriter writer, IComplexType complexType, object? objectValue)
+        {
+            if (objectValue is null)
+            {
+                writer.WriteNullValue();
+                return;
+            }
+
+            writer.WriteStartObject();
+
+            foreach (var property in complexType.GetProperties())
+            {
+                var jsonPropertyName = property.GetJsonPropertyName();
+                Check.DebugAssert(jsonPropertyName is not null);
+                writer.WritePropertyName(jsonPropertyName);
+
+                var propertyValue = property.GetGetter().GetClrValue(objectValue);
+                if (propertyValue is null)
+                {
+                    writer.WriteNullValue();
+                }
+                else
+                {
+                    var jsonValueReaderWriter = property.GetJsonValueReaderWriter() ?? property.GetTypeMapping().JsonValueReaderWriter;
+                    Check.DebugAssert(jsonValueReaderWriter is not null, "Missing JsonValueReaderWriter on JSON property");
+                    jsonValueReaderWriter.ToJson(writer, propertyValue);
+                }
+            }
+
+            foreach (var complexProperty in complexType.GetComplexProperties())
+            {
+                var jsonPropertyName = complexProperty.GetJsonPropertyName();
+                Check.DebugAssert(jsonPropertyName is not null);
+                writer.WritePropertyName(jsonPropertyName);
+
+                var propertyValue = complexProperty.GetGetter().GetClrValue(objectValue);
+
+                WriteJson(writer, complexProperty.ComplexType, propertyValue, complexProperty.IsCollection);
+            }
+
+            writer.WriteEndObject();
+        }
+    }
+}

src/EFCore.Relational/Query/Internal/RelationalJsonUtilities.cs

@@ -1459,20 +1459,33 @@ protected override Expression VisitUpdate(UpdateExpression updateExpression)
                 || selectExpression.Tables[1] is CrossJoinExpression))
         {
             _relationalCommandBuilder.Append("UPDATE ");
+
             Visit(updateExpression.Table);
+
             _relationalCommandBuilder.AppendLine();
             _relationalCommandBuilder.Append("SET ");
-            _relationalCommandBuilder.Append(
-                $"{_sqlGenerationHelper.DelimitIdentifier(updateExpression.ColumnValueSetters[0].Column.Name)} = ");
-            Visit(updateExpression.ColumnValueSetters[0].Value);
-            using (_relationalCommandBuilder.Indent())
+
+            for (var i = 0; i < updateExpression.ColumnValueSetters.Count; i++)
             {
-                foreach (var columnValueSetter in updateExpression.ColumnValueSetters.Skip(1))
+                if (i == 1)
+                {
+                    Sql.IncrementIndent();
+                }
+
+                if (i > 0)
                 {
                     _relationalCommandBuilder.AppendLine(",");
-                    _relationalCommandBuilder.Append($"{_sqlGenerationHelper.DelimitIdentifier(columnValueSetter.Column.Name)} = ");
-                    Visit(columnValueSetter.Value);
                 }
+
+                var (column, value) = updateExpression.ColumnValueSetters[i];
+
+                _relationalCommandBuilder.Append(_sqlGenerationHelper.DelimitIdentifier(column.Name)).Append(" = ");
+                Visit(value);
+            }
+
+            if (updateExpression.ColumnValueSetters.Count > 1)
+            {
+                Sql.DecrementIndent();
             }
 
             var predicate = selectExpression.Predicate;