Throw proper exceptions for ExecuteUpdate on owned JSON

Author: roji

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

@@ -424,6 +424,9 @@
   <data name="ExecuteOperationOnKeylessEntityTypeWithUnsupportedOperator" xml:space="preserve">
     <value>The operation '{operation}' cannot be performed on keyless entity type '{entityType}', since it contains an operator not natively supported by the database provider.</value>
   </data>
+  <data name="ExecuteOperationOnOwnedJsonIsNotSupported" xml:space="preserve">
+    <value>'{operation}' used over owned type '{entityType}' which is mapped to JSON; '{operation}' on JSON-mapped owned entities is not supported. Consider mapping your type as a complex type instead.</value>
+  </data>
   <data name="ExecuteOperationOnTPC" xml:space="preserve">
     <value>The operation '{operation}' is being applied on entity type '{entityType}', which is using the TPC mapping strategy and is not a leaf type. 'ExecuteDelete'/'ExecuteUpdate' operations on entity types participating in TPC hierarchies is only supported for leaf types.</value>
   </data>

src/EFCore.Relational/Properties/RelationalStrings.resx

@@ -19,23 +19,27 @@ public partial class RelationalQueryableMethodTranslatingExpressionVisitor
             return null;
         }
 
-        var mappingStrategy = entityType.GetMappingStrategy();
-        if (mappingStrategy == RelationalAnnotationNames.TptMappingStrategy)
+        if (entityType.IsMappedToJson())
         {
             AddTranslationErrorDetails(
-                RelationalStrings.ExecuteOperationOnTPT(
-                    nameof(EntityFrameworkQueryableExtensions.ExecuteDelete), entityType.DisplayName()));
+                RelationalStrings.ExecuteOperationOnOwnedJsonIsNotSupported("ExecuteDelete", entityType.DisplayName()));
             return null;
         }
 
-        if (mappingStrategy == RelationalAnnotationNames.TpcMappingStrategy
-            && entityType.GetDirectlyDerivedTypes().Any())
+        switch (entityType.GetMappingStrategy())
         {
-            // We allow TPC is it is leaf type
-            AddTranslationErrorDetails(
-                RelationalStrings.ExecuteOperationOnTPC(
-                    nameof(EntityFrameworkQueryableExtensions.ExecuteDelete), entityType.DisplayName()));
-            return null;
+            case RelationalAnnotationNames.TptMappingStrategy:
+                AddTranslationErrorDetails(
+                    RelationalStrings.ExecuteOperationOnTPT(
+                        nameof(EntityFrameworkQueryableExtensions.ExecuteDelete), entityType.DisplayName()));
+                return null;
+
+            // Note that we do allow TPC if the target is a leaf type
+            case RelationalAnnotationNames.TpcMappingStrategy when entityType.GetDirectlyDerivedTypes().Any():
+                AddTranslationErrorDetails(
+                    RelationalStrings.ExecuteOperationOnTPC(
+                        nameof(EntityFrameworkQueryableExtensions.ExecuteDelete), entityType.DisplayName()));
+                return null;
         }
 
         // Find the table model that maps to the entity type; there must be exactly one (e.g. no entity splitting).

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

@@ -2,6 +2,7 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 
 using System.Diagnostics.CodeAnalysis;
+using Microsoft.EntityFrameworkCore.Metadata.Internal;
 using Microsoft.EntityFrameworkCore.Query.Internal;
 using Microsoft.EntityFrameworkCore.Query.SqlExpressions;
 using Microsoft.EntityFrameworkCore.Storage.Json;
@@ -279,6 +280,12 @@ protected virtual bool TryTranslateSetters(
                 return false;
             }
 
+            if (targetProperty.DeclaringType is IEntityType entityType && entityType.IsMappedToJson())
+            {
+                AddTranslationErrorDetails(RelationalStrings.ExecuteOperationOnOwnedJsonIsNotSupported("ExecuteUpdate", entityType.DisplayName()));
+                return false;
+            }
+
             // Hack: when returning a StructuralTypeShaperExpression, _sqlTranslator returns it wrapped by a
             // StructuralTypeReferenceExpression, which is supposed to be a private wrapper only with the SQL translator.
             // Call TranslateProjection to unwrap it (need to look into getting rid StructuralTypeReferenceExpression altogether).

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

