Merge pull request #33 from DataObjects-NET/master-bulk-with-in

Makes IEnumberable<T>.Contains work with Bulk operations

Author: alex-kulakov

Extensions/Xtensive.Orm.BulkOperations.Tests/ContainsTest.cs

@@ -0,0 +1,111 @@
+// Copyright (C) 2020 Xtensive LLC.
+// This code is distributed under MIT license terms.
+// See the License.txt file in the project root for more information.
+
+using System;
+using System.Linq;
+using NUnit.Framework;
+using Xtensive.Orm.BulkOperations.ContainsTestModel;
+using Xtensive.Orm.Configuration;
+
+namespace Xtensive.Orm.BulkOperations.ContainsTestModel
+{
+  [HierarchyRoot]
+  [KeyGenerator(KeyGeneratorKind.None)]
+  public class TagType : Entity
+  {
+    [Field, Key]
+    public long Id { get; private set; }
+
+    [Field]
+    public int ProjectedValueAdjustment { get; set; }
+
+    public TagType(Session session, long id)
+      :base(session, id)
+    {
+    }
+  }
+}
+
+namespace Xtensive.Orm.BulkOperations.Tests
+{
+  public class ContainsTest : AutoBuildTest
+  {
+    private long[] tagIds;
+
+    protected override DomainConfiguration BuildConfiguration()
+    {
+      var configuration = base.BuildConfiguration();
+      configuration.Types.Register(typeof(TagType).Assembly, typeof(TagType).Namespace);
+      return configuration;
+    }
+
+    protected override void PopulateData()
+    {
+      tagIds = Enumerable.Range(0, 100).Select(i => (long) i).ToArray();
+      using (var session = Domain.OpenSession())
+      using (var transaction = session.OpenTransaction()) {
+        foreach (var id in tagIds.Concat(Enumerable.Repeat(1000, 1).Select(i => (long) i)))
+          new TagType(session, id) { ProjectedValueAdjustment = -1 };
+        transaction.Complete();
+      }
+    }
+
+    [Test]
+    public void Test1()
+    {
+      using (var session = Domain.OpenSession())
+      using (var tx = session.OpenTransaction()) {
+        var updatedRows = session.Query.All<TagType>()
+          .Where(t => t.Id.In(tagIds))
+          .Set(t => t.ProjectedValueAdjustment, 2)
+          .Update();
+        Assert.That(updatedRows, Is.EqualTo(100));
+        Assert.That(session.Query.All<TagType>().Count(t => t.ProjectedValueAdjustment == 2 && t.Id <= 200), Is.EqualTo(100));
+        Assert.That(session.Query.All<TagType>().Count(t => t.ProjectedValueAdjustment == -1 && t.Id > 700), Is.EqualTo(1));
+      }
+    }
+
+    [Test]
+    public void Test2()
+    {
+      using (var session = Domain.OpenSession())
+      using (var tx = session.OpenTransaction()) {
+        var updatedRows = session.Query.All<TagType>()
+          .Where(t => t.Id.In(IncludeAlgorithm.ComplexCondition, tagIds))
+          .Set(t => t.ProjectedValueAdjustment, 2)
+          .Update();
+        Assert.That(updatedRows, Is.EqualTo(100));
+        Assert.That(session.Query.All<TagType>().Count(t => t.ProjectedValueAdjustment == 2 && t.Id <= 200), Is.EqualTo(100));
+        Assert.That(session.Query.All<TagType>().Count(t => t.ProjectedValueAdjustment == -1 && t.Id > 700), Is.EqualTo(1));
+      }
+    }
+
+    [Test]
+    public void Test3()
+    {
+      using (var session = Domain.OpenSession())
+      using (var tx = session.OpenTransaction()) {
+        Assert.Throws<NotSupportedException>(() => session.Query.All<TagType>()
+          .Where(t => t.Id.In(IncludeAlgorithm.TemporaryTable, tagIds))
+          .Set(t => t.ProjectedValueAdjustment, 2)
+          .Update());
+      }
+    }
+
+    [Test]
+    public void Test4()
+    {
+      using (var session = Domain.OpenSession())
+      using (var tx = session.OpenTransaction()) {
+        var updatedRows = session.Query.All<TagType>()
+          .Where(t => tagIds.Contains(t.Id))
+          .Set(t => t.ProjectedValueAdjustment, 2)
+          .Update();
+        Assert.That(updatedRows, Is.EqualTo(100));
+        Assert.That(session.Query.All<TagType>().Count(t => t.ProjectedValueAdjustment == 2 && t.Id <= 200), Is.EqualTo(100));
+        Assert.That(session.Query.All<TagType>().Count(t => t.ProjectedValueAdjustment == -1 && t.Id > 700), Is.EqualTo(1));
+      }
+    }
+  }
+}

Extensions/Xtensive.Orm.BulkOperations/Internals/QueryOperation.cs

@@ -1,4 +1,4 @@
-using System;
+using System;
 using System.Collections.Generic;
 using System.Linq;
 using System.Linq.Expressions;
@@ -14,7 +14,7 @@ namespace Xtensive.Orm.BulkOperations
   internal abstract class QueryOperation<T> : Operation<T>
     where T : class, IEntity
   {
-    private static MethodInfo inMethod = GetInMethod();
+    private readonly static MethodInfo inMethod = GetInMethod();
     protected IQueryable<T> query;
 
     protected QueryOperation(QueryProvider queryProvider)
@@ -24,10 +24,9 @@ protected QueryOperation(QueryProvider queryProvider)
 
     private static MethodInfo GetInMethod()
     {
-      foreach (var method in typeof (QueryableExtensions).GetMethods().Where(a=>a.Name=="In"))
-      {
+      foreach (var method in typeof (QueryableExtensions).GetMethods().Where(a => string.Equals(a.Name, "In", StringComparison.Ordinal))) {
         var parameters = method.GetParameters();
-        if (parameters.Length == 3 && parameters[2].ParameterType.Name == "IEnumerable`1")
+        if (parameters.Length == 3 && string.Equals(parameters[2].ParameterType.Name, "IEnumerable`1", StringComparison.Ordinal))
           return method;
       }
       return null;
@@ -37,30 +36,38 @@ protected override int ExecuteInternal()
     {
       Expression e = query.Expression.Visit((MethodCallExpression ex) =>
         {
-          if (ex.Method.DeclaringType == typeof (QueryableExtensions) && ex.Method.Name == "In" &&
-              ex.Arguments.Count > 1)
-          {
-            if (ex.Arguments[1].Type == typeof (IncludeAlgorithm))
-            {
-              var v = (IncludeAlgorithm) ex.Arguments[1].Invoke();
-              if (v == IncludeAlgorithm.TemporaryTable)
-              {
+          var methodInfo = ex.Method;
+          //rewrite localCollection.Contains(entity.SomeField) -> entity.SomeField.In(localCollection)
+          if (methodInfo.DeclaringType == typeof(Enumerable) &&
+              string.Equals(methodInfo.Name, "Contains", StringComparison.Ordinal) &&
+              ex.Arguments.Count == 2) {
+            var localCollection = ex.Arguments[0];//IEnumerable<T>
+            var valueToCheck = ex.Arguments[1];
+            var genericInMethod = inMethod.MakeGenericMethod(new[] { valueToCheck.Type });
+            ex = Expression.Call(genericInMethod, valueToCheck, Expression.Constant(IncludeAlgorithm.ComplexCondition), localCollection);
+            methodInfo = ex.Method;
+          }
+
+          if (methodInfo.DeclaringType == typeof(QueryableExtensions) &&
+              string.Equals(methodInfo.Name, "In", StringComparison.Ordinal) &&
+              ex.Arguments.Count > 1) {
+            if (ex.Arguments[1].Type == typeof(IncludeAlgorithm)) {
+              var algorithm = (IncludeAlgorithm) ex.Arguments[1].Invoke();
+              if (algorithm == IncludeAlgorithm.TemporaryTable) {
                 throw new NotSupportedException("IncludeAlgorithm.TemporaryTable is not supported");
               }
-              if (v == IncludeAlgorithm.Auto)
-              {
+              if (algorithm == IncludeAlgorithm.Auto) {
                 List<Expression> arguments = ex.Arguments.ToList();
                 arguments[1] = Expression.Constant(IncludeAlgorithm.ComplexCondition);
-                ex = Expression.Call(ex.Method, arguments);
+                ex = Expression.Call(methodInfo, arguments);
               }
             }
-            else
-            {
+            else {
               List<Expression> arguments = ex.Arguments.ToList();
               arguments.Insert(1, Expression.Constant(IncludeAlgorithm.ComplexCondition));
-              List<Type> types = ex.Method.GetParameters().Select(a => a.ParameterType).ToList();
-              types.Insert(1, typeof (IncludeAlgorithm));
-              ex = Expression.Call(inMethod.MakeGenericMethod(ex.Method.GetGenericArguments()),
+              List<Type> types = methodInfo.GetParameters().Select(a => a.ParameterType).ToList();
+              types.Insert(1, typeof(IncludeAlgorithm));
+              ex = Expression.Call(inMethod.MakeGenericMethod(methodInfo.GetGenericArguments()),
                                    arguments.ToArray());
             }
           }