Merge pull request #69 from DataObjects-NET/include-provider-bugfix

Fix the issue with the multiple In statements in the same query

Author: alex-kulakov

Orm/Xtensive.Orm.Tests/Issues/IssueGitHub0070_IncludeProviderParameterConflictWithinParameterContext.cs

@@ -0,0 +1,58 @@
+// 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 System.Reflection;
+using NUnit.Framework;
+using Xtensive.Orm.Configuration;
+using Xtensive.Orm.Tests.Issues.IssueGitHub0070_IncludeProviderParameterConflictWithinParameterContextModel;
+
+namespace Xtensive.Orm.Tests.Issues.IssueGitHub0070_IncludeProviderParameterConflictWithinParameterContextModel
+{
+  [HierarchyRoot]
+  [KeyGenerator(KeyGeneratorKind.None)]
+  public class Token: Entity
+  {
+    [Field, Key]
+    public Guid Id { get; private set; }
+
+    [Field]
+    public long Salt { get; set; }
+
+    public Token(Session session, Guid id)
+      : base(session, id)
+    { }
+  }
+}
+
+namespace Xtensive.Orm.Tests.Issues
+{
+  [TestFixture]
+  public class IssueGitHub0070_IncludeProviderParameterConflictWithinParameterContext : AutoBuildTest
+  {
+    protected override DomainConfiguration BuildConfiguration()
+    {
+      var config = base.BuildConfiguration();
+      config.Types.Register(typeof(Token).Assembly, typeof(Token).Namespace);
+      return config;
+    }
+
+    [Test]
+    public void TwoDifferentInStatementsInTheSameQuery()
+    {
+      using (var session = Domain.OpenSession())
+      using (session.OpenTransaction()) {
+        var tokenId = Guid.NewGuid();
+        var token = new Token(session, tokenId) {
+          Salt = -1
+        };
+        session.SaveChanges();
+        var query = session.Query.All<Token>()
+          .Where(t => t.Salt.In(-1, 1) && t.Id.In(tokenId, Guid.Empty));
+        Assert.AreSame(token, query.FirstOrDefault());
+      }
+    }
+  }
+}

Orm/Xtensive.Orm/Core/Parameter{TValue}.cs

@@ -13,7 +13,7 @@ namespace Xtensive.Core
   /// Parameter - an object identifying its value in active <see cref="ParameterContext"/>.
   /// </summary>
   /// <typeparam name="TValue">The type of parameter value.</typeparam>
-  public sealed class Parameter<TValue> : Parameter
+  public class Parameter<TValue> : Parameter
   {
     /// <summary>
     /// Always fails.

Orm/Xtensive.Orm/Orm/Providers/SqlCompiler.Include.cs

@@ -8,11 +8,9 @@
 using System.Collections.Generic;
 using System.Linq;
 using Xtensive.Core;
-using Xtensive.Collections;
 using Tuple = Xtensive.Tuples.Tuple;
 using Xtensive.Sql;
 using Xtensive.Sql.Dml;
-using Xtensive.Orm.Rse;
 using Xtensive.Orm.Rse.Providers;
 
 namespace Xtensive.Orm.Providers
@@ -32,25 +30,29 @@ protected override SqlProvider VisitInclude(IncludeProvider provider)
       TemporaryTableDescriptor tableDescriptor = null;
       QueryParameterBinding extraBinding = null;
       var algorithm = provider.Algorithm;
-      if (!temporaryTablesSupported)
+      if (!temporaryTablesSupported) {
         algorithm = IncludeAlgorithm.ComplexCondition;
+      }
+
       switch (algorithm) {
       case IncludeAlgorithm.Auto:
-        var complexConditionExpression = CreateIncludeViaComplexConditionExpression(
-          provider, BuildRowFilterParameterAccessor(filterDataSource, true),
-          sourceColumns, out extraBinding);
         var temporaryTableExpression = CreateIncludeViaTemporaryTableExpression(
           provider, sourceColumns, out tableDescriptor);
+        var complexConditionExpression = CreateIncludeViaComplexConditionExpression(
+          provider, BuildAutoRowFilterParameterAccessor(tableDescriptor),
+          sourceColumns, out extraBinding);
         resultExpression = SqlDml.Variant(extraBinding,
           complexConditionExpression, temporaryTableExpression);
         anyTemporaryTablesRequired = true;
         break;
       case IncludeAlgorithm.ComplexCondition:
         resultExpression = CreateIncludeViaComplexConditionExpression(
-          provider, BuildRowFilterParameterAccessor(filterDataSource, false),
+          provider, BuildComplexConditionRowFilterParameterAccessor(filterDataSource),
           sourceColumns, out extraBinding);
-        if (!anyTemporaryTablesRequired)
+        if (!anyTemporaryTablesRequired) {
           requestOptions |= QueryRequestOptions.AllowOptimization;
+        }
+
         break;
       case IncludeAlgorithm.TemporaryTable:
         resultExpression = CreateIncludeViaTemporaryTableExpression(
@@ -63,8 +65,10 @@ protected override SqlProvider VisitInclude(IncludeProvider provider)
       resultExpression = GetBooleanColumnExpression(resultExpression);
       var calculatedColumn = provider.Header.Columns[provider.Header.Length - 1];
       AddInlinableColumn(provider, calculatedColumn, resultQuery, resultExpression);
-      if (extraBinding!=null)
-        bindings = bindings.Concat(EnumerableUtils.One(extraBinding));
+      if (extraBinding!=null) {
+        bindings = bindings.Append(extraBinding);
+      }
+
       var request = CreateQueryRequest(Driver, resultQuery, bindings, provider.Header.TupleDescriptor, requestOptions);
       return new SqlIncludeProvider(Handlers, request, tableDescriptor, filterDataSource, provider, source);
     }
@@ -97,16 +101,15 @@ protected SqlExpression CreateIncludeViaTemporaryTableExpression(
       return resultExpression;
     }
 
-    protected static Func<ParameterContext, object> BuildRowFilterParameterAccessor(
-      Func<ParameterContext, IEnumerable<Tuple>> filterDataSource, bool takeFromContext)
-    {
-      if (!takeFromContext) {
-        return context => filterDataSource.Invoke(context).ToList();
-      }
+    private static Func<ParameterContext, object> BuildComplexConditionRowFilterParameterAccessor(
+      Func<ParameterContext, IEnumerable<Tuple>> filterDataSource) =>
+      context => filterDataSource.Invoke(context).ToList();
 
-      return context => context.TryGetValue(SqlIncludeProvider.rowFilterParameter, out var filterData)
-        ? filterData
-        : null;
-    }
+    private static Func<ParameterContext, object> BuildAutoRowFilterParameterAccessor(
+      TemporaryTableDescriptor tableDescriptor) =>
+      context =>
+        context.TryGetValue(SqlIncludeProvider.CreateFilterParameter(tableDescriptor), out var filterData)
+          ? filterData
+          : null;
   }
 }

Orm/Xtensive.Orm/Orm/Providers/SqlIncludeProvider.cs

@@ -18,11 +18,32 @@ namespace Xtensive.Orm.Providers
   /// </summary>
   public sealed class SqlIncludeProvider : SqlTemporaryDataProvider
   {
-    internal static readonly Parameter<List<Tuple>> rowFilterParameter = new Parameter<List<Tuple>>("RowFilterData");
+    private class RowFilterParameter : Parameter<List<Tuple>>, IEquatable<RowFilterParameter>
+    {
+      private readonly TemporaryTableDescriptor temporaryTableDescriptor;
+
+      public bool Equals(RowFilterParameter other) =>
+        !ReferenceEquals(null, other)
+        && (ReferenceEquals(this, other) || ReferenceEquals(temporaryTableDescriptor, other.temporaryTableDescriptor));
+
+      public override bool Equals(object obj) =>
+        !ReferenceEquals(null, obj)
+        && (ReferenceEquals(this, obj) || (obj is RowFilterParameter rowFilterParameter && Equals(rowFilterParameter)));
+
+      public override int GetHashCode() => temporaryTableDescriptor != null ? temporaryTableDescriptor.GetHashCode() : 0;
+
+      public RowFilterParameter(TemporaryTableDescriptor temporaryTableDescriptor) : base("RowFilterData")
+      {
+        this.temporaryTableDescriptor = temporaryTableDescriptor;
+      }
+    }
 
     private readonly Func<ParameterContext, IEnumerable<Tuple>> filterDataSource;
 
-    private new IncludeProvider Origin { get { return (IncludeProvider) base.Origin; } }
+    private new IncludeProvider Origin => (IncludeProvider) base.Origin;
+
+    internal static Parameter<List<Tuple>> CreateFilterParameter(TemporaryTableDescriptor temporaryTableDescriptor) =>
+      new RowFilterParameter(temporaryTableDescriptor);
 
     /// <inheritdoc/>
     protected internal override void OnBeforeEnumerate(Rse.Providers.EnumerationContext context)
@@ -36,7 +57,7 @@ protected internal override void OnBeforeEnumerate(Rse.Providers.EnumerationCont
           LockAndStore(context, filterData);
         }
         else {
-          parameterContext.SetValue(rowFilterParameter, filterData);
+          parameterContext.SetValue(CreateFilterParameter(tableDescriptor), filterData);
         }
 
         break;