From dc1ed71a49b2b728794c9407ba18a2a3a7444215 Mon Sep 17 00:00:00 2001 From: Shay Rojansky Date: Tue, 30 Jul 2019 12:42:06 +0200 Subject: [PATCH] Entity equality support for non-extension Contains EE handled the extension version of {IQueryable,IEnumerable}.Contains, but not instance methods such as List.Contains. Fixes #15554 --- .../Internal/ExpressionExtensions.cs | 2 - ...ntityEqualityRewritingExpressionVisitor.cs | 125 ++++++++++++++---- .../SimpleQueryCosmosTest.ResultOperators.cs | 33 +++++ .../SimpleQueryTestBase.ResultOperators.cs | 38 ++++++ ...impleQuerySqlServerTest.ResultOperators.cs | 36 +++++ 5 files changed, 209 insertions(+), 25 deletions(-) diff --git a/src/EFCore/Extensions/Internal/ExpressionExtensions.cs b/src/EFCore/Extensions/Internal/ExpressionExtensions.cs index e064b51e392..a60ac856ea2 100644 --- a/src/EFCore/Extensions/Internal/ExpressionExtensions.cs +++ b/src/EFCore/Extensions/Internal/ExpressionExtensions.cs @@ -8,9 +8,7 @@ using System.Linq.Expressions; using System.Reflection; using JetBrains.Annotations; -using Microsoft.EntityFrameworkCore.Diagnostics; using Microsoft.EntityFrameworkCore.Infrastructure; -using Microsoft.EntityFrameworkCore.Metadata; using Microsoft.EntityFrameworkCore.Query.Internal; using Microsoft.EntityFrameworkCore.Utilities; diff --git a/src/EFCore/Query/Internal/EntityEqualityRewritingExpressionVisitor.cs b/src/EFCore/Query/Internal/EntityEqualityRewritingExpressionVisitor.cs index 6f819c6bfea..f596f922745 100644 --- a/src/EFCore/Query/Internal/EntityEqualityRewritingExpressionVisitor.cs +++ b/src/EFCore/Query/Internal/EntityEqualityRewritingExpressionVisitor.cs @@ -2,8 +2,10 @@ // Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information. using System; +using System.Collections; using System.Collections.Generic; using System.Collections.ObjectModel; +using System.Diagnostics; using System.Linq; using System.Linq.Expressions; using System.Reflection; @@ -12,7 +14,6 @@ using Microsoft.EntityFrameworkCore.Infrastructure; using Microsoft.EntityFrameworkCore.Internal; using Microsoft.EntityFrameworkCore.Metadata; -using Microsoft.EntityFrameworkCore.Metadata.Internal; namespace Microsoft.EntityFrameworkCore.Query.Internal { @@ -36,6 +37,13 @@ public class EntityEqualityRewritingExpressionVisitor : ExpressionVisitor private static readonly MethodInfo _objectEqualsMethodInfo = typeof(object).GetRuntimeMethod(nameof(object.Equals), new[] { typeof(object), typeof(object) }); + private static readonly MethodInfo _enumerableContainsMethodInfo = typeof(Enumerable).GetTypeInfo() + .GetDeclaredMethods(nameof(Enumerable.Contains)) + .Single(mi => mi.GetParameters().Length == 2); + private static readonly MethodInfo _enumerableSelectMethodInfo = typeof(Enumerable).GetTypeInfo() + .GetDeclaredMethods(nameof(Enumerable.Contains)) + .Single(mi => mi.GetParameters().Length == 2); + public EntityEqualityRewritingExpressionVisitor(QueryCompilationContext queryCompilationContext) { _queryCompilationContext = queryCompilationContext; @@ -179,20 +187,19 @@ protected override Expression VisitConditional(ConditionalExpression conditional protected override Expression VisitMethodCall(MethodCallExpression methodCallExpression) { + var method = methodCallExpression.Method; var arguments = methodCallExpression.Arguments; Expression newSource; // Check if this is this Equals() - if (methodCallExpression.Method.Name == nameof(object.Equals) - && methodCallExpression.Object != null - && methodCallExpression.Arguments.Count == 1) + if (method.Name == nameof(object.Equals) && methodCallExpression.Object != null && methodCallExpression.Arguments.Count == 1) { var (newLeft, newRight) = (Visit(methodCallExpression.Object), Visit(arguments[0])); return RewriteEquality(true, newLeft, newRight) ?? methodCallExpression.Update(Unwrap(newLeft), new[] { Unwrap(newRight) }); } - if (methodCallExpression.Method.Equals(_objectEqualsMethodInfo)) + if (method.Equals(_objectEqualsMethodInfo)) { var (newLeft, newRight) = (Visit(arguments[0]), Visit(arguments[1])); return RewriteEquality(true, newLeft, newRight) @@ -210,11 +217,9 @@ protected override Expression VisitMethodCall(MethodCallExpression methodCallExp : newMethodCall; } - if (methodCallExpression.Method.DeclaringType == typeof(Queryable) - || methodCallExpression.Method.DeclaringType == typeof(Enumerable) - || methodCallExpression.Method.DeclaringType == typeof(QueryableExtensions)) + if (method.DeclaringType == typeof(Queryable) || method.DeclaringType == typeof(QueryableExtensions)) { - switch (methodCallExpression.Method.Name) + switch (method.Name) { // These are methods that require special handling case nameof(Queryable.Contains) when arguments.Count == 2: @@ -241,6 +246,13 @@ protected override Expression VisitMethodCall(MethodCallExpression methodCallExp } } + // We handled the Contains Queryable extension method above, but there's also IList.Contains + if (method.IsGenericMethod && method.GetGenericMethodDefinition().Equals(_enumerableContainsMethodInfo) + || method.DeclaringType.GetInterfaces().Contains(typeof(IList)) && string.Equals(method.Name, nameof(IList.Contains))) + { + return VisitContainsMethodCall(methodCallExpression); + } + // TODO: Can add an extension point that can be overridden by subclassing visitors to recognize additional methods and flow through the entity type. // Do this here, since below we visit the arguments (avoid double visitation) @@ -312,16 +324,18 @@ protected override Expression VisitMethodCall(MethodCallExpression methodCallExp protected virtual Expression VisitContainsMethodCall(MethodCallExpression methodCallExpression) { - var arguments = methodCallExpression.Arguments; - var newSource = Visit(arguments[0]); - var newItem = Visit(arguments[1]); + // We handle both Contains the extension method and the instance method + var (newSource, newItem) = methodCallExpression.Arguments.Count == 2 + ? (methodCallExpression.Arguments[0], methodCallExpression.Arguments[1]) + : (methodCallExpression.Object, methodCallExpression.Arguments[0]); + (newSource, newItem) = (Visit(newSource), Visit(newItem)); var sourceEntityType = (newSource as EntityReferenceExpression)?.EntityType; var itemEntityType = (newItem as EntityReferenceExpression)?.EntityType; if (sourceEntityType == null && itemEntityType == null) { - return methodCallExpression.Update(null, new[] { newSource, newItem }); + return NoTranslation(); } if (sourceEntityType != null && itemEntityType != null @@ -338,23 +352,65 @@ protected virtual Expression VisitContainsMethodCall(MethodCallExpression method ? keyProperties.Single() : throw new NotSupportedException(CoreStrings.EntityEqualityContainsWithCompositeKeyNotSupported(entityType.DisplayName())); - // Wrap the source with a projection to its primary key, and the item with a primary key access expression - var param = Expression.Parameter(entityType.ClrType, "v"); - var keySelector = Expression.Lambda(CreatePropertyAccessExpression(param, keyProperty), param); - var keyProjection = Expression.Call( - QueryableMethodProvider.SelectMethodInfo.MakeGenericMethod(entityType.ClrType, keyProperty.ClrType), - Unwrap(newSource), - keySelector); + Expression rewrittenSource, rewrittenItem; + + if (newSource is ConstantExpression listConstant) + { + // The source list is a constant, evaluate and replace with a list of the keys + var listValue = (IEnumerable)listConstant.Value; + var keyListType = typeof(List<>).MakeGenericType(keyProperty.ClrType); + var keyList = (IList)Activator.CreateInstance(keyListType); + foreach (var listItem in listValue) + { + keyList.Add(keyProperty.GetGetter().GetClrValue(listItem)); + } + rewrittenSource = Expression.Constant(keyList, keyListType); + } + else if (newSource is ParameterExpression listParam + && listParam.Name.StartsWith(CompiledQueryCache.CompiledQueryParameterPrefix, StringComparison.Ordinal)) + { + // The source list is a parameter. Add a runtime parameter that will contain a list of the extracted keys for each execution. + var parameterKeyExtractor = _parameterListValueExtractor.MakeGenericMethod(entityType.ClrType, keyProperty.ClrType); + var lambda = Expression.Lambda( + Expression.Call( + parameterKeyExtractor, + QueryCompilationContext.QueryContextParameter, + Expression.Constant(listParam.Name, typeof(string)), + Expression.Constant(keyProperty, typeof(IProperty))), + QueryCompilationContext.QueryContextParameter + ); + + var newParameterName = $"{RuntimeParameterPrefix}{listParam.Name.Substring(CompiledQueryCache.CompiledQueryParameterPrefix.Length)}_{keyProperty.Name}"; + _queryCompilationContext.RegisterRuntimeParameter(newParameterName, lambda); + rewrittenSource = Expression.Parameter(typeof(List<>).MakeGenericType(keyProperty.ClrType), newParameterName); + } + else + { + // The source list is neither a constant nor a parameter. Wrap it with a projection to its primary key. + var param = Expression.Parameter(entityType.ClrType, "v"); + var keySelector = Expression.Lambda(CreatePropertyAccessExpression(param, keyProperty), param); + rewrittenSource = Expression.Call( + QueryableMethodProvider.SelectMethodInfo.MakeGenericMethod(entityType.ClrType, keyProperty.ClrType), + Unwrap(newSource), + keySelector); + } - var rewrittenItem = newItem.IsNullConstantExpression() + // Rewrite the item with a key expression as needed (constant, parameter and other are handled within) + rewrittenItem = newItem.IsNullConstantExpression() ? Expression.Constant(null) : CreatePropertyAccessExpression(Unwrap(newItem), keyProperty); return Expression.Call( - QueryableMethodProvider.ContainsMethodInfo.MakeGenericMethod(keyProperty.ClrType), - keyProjection, + (Unwrap(newSource).Type.IsQueryableType() + ? QueryableMethodProvider.ContainsMethodInfo + : _enumerableContainsMethodInfo).MakeGenericMethod(keyProperty.ClrType), + rewrittenSource, rewrittenItem ); + + Expression NoTranslation() => methodCallExpression.Arguments.Count == 2 + ? methodCallExpression.Update(null, new[] { Unwrap(newSource), Unwrap(newItem) }) + : methodCallExpression.Update(Unwrap(newSource), new[] { Unwrap(newItem) }); } protected virtual Expression VisitOrderingMethodCall(MethodCallExpression methodCallExpression) @@ -820,6 +876,29 @@ private static readonly MethodInfo _parameterValueExtractor .GetTypeInfo() .GetDeclaredMethod(nameof(ParameterValueExtractor)); + /// + /// Extracts the list parameter with name from and returns a + /// projection to its elements' values. + /// + private static object ParameterListValueExtractor(QueryContext context, string baseParameterName, IProperty property) + { + Debug.Assert(property.ClrType == typeof(TProperty)); + + var baseListParameter = context.ParameterValues[baseParameterName] as IEnumerable; + if (baseListParameter == null) + { + return null; + } + + var getter = property.GetGetter(); + return baseListParameter.Select(e => (TProperty)getter.GetClrValue(e)).ToList(); + } + + private static readonly MethodInfo _parameterListValueExtractor + = typeof(EntityEqualityRewritingExpressionVisitor) + .GetTypeInfo() + .GetDeclaredMethod(nameof(ParameterListValueExtractor)); + protected static Expression UnwrapLastNavigation(Expression expression) => (expression as MemberExpression)?.Expression ?? (expression is MethodCallExpression methodCallExpression diff --git a/test/EFCore.Cosmos.FunctionalTests/Query/SimpleQueryCosmosTest.ResultOperators.cs b/test/EFCore.Cosmos.FunctionalTests/Query/SimpleQueryCosmosTest.ResultOperators.cs index de3d4af6eca..ce78d174d23 100644 --- a/test/EFCore.Cosmos.FunctionalTests/Query/SimpleQueryCosmosTest.ResultOperators.cs +++ b/test/EFCore.Cosmos.FunctionalTests/Query/SimpleQueryCosmosTest.ResultOperators.cs @@ -1207,6 +1207,39 @@ FROM root c WHERE ((c[""Discriminator""] = ""Order"") AND (c[""OrderID""] = 10248))"); } + [ConditionalTheory(Skip = "Issue#14935 (Contains not implemented)")] + public override async Task List_Contains_over_entityType_should_rewrite_to_identity_equality(bool isAsync) + { + await base.List_Contains_over_entityType_should_rewrite_to_identity_equality(isAsync); + + AssertSql( + @"SELECT c +FROM root c +WHERE ((c[""Discriminator""] = ""Order"") AND (c[""OrderID""] = 10248))"); + } + + [ConditionalTheory(Skip = "Issue#14935 (Contains not implemented)")] + public override async Task List_Contains_with_constant_list(bool isAsync) + { + await base.List_Contains_with_constant_list(isAsync); + + AssertSql( + @"SELECT c +FROM root c +WHERE ((c[""Discriminator""] = ""Order"") AND (c[""OrderID""] = 10248))"); + } + + [ConditionalTheory(Skip = "Issue#14935 (Contains not implemented)")] + public override async Task List_Contains_with_parameter_list(bool isAsync) + { + await base.List_Contains_with_parameter_list(isAsync); + + AssertSql( + @"SELECT c +FROM root c +WHERE ((c[""Discriminator""] = ""Order"") AND (c[""OrderID""] = 10248))"); + } + [ConditionalTheory(Skip = "Issue#14935 (Contains not implemented)")] public override void Contains_over_entityType_with_null_should_rewrite_to_identity_equality() { diff --git a/test/EFCore.Specification.Tests/Query/SimpleQueryTestBase.ResultOperators.cs b/test/EFCore.Specification.Tests/Query/SimpleQueryTestBase.ResultOperators.cs index c8515262edb..1c134d9d88a 100644 --- a/test/EFCore.Specification.Tests/Query/SimpleQueryTestBase.ResultOperators.cs +++ b/test/EFCore.Specification.Tests/Query/SimpleQueryTestBase.ResultOperators.cs @@ -1510,6 +1510,44 @@ var query } } + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public virtual Task List_Contains_over_entityType_should_rewrite_to_identity_equality(bool isAsync) + { + var someOrder = new Order { OrderID = 10248 }; + + return AssertQuery(isAsync, cs => + cs.Where(c => c.Orders.Contains(someOrder)), + entryCount: 1); + } + + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public virtual Task List_Contains_with_constant_list(bool isAsync) + { + return AssertQuery(isAsync, cs => + cs.Where(c => new List + { + new Customer { CustomerID = "ALFKI" }, + new Customer { CustomerID = "ANATR" } + }.Contains(c)), + entryCount: 2); + } + + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public virtual Task List_Contains_with_parameter_list(bool isAsync) + { + var customers = new List + { + new Customer { CustomerID = "ALFKI" }, + new Customer { CustomerID = "ANATR" } + }; + + return AssertQuery(isAsync, cs => cs.Where(c => customers.Contains(c)), + entryCount: 2); + } + [ConditionalFact] public virtual void Contains_over_entityType_with_null_should_rewrite_to_identity_equality() { diff --git a/test/EFCore.SqlServer.FunctionalTests/Query/SimpleQuerySqlServerTest.ResultOperators.cs b/test/EFCore.SqlServer.FunctionalTests/Query/SimpleQuerySqlServerTest.ResultOperators.cs index 6c493aed146..98d01801aaa 100644 --- a/test/EFCore.SqlServer.FunctionalTests/Query/SimpleQuerySqlServerTest.ResultOperators.cs +++ b/test/EFCore.SqlServer.FunctionalTests/Query/SimpleQuerySqlServerTest.ResultOperators.cs @@ -1189,6 +1189,42 @@ ELSE CAST(0 AS bit) END"); } + public override async Task List_Contains_over_entityType_should_rewrite_to_identity_equality(bool isAsync) + { + await base.List_Contains_over_entityType_should_rewrite_to_identity_equality(isAsync); + + AssertSql( + @"@__entity_equality_someOrder_0_OrderID='10248' + +SELECT [c].[CustomerID], [c].[Address], [c].[City], [c].[CompanyName], [c].[ContactName], [c].[ContactTitle], [c].[Country], [c].[Fax], [c].[Phone], [c].[PostalCode], [c].[Region] +FROM [Customers] AS [c] +WHERE @__entity_equality_someOrder_0_OrderID IN ( + SELECT [o].[OrderID] + FROM [Orders] AS [o] + WHERE ([c].[CustomerID] = [o].[CustomerID]) AND [o].[CustomerID] IS NOT NULL +)"); + } + + public override async Task List_Contains_with_constant_list(bool isAsync) + { + await base.List_Contains_with_constant_list(isAsync); + + AssertSql( + @"SELECT [c].[CustomerID], [c].[Address], [c].[City], [c].[CompanyName], [c].[ContactName], [c].[ContactTitle], [c].[Country], [c].[Fax], [c].[Phone], [c].[PostalCode], [c].[Region] +FROM [Customers] AS [c] +WHERE [c].[CustomerID] IN (N'ALFKI', N'ANATR')"); + } + + public override async Task List_Contains_with_parameter_list(bool isAsync) + { + await base.List_Contains_with_parameter_list(isAsync); + + AssertSql( + @"SELECT [c].[CustomerID], [c].[Address], [c].[City], [c].[CompanyName], [c].[ContactName], [c].[ContactTitle], [c].[Country], [c].[Fax], [c].[Phone], [c].[PostalCode], [c].[Region] +FROM [Customers] AS [c] +WHERE [c].[CustomerID] IN (N'ALFKI', N'ANATR')"); + } + public override void Contains_over_entityType_with_null_should_rewrite_to_identity_equality() { base.Contains_over_entityType_with_null_should_rewrite_to_identity_equality();