Merge release/9.0-staging to release/9.0 (#37294)

Author: AndriySvyryd

azure-pipelines-public.yml

@@ -93,7 +93,7 @@ stages:
           - job: macOS
             enablePublishTestResults: true
             pool:
-              vmImage: macOS-13
+              vmImage: macOS-15
             variables:
               # Rely on task Arcade injects, not auto-injected build step.
               - skipComponentGovernanceDetection: true
@@ -151,7 +151,7 @@ stages:
               - name: _HelixBuildConfig
                 value: $(_BuildConfig)
               - name: HelixTargetQueues
-                value: Windows.10.Amd64.Open;OSX.13.ARM64.Open;[email protected]/dotnet-buildtools/prereqs:ubuntu-20.04-helix-sqlserver-amd64
+                value: Windows.10.Amd64.Open;OSX.15.ARM64.Open;[email protected]/dotnet-buildtools/prereqs:ubuntu-20.04-helix-sqlserver-amd64
               - name: _HelixAccessToken
                 value: '' # Needed for public queues
             steps:

azure-pipelines.yml

@@ -140,7 +140,7 @@ extends:
           - job: macOS
             pool:
               name: Azure Pipelines
-              image: macOS-13
+              image: macOS-15
               os: macOS
             variables:
               # Rely on task Arcade injects, not auto-injected build step.
@@ -195,7 +195,7 @@ extends:
               - name: _HelixBuildConfig
                 value: $(_BuildConfig)
               - name: HelixTargetQueues
-                value: Windows.10.Amd64;OSX.13.ARM64;[email protected]/dotnet-buildtools/prereqs:ubuntu-20.04-helix-sqlserver-amd64
+                value: Windows.10.Amd64;OSX.15.ARM64;[email protected]/dotnet-buildtools/prereqs:ubuntu-20.04-helix-sqlserver-amd64
               - name: _HelixAccessToken
                 # Needed for internal queues
                 value: $(HelixApiAccessToken)

src/EFCore.Design/Migrations/Design/CSharpSnapshotGenerator.cs

@@ -2,6 +2,7 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 
 using System.Text;
+using System.Text.Json;
 using Microsoft.EntityFrameworkCore.Internal;
 using Microsoft.EntityFrameworkCore.Metadata.Internal;
 
@@ -837,6 +838,20 @@ protected virtual void GenerateEntityTypeAnnotations(
             .FilterIgnoredAnnotations(entityType.GetAnnotations())
             .ToDictionary(a => a.Name, a => a);
 
+        // Add ContainerColumnType annotation if entity is mapped to JSON but the type annotation is missing
+        if (annotations.ContainsKey(RelationalAnnotationNames.ContainerColumnName)
+            && !annotations.ContainsKey(RelationalAnnotationNames.ContainerColumnType))
+        {
+            var containerColumnType = entityType.GetContainerColumnType()
+                ?? Dependencies.RelationalTypeMappingSource.FindMapping(typeof(JsonElement))?.StoreType;
+            if (containerColumnType != null)
+            {
+                annotations[RelationalAnnotationNames.ContainerColumnType] = new Annotation(
+                    RelationalAnnotationNames.ContainerColumnType,
+                    containerColumnType);
+            }
+        }
+
         GenerateTableMapping(entityTypeBuilderName, entityType, stringBuilder, annotations);
         GenerateSplitTableMapping(entityTypeBuilderName, entityType, stringBuilder);
 

src/EFCore/Query/Internal/ExpressionTreeFuncletizer.cs

@@ -115,6 +115,9 @@ public class ExpressionTreeFuncletizer : ExpressionVisitor
     private static readonly bool UseOldBehavior35100 =
         AppContext.TryGetSwitch("Microsoft.EntityFrameworkCore.Issue35100", out var enabled35100) && enabled35100;
 
+    private static readonly bool UseOldBehavior37176 =
+        AppContext.TryGetSwitch("Microsoft.EntityFrameworkCore.Issue37176", out var enabled37176) && enabled37176;
+
     private static readonly MethodInfo ReadOnlyCollectionIndexerGetter = typeof(ReadOnlyCollection<Expression>).GetProperties()
         .Single(p => p.GetIndexParameters() is { Length: 1 } indexParameters && indexParameters[0].ParameterType == typeof(int)).GetMethod!;
 
@@ -985,14 +988,32 @@ protected override Expression VisitMethodCall(MethodCallExpression methodCall)
             switch (method.Name)
             {
                 case nameof(MemoryExtensions.Contains)
-                    when methodCall.Arguments is [var arg0, var arg1] && TryUnwrapSpanImplicitCast(arg0, out var unwrappedArg0):
+                    when UseOldBehavior37176
+                        && methodCall.Arguments is [var arg0, var arg1]
+                        && TryUnwrapSpanImplicitCast(arg0, out var unwrappedArg0):
                 {
                     return Visit(
                         Call(
                             EnumerableMethods.Contains.MakeGenericMethod(methodCall.Method.GetGenericArguments()[0]),
                             unwrappedArg0, arg1));
                 }
 
+                // In .NET 10, MemoryExtensions.Contains has an overload that accepts a third, optional comparer, in addition to the older
+                // overload that accepts two parameters only.
+                case nameof(MemoryExtensions.Contains)
+                    when !UseOldBehavior37176
+                        && methodCall.Arguments is [var spanArg, var valueArg, ..]
+                        && (methodCall.Arguments.Count is 2
+                            || methodCall.Arguments.Count is 3
+                                && methodCall.Arguments[2] is ConstantExpression { Value: null })
+                        && TryUnwrapSpanImplicitCast(spanArg, out var unwrappedSpanArg):
+                {
+                    return Visit(
+                        Call(
+                            EnumerableMethods.Contains.MakeGenericMethod(method.GetGenericArguments()[0]),
+                            unwrappedSpanArg, valueArg));
+                }
+
                 case nameof(MemoryExtensions.SequenceEqual)
                     when methodCall.Arguments is [var arg0, var arg1]
                     && TryUnwrapSpanImplicitCast(arg0, out var unwrappedArg0)
@@ -1005,20 +1026,37 @@ protected override Expression VisitMethodCall(MethodCallExpression methodCall)
 
             static bool TryUnwrapSpanImplicitCast(Expression expression, [NotNullWhen(true)] out Expression? result)
             {
-                if (expression is MethodCallExpression
+                switch (expression)
+                {
+                    // With newer versions of the SDK, the implicit cast is represented as a MethodCallExpression;
+                    // with older versions, it's a Convert node.
+                    case MethodCallExpression
                     {
                         Method: { Name: "op_Implicit", DeclaringType: { IsGenericType: true } implicitCastDeclaringType },
                         Arguments: [var unwrapped]
+                    } when implicitCastDeclaringType.GetGenericTypeDefinition() is var genericTypeDefinition
+                        && (genericTypeDefinition == typeof(Span<>) || genericTypeDefinition == typeof(ReadOnlySpan<>)):
+                    {
+                        result = unwrapped;
+                        return true;
                     }
-                    && implicitCastDeclaringType.GetGenericTypeDefinition() is var genericTypeDefinition
-                    && (genericTypeDefinition == typeof(Span<>) || genericTypeDefinition == typeof(ReadOnlySpan<>)))
-                {
-                    result = unwrapped;
-                    return true;
-                }
 
-                result = null;
-                return false;
+                    case UnaryExpression
+                    {
+                        NodeType: ExpressionType.Convert,
+                        Operand: var unwrapped,
+                        Type: { IsGenericType: true } convertType
+                    } when !UseOldBehavior37176 && convertType.GetGenericTypeDefinition() is var genericTypeDefinition
+                        && (genericTypeDefinition == typeof(Span<>) || genericTypeDefinition == typeof(ReadOnlySpan<>)):
+                    {
+                        result = unwrapped;
+                        return true;
+                    }
+
+                    default:
+                        result = null;
+                        return false;
+                }
             }
         }
 

src/Microsoft.Data.Sqlite.Core/SqliteBlob.cs

@@ -206,8 +206,12 @@ public virtual int Read(Span<byte> buffer)
                 count = (int)(Length - position);
             }
 
-            var rc = sqlite3_blob_read(_blob, buffer.Slice(0, count), (int)position);
-            SqliteException.ThrowExceptionForRC(rc, _connection.Handle);
+            // Newer sqlite3_blob_read returns error for 0-byte reads.
+            if (count > 0)
+            {
+                var rc = sqlite3_blob_read(_blob, buffer.Slice(0, count), (int)position);
+                SqliteException.ThrowExceptionForRC(rc, _connection.Handle);
+            }
             _position += count;
             return count;
         }
@@ -280,8 +284,12 @@ public virtual void Write(ReadOnlySpan<byte> buffer)
                 throw new NotSupportedException(Resources.ResizeNotSupported);
             }
 
-            var rc = sqlite3_blob_write(_blob, buffer.Slice(0, count), (int)position);
-            SqliteException.ThrowExceptionForRC(rc, _connection.Handle);
+            // Newer sqlite3_blob_write returns error for 0-byte writes.
+            if (count > 0)
+            {
+                var rc = sqlite3_blob_write(_blob, buffer.Slice(0, count), (int)position);
+                SqliteException.ThrowExceptionForRC(rc, _connection.Handle);
+            }
             _position += count;
         }
 

test/EFCore.Cosmos.FunctionalTests/Query/PrimitiveCollectionsQueryCosmosTest.cs

@@ -997,6 +997,50 @@ FROM root c
 """);
             });
 
+    public override Task Contains_on_Enumerable(bool async)
+        => CosmosTestHelpers.Instance.NoSyncTest(
+            async, async a =>
+            {
+                await base.Contains_on_Enumerable(a);
+
+                AssertSql(
+                """
+SELECT VALUE c
+FROM root c
+WHERE c["Int"] IN (10, 999)
+""");
+            });
+
+    public override Task Contains_on_MemoryExtensions(bool async)
+        => CosmosTestHelpers.Instance.NoSyncTest(
+            async, async a =>
+            {
+                await base.Contains_on_MemoryExtensions(a);
+
+                AssertSql(
+                """
+SELECT VALUE c
+FROM root c
+WHERE c["Int"] IN (10, 999)
+""");
+            });
+
+#if NET10_0_OR_GREATER
+    public override Task Contains_with_MemoryExtensions_with_null_comparer(bool async)
+        => CosmosTestHelpers.Instance.NoSyncTest(
+            async, async a =>
+            {
+                await base.Contains_with_MemoryExtensions_with_null_comparer(a);
+
+                AssertSql(
+                """
+SELECT VALUE c
+FROM root c
+WHERE c["Int"] IN (10, 999)
+""");
+            });
+#endif
+
     public override Task Column_collection_Length(bool async)
         => CosmosTestHelpers.Instance.NoSyncTest(
             async, async a =>

test/EFCore.Design.Tests/Migrations/Design/CSharpMigrationsGeneratorTest.ModelSnapshot.cs

@@ -4362,7 +4362,9 @@ public virtual void Owned_types_mapped_to_json_are_stored_in_snapshot()
 
                             b1.ToTable("EntityWithOneProperty", "DefaultSchema");
 
-                            b1.ToJson("EntityWithTwoProperties");
+                            b1
+                                .ToJson("EntityWithTwoProperties")
+                                .HasColumnType("nvarchar(max)");
 
                             b1.WithOwner("EntityWithOneProperty")
                                 .HasForeignKey("EntityWithOnePropertyId");
@@ -4437,6 +4439,7 @@ public virtual void Owned_types_mapped_to_json_are_stored_in_snapshot()
 
                 Assert.Equal(nameof(EntityWithOneProperty), ownedType1.GetTableName());
                 Assert.Equal("EntityWithTwoProperties", ownedType1.GetContainerColumnName());
+                Assert.Equal("nvarchar(max)", ownedType1.GetContainerColumnType());
 
                 var ownership2 = ownedType1.FindNavigation(nameof(EntityWithStringKey)).ForeignKey;
                 Assert.Equal("EntityWithTwoPropertiesEntityWithOnePropertyId", ownership2.Properties[0].Name);
@@ -4473,6 +4476,83 @@ public virtual void Owned_types_mapped_to_json_are_stored_in_snapshot()
                 Assert.Equal("Name", ownedProperties3[3].Name);
             });
 
+    [ConditionalFact]
+    public virtual void Owned_types_mapped_to_json_with_explicit_column_type_are_stored_in_snapshot()
+        => Test(
+            builder =>
+            {
+                builder.Entity<EntityWithOneProperty>(b =>
+                {
+                    b.HasKey(x => x.Id).HasName("PK_Custom");
+
+                    b.OwnsOne(
+                        x => x.EntityWithTwoProperties, bb =>
+                        {
+                            bb.ToJson().HasColumnType("json");
+                            bb.Ignore(x => x.Id);
+                            bb.Property(x => x.AlternateId).HasJsonPropertyName("NotKey");
+                            bb.WithOwner(e => e.EntityWithOneProperty);
+                        });
+                });
+            },
+            AddBoilerPlate(
+                GetHeading()
+                + """
+            modelBuilder.Entity("Microsoft.EntityFrameworkCore.Migrations.Design.CSharpMigrationsGeneratorTest+EntityWithOneProperty", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.HasKey("Id")
+                        .HasName("PK_Custom");
+
+                    b.ToTable("EntityWithOneProperty", "DefaultSchema");
+                });
+
+            modelBuilder.Entity("Microsoft.EntityFrameworkCore.Migrations.Design.CSharpMigrationsGeneratorTest+EntityWithOneProperty", b =>
+                {
+                    b.OwnsOne("Microsoft.EntityFrameworkCore.Migrations.Design.CSharpMigrationsGeneratorTest+EntityWithTwoProperties", "EntityWithTwoProperties", b1 =>
+                        {
+                            b1.Property<int>("EntityWithOnePropertyId")
+                                .HasColumnType("int");
+
+                            b1.Property<int>("AlternateId")
+                                .HasColumnType("int")
+                                .HasAnnotation("Relational:JsonPropertyName", "NotKey");
+
+                            b1.HasKey("EntityWithOnePropertyId");
+
+                            b1.ToTable("EntityWithOneProperty", "DefaultSchema");
+
+                            b1
+                                .ToJson("EntityWithTwoProperties")
+                                .HasColumnType("json");
+
+                            b1.WithOwner("EntityWithOneProperty")
+                                .HasForeignKey("EntityWithOnePropertyId");
+
+                            b1.Navigation("EntityWithOneProperty");
+                        });
+
+                    b.Navigation("EntityWithTwoProperties");
+                });
+""", usingSystem: false),
+            o =>
+            {
+                var entityWithOneProperty = o.FindEntityType(typeof(EntityWithOneProperty));
+                Assert.Equal("PK_Custom", entityWithOneProperty.GetKeys().Single().GetName());
+
+                var ownership1 = entityWithOneProperty.FindNavigation(nameof(EntityWithOneProperty.EntityWithTwoProperties))
+                    .ForeignKey;
+                var ownedType1 = ownership1.DeclaringEntityType;
+                Assert.Equal(nameof(EntityWithOneProperty), ownedType1.GetTableName());
+                Assert.Equal("EntityWithTwoProperties", ownedType1.GetContainerColumnName());
+                Assert.Equal("json", ownedType1.GetContainerColumnType());
+            });
+
     private class Order
     {
         public int Id { get; set; }

test/EFCore.Specification.Tests/Query/PrimitiveCollectionsQueryTestBase.cs

@@ -607,6 +607,34 @@ public virtual Task Column_collection_of_bools_Contains(bool async)
             async,
             ss => ss.Set<PrimitiveCollectionsEntity>().Where(c => c.Bools.Contains(true)));
 
+    // C# 14 first-class spans caused MemoryExtensions.Contains to get resolved instead of Enumerable.Contains.
+    // The following tests that the various overloads are all supported.
+    [ConditionalTheory]
+    [MemberData(nameof(IsAsyncData))]
+    public virtual Task Contains_on_Enumerable(bool async)
+        => AssertQuery(
+            async,
+            ss => ss.Set<PrimitiveCollectionsEntity>().Where(c => Enumerable.Contains(new[] { 10, 999 }, c.Int)));
+
+    // C# 14 first-class spans caused MemoryExtensions.Contains to get resolved instead of Enumerable.Contains.
+    // The following tests that the various overloads are all supported.
+    [ConditionalTheory]
+    [MemberData(nameof(IsAsyncData))]
+    public virtual Task Contains_on_MemoryExtensions(bool async)
+        => AssertQuery(
+            async,
+            ss => ss.Set<PrimitiveCollectionsEntity>().Where(c => MemoryExtensions.Contains(new[] { 10, 999 }, c.Int)));
+
+    // Note that we don't test EF 8/9 with .NET 10; this test is here for completeness/documentation purposes.
+#if NET10_0_OR_GREATER
+    [ConditionalTheory]
+    [MemberData(nameof(IsAsyncData))]
+    public virtual Task Contains_with_MemoryExtensions_with_null_comparer(bool async)
+        => AssertQuery(
+            async,
+            ss => ss.Set<PrimitiveCollectionsEntity>().Where(c => MemoryExtensions.Contains(new[] { 10, 999 }, c.Int, comparer: null)));
+#endif
+
     [ConditionalTheory]
     [MemberData(nameof(IsAsyncData))]
     public virtual Task Column_collection_Count_method(bool async)