@@ -0,0 +1,66 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using Microsoft.EntityFrameworkCore.BulkUpdates;
+
+namespace Microsoft.EntityFrameworkCore.Query.Associations.OwnedJson;
+
+public abstract class OwnedJsonBulkUpdateRelationalTestBase<TFixture> : BulkUpdatesTestBase<TFixture>
+    where TFixture : OwnedJsonRelationalFixtureBase, new()
+{
+    public OwnedJsonBulkUpdateRelationalTestBase(TFixture fixture, ITestOutputHelper testOutputHelper)
+        : base(fixture)
+    {
+        fixture.TestSqlLoggerFactory.Clear();
+        fixture.TestSqlLoggerFactory.SetTestOutputHelper(testOutputHelper);
+    }
+
+    // Bulk update is not supported with owned JSON.
+    // We just have a couple of tests here to verify that the correct exceptions are thrown, and don't extend
+    // the actual AssociationsBulkUpdateTestBase with all the different tests.
+
+    [ConditionalFact]
+    public virtual Task Delete_association()
+        => AssertTranslationFailedWithDetails(
+            RelationalStrings.ExecuteOperationOnOwnedJsonIsNotSupported("ExecuteDelete", "RootEntity.RequiredRelated#RelatedType"),
+            () => AssertDelete(
+                ss => ss.Set<RootEntity>().Select(c => c.RequiredRelated),
+                rowsAffectedCount: 0));
+
+    [ConditionalFact]
+    public virtual Task Update_property_inside_association()
+        => AssertTranslationFailedWithDetails(
+            RelationalStrings.ExecuteOperationOnOwnedJsonIsNotSupported("ExecuteUpdate", "RootEntity.RequiredRelated#RelatedType"),
+            () => AssertUpdate(
+                ss => ss.Set<RootEntity>(),
+                e => e,
+                s => s.SetProperty(c => c.RequiredRelated.String, "foo_updated"),
+                rowsAffectedCount: 0));
+
+    [ConditionalFact]
+    public virtual async Task Update_association()
+    {
+        var newNested = new NestedType
+        {
+            Name = "Updated nested name",
+            Int = 80,
+            String = "Updated nested string"
+        };
+
+        await AssertTranslationFailedWithDetails(
+            RelationalStrings.InvalidPropertyInSetProperty("x => x.RequiredRelated.RequiredNested"),
+            // RelationalStrings.ExecuteOperationOnOwnedJsonIsNotSupported("ExecuteUpdate", "RootEntity.RequiredRelated#RelatedType"),
+            () => AssertUpdate(
+                ss => ss.Set<RootEntity>(),
+                c => c,
+                s => s.SetProperty(x => x.RequiredRelated.RequiredNested, newNested),
+                rowsAffectedCount: 0));
+    }
+
+    protected static async Task AssertTranslationFailedWithDetails(string details, Func<Task> query)
+    {
+        var exception = await Assert.ThrowsAsync<InvalidOperationException>(query);
+        Assert.Contains(CoreStrings.NonQueryTranslationFailedWithDetails("", details)[21..], exception.Message);
+    }
+}
+

test/EFCore.Relational.Specification.Tests/Query/Associations/OwnedJson/OwnedJsonBulkUpdateRelationalTestBase.cs

@@ -0,0 +1,9 @@
+// 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.Query.Associations.OwnedJson;
+
+public class OwnedJsonBulkUpdateSqlServerTest(
+    OwnedJsonSqlServerFixture fixture,
+    ITestOutputHelper testOutputHelper)
+    : OwnedJsonBulkUpdateRelationalTestBase<OwnedJsonSqlServerFixture>(fixture, testOutputHelper);

test/EFCore.SqlServer.FunctionalTests/Query/Associations/OwnedJson/OwnedJsonBulkUpdateSqlServerTest.cs

@@ -0,0 +1,9 @@
+// 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.Query.Associations.OwnedJson;
+
+public class OwnedJsonBulkUpdateSqliteTest(
+    OwnedJsonSqliteFixture fixture,
+    ITestOutputHelper testOutputHelper)
+    : OwnedJsonBulkUpdateRelationalTestBase<OwnedJsonSqliteFixture>(fixture, testOutputHelper);