Merge pull request #379 from DataObjects-NET/6.0-same-param-in-inner-outer-selector

Denies Join/LeftJoin to use the same expression instance for both inner and outer selectors

Author: alex-kulakov

ChangeLog/6.0.13_dev.txt

@@ -1,4 +1,5 @@
 [main] Fixed certain cases of bad translation of casts via 'as' operator in LINQ queries
 [main] Addressed certain issues of translation connected with comparison with local entity instace within LINQ queries
 [main] Fixed rare issues of incorrect translation of filtered index expressions including conditional expressions
+[main] Join/LeftJoin is denied to have the same expression instance for both inner/outer selector.
 [postgresql] Fixed issue of incorrect translation of contitional expressions including comparison with nullable fields

Orm/Xtensive.Orm.Tests/Issues/IssueJira0803_ReuseOfJoiningExpressionCausesWrongTranslation.cs

@@ -0,0 +1,174 @@
+// Copyright (C) 2024 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.Linq.Expressions;
+using NUnit.Framework;
+using Xtensive.Orm.Configuration;
+using Xtensive.Orm.Tests.Issues.IssueJira0803_ReuseOfJoiningExpressionCausesWrongTranslationModel;
+
+namespace Xtensive.Orm.Tests.Issues.IssueJira0803_ReuseOfJoiningExpressionCausesWrongTranslationModel
+{
+  [HierarchyRoot]
+  public class TestEntity : Entity
+  {
+    [Field, Key]
+    public int Id { get; private set; }
+
+    [Field(Nullable = false)]
+    public string Name { get; set; }
+
+    [Field]
+    public string Description { get; set; }
+
+    [Field]
+    public string Text { get; set; }
+
+    public TestEntity(Session session)
+      : base(session)
+    {
+    }
+  }
+}
+
+namespace Xtensive.Orm.Tests.Issues
+{
+  public sealed class IssueJira0803_ReuseOfJoiningExpressionCausesWrongTranslation : AutoBuildTest
+  {
+    protected override DomainConfiguration BuildConfiguration()
+    {
+      var configuration = base.BuildConfiguration();
+      configuration.UpgradeMode = DomainUpgradeMode.Recreate;
+      configuration.Types.Register(typeof(TestEntity));
+      return configuration;
+    }
+
+    protected override void PopulateData()
+    {
+      using (var session = Domain.OpenSession())
+      using (var tx = session.OpenTransaction()) {
+        _ = new TestEntity(session) { Name = "1", Description = "test", Text = "text" };
+        _ = new TestEntity(session) { Name = "1", Description = "test", Text = "text" };
+        _ = new TestEntity(session) { Name = "1", Description = null, Text = "text" };
+
+        tx.Complete();
+      }
+    }
+
+    [Test]
+    public void LeftJoinOneVariableUsage()
+    {
+      Expression<Func<TestEntity, int>> key = it => it.Id;
+
+      using (var session = Domain.OpenSession())
+      using (var tx = session.OpenTransaction()) {
+
+        var leftJoinWithExpression = session.Query.All<TestEntity>()
+          .LeftJoin(session.Query.All<TestEntity>().Where(it => it.Description == null),
+            o => o.Id,
+            key,
+            (o, i) => o)
+          .Where(it => it.Text != null)
+          .Select(it => it.Id)
+          .Distinct()
+          .ToList();
+
+        Assert.AreEqual(3, leftJoinWithExpression.Count);
+
+        leftJoinWithExpression = session.Query.All<TestEntity>()
+          .LeftJoin(session.Query.All<TestEntity>().Where(it => it.Description == null),
+            key,
+            i => i.Id,
+            (o, i) => o)
+          .Where(it => it.Text != null)
+          .Select(it => it.Id)
+          .Distinct()
+          .ToList();
+
+        Assert.AreEqual(3, leftJoinWithExpression.Count);
+      }
+    }
+
+    [Test]
+    public void LeftJoinTwoVariableUsage()
+    {
+      Expression<Func<TestEntity, int>> key = it => it.Id;
+
+      using (var session = Domain.OpenSession())
+      using (var tx = session.OpenTransaction()) {
+
+        var ex = Assert.Throws<QueryTranslationException>(() =>
+          _ = session.Query.All<TestEntity>()
+          .LeftJoin(session.Query.All<TestEntity>().Where(it => it.Description == null),
+            key,
+            key,
+            (o, i) => o)
+          .Where(it => it.Text != null)
+          .Select(it => it.Id)
+          .Distinct()
+          .ToList());
+
+        Assert.That(ex.InnerException, Is.InstanceOf<NotSupportedException>());
+      }
+    }
+
+    [Test]
+    public void InnerJoinOneVariableUsage()
+    {
+      Expression<Func<TestEntity, int>> key = it => it.Id;
+
+      using (var session = Domain.OpenSession())
+      using (var tx = session.OpenTransaction()) {
+
+        var leftJoinWithExpression = session.Query.All<TestEntity>()
+          .Join(session.Query.All<TestEntity>().Where(it => it.Description == null),
+            o => o.Id,
+            key,
+            (o, i) => o)
+          .Where(it => it.Text != null)
+          .Select(it => it.Id)
+          .Distinct()
+          .ToList();
+
+        Assert.AreEqual(1, leftJoinWithExpression.Count);
+
+        leftJoinWithExpression = session.Query.All<TestEntity>()
+          .Join(session.Query.All<TestEntity>().Where(it => it.Description == null),
+            key,
+            i => i.Id,
+            (o, i) => o)
+          .Where(it => it.Text != null)
+          .Select(it => it.Id)
+          .Distinct()
+          .ToList();
+
+        Assert.AreEqual(1, leftJoinWithExpression.Count);
+      }
+    }
+
+    [Test]
+    public void InnerJoinTwoVariableUsage()
+    {
+      Expression<Func<TestEntity, int>> key = it => it.Id;
+
+      using (var session = Domain.OpenSession())
+      using (var tx = session.OpenTransaction()) {
+
+        var ex = Assert.Throws<QueryTranslationException>(() =>
+          _ = session.Query.All<TestEntity>()
+            .Join(session.Query.All<TestEntity>().Where(it => it.Description == null),
+              key,
+              key,
+              (o, i) => o)
+          .Where(it => it.Text != null)
+          .Select(it => it.Id)
+          .Distinct()
+          .ToList());
+
+        Assert.That(ex.InnerException, Is.InstanceOf<NotSupportedException>());
+      }
+    }
+  }
+}

Orm/Xtensive.Orm/Orm/Linq/Translator.Queryable.cs

@@ -1007,6 +1007,10 @@ private ProjectionExpression VisitJoin(Expression outerSource, Expression innerS
     {
       var outerParameter = outerKey.Parameters[0];
       var innerParameter = innerKey.Parameters[0];
+      if (innerParameter == outerParameter) {
+        throw new NotSupportedException(Strings.ExJoinHasSameInnerAndOuterParameterInstances);
+      }
+
       var outerSequence = VisitSequence(outerSource);
       var innerSequence = VisitSequence(innerSource);
       using (context.Bindings.Add(outerParameter, outerSequence))

Orm/Xtensive.Orm/Strings.Designer.cs

@@ -3476,4 +3476,7 @@ Error: {1}</value>
   <data name="ComparisonOfTwoEntityFieldsIsNotSupported" xml:space="preserve">
     <value>Comparison of two entity fields is not supported.</value>
   </data>
+  <data name="ExJoinHasSameInnerAndOuterParameterInstances" xml:space="preserve">
+    <value>Inner and outer selector expressions have the same parameter instance. Probably you use the same lambda expression for both selectors, which is currently not supported.</value>
+  </data>
 </root>