Merge branch '6.0' into 6.0-renamefieldhint-validation-bug

# Conflicts:
#	ChangeLog/6.0.13_dev.txt

Author: alex-kulakov

ChangeLog/6.0.13_dev.txt

@@ -2,5 +2,6 @@
 [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
+[main] Addressed issue when wrong type of join was chosen when .First/FirstOrDefalult() method was used as subquery
 [main] Added dedicated exception when RenameFieldHint.TargetType exists in current model but absent in storage model
 [postgresql] Fixed issue of incorrect translation of contitional expressions including comparison with nullable fields

Orm/Xtensive.Orm.Tests/Issues/IssueJira0743_IncludeDoesNotWorkWithSubqueries.cs

@@ -5,10 +5,8 @@
 // Created:    2018.10.18
 
 using System;
-using System.Collections.Generic;
 using System.Linq;
 using System.Linq.Expressions;
-using System.Text;
 using NUnit.Framework;
 using Xtensive.Orm.Configuration;
 using Xtensive.Orm.Providers;
@@ -345,7 +343,13 @@ public void Case21Test()
         var result = session.Query.All<TestEntity>()
           .Select(e => values.Contains(e.List.FirstOrDefault().Link.Value3.Value)).ToArray();
 
-        Assert.That(result.Single(), Is.True);
+        var values2 = new MyEnum?[] { MyEnum.Bar, MyEnum.Foo };
+        var expected = session.Query.All<TestEntity>().AsEnumerable()
+          .Select(e => values2.Contains(e.List.FirstOrDefault()?.Link.Value3.Value)).ToArray();
+
+        Assert.That(result.Length, Is.EqualTo(2));
+        Assert.That(expected.Length, Is.EqualTo(2));
+        Assert.That(result.Except(expected).Count(), Is.EqualTo(0));
       }
     }
 
@@ -358,7 +362,18 @@ public void Case22Test()
         var result = session.Query.All<TestEntity>()
           .Select(e => e.List.FirstOrDefault().Link.Value3.Value.In(values)).ToArray();
 
-        Assert.That(result.Single(), Is.True);
+        var expected = session.Query.All<TestEntity>().AsEnumerable()
+          .Select(e => {
+            var firsItem = e.List.FirstOrDefault();
+            if (firsItem == null)
+              return false;
+            return firsItem.Link.Value3.Value.In(values);
+          })
+          .ToArray();
+
+        Assert.That(result.Length, Is.EqualTo(2));
+        Assert.That(expected.Length, Is.EqualTo(2));
+        Assert.That(result.Except(expected).Count(), Is.EqualTo(0));
       }
     }
 
@@ -397,7 +412,18 @@ public void Case25Test()
         var result = session.Query.All<TestEntity>()
           .Select(e => values.Contains(e.List.FirstOrDefault().Link.String.Substring(2, 3))).ToArray();
 
-        Assert.That(result, Is.All.True);
+        var expected = session.Query.All<TestEntity>().AsEnumerable()
+         .Select(e => {
+           var firsItem = e.List.FirstOrDefault();
+           if (firsItem == null)
+             return false;
+           return values.Contains(firsItem.Link.String.Substring(2, 3));
+         })
+         .ToArray();
+
+        Assert.That(result.Length, Is.EqualTo(2));
+        Assert.That(expected.Length, Is.EqualTo(2));
+        Assert.That(result.Except(expected).Count(), Is.EqualTo(0));
       }
     }
 

Orm/Xtensive.Orm.Tests/Issues/IssueJira0754_FirstOrDefultOnEntitySetCauseIncorrectResults.cs

@@ -0,0 +1,194 @@
+// 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.Providers;
+using Xtensive.Orm.Tests.Issues.IssueJira0754_FirstOrDefultOnEntitySetCauseIncorrectResultsModel;
+
+
+namespace Xtensive.Orm.Tests.Issues.IssueJira0754_FirstOrDefultOnEntitySetCauseIncorrectResultsModel
+{
+  [HierarchyRoot]
+  public class TestEntity : Entity
+  {
+    [Key]
+    [Field(Nullable = false)]
+    public Guid Id { get; private set; }
+
+    [Field]
+    public string String { get; set; }
+
+    [Field]
+    public ListEntity LinkOnList { get; set; }
+
+    [Field]
+    [Association(PairTo = "Owner")]
+    public EntitySet<ListEntity> List { get; set; }
+
+    [Field]
+    public TestEntity2 Link { get; set; }
+
+    public TestEntity2 VirtualList { get; set; }
+
+    public TestEntity2 VirtualLink { get; set; }
+
+    public TestEntity(Session session)
+      : base(session)
+    {
+    }
+  }
+
+  [HierarchyRoot]
+  public class ListEntity : Entity
+  {
+    [Key]
+    [Field(Nullable = false)]
+    public Guid Id { get; private set; }
+
+    [Field]
+    public string String { get; set; }
+
+    [Field(Nullable = false)]
+    public TestEntity Owner { get; set; }
+
+    [Field(Nullable = false)]
+    public TestEntity2 Link { get; set; }
+
+    public ListEntity(Session session)
+      : base(session)
+    {
+    }
+  }
+
+  [HierarchyRoot]
+  public class TestEntity2 : Entity
+  {
+    public TestEntity2(Session session)
+      : base(session)
+    {
+    }
+
+    [Key]
+    [Field(Nullable = false)]
+    public Guid Id { get; private set; }
+
+    [Field(Nullable = false)]
+    public string String { get; set; }
+  }
+}
+
+
+namespace Xtensive.Orm.Tests.Issues
+{
+  public class IssueJira0754_FirstOrDefultOnEntitySetCauseIncorrectResults : AutoBuildTest
+  {
+    protected override void CheckRequirements() => Require.AllFeaturesSupported(ProviderFeatures.ScalarSubqueries);
+
+    protected override DomainConfiguration BuildConfiguration()
+    {
+      var config = base.BuildConfiguration();
+      config.UpgradeMode = DomainUpgradeMode.Recreate;
+
+      config.Types.Register(typeof(TestEntity));
+      config.Types.Register(typeof(TestEntity2));
+      config.Types.Register(typeof(ListEntity));
+
+      Expression<Func<TestEntity, TestEntity2>> exp = e => e.List.FirstOrDefault().Link;
+      Expression<Func<TestEntity, TestEntity2>> exp2 = e => e.LinkOnList.Link;
+      config.LinqExtensions.Register(typeof(TestEntity).GetProperty("VirtualList"), exp);
+      config.LinqExtensions.Register(typeof(TestEntity).GetProperty("VirtualLink"), exp2);
+
+      return config;
+    }
+
+    protected override void PopulateData()
+    {
+      using (var session = Domain.OpenSession())
+      using (var tx = session.OpenTransaction()) {
+        var item = new TestEntity(session) { String = "test" };
+        var item2 = new TestEntity2(session) { String = "test" };
+        var list = new ListEntity(session) { String = "test", Owner = item, Link = item2 };
+        item.LinkOnList = list;
+
+        _ = new TestEntity(session) { String = "test2" };
+
+        tx.Complete();
+      }
+    }
+
+    [Test]
+    public void Case1()
+    {
+      using (var session = Domain.OpenSession())
+      using (var tx = session.OpenTransaction()) {
+        var count = session.Query.All<TestEntity>()
+          .Select(e => new { e.VirtualList.String, e.VirtualList.Id })
+          .Count();
+        Assert.That(count, Is.EqualTo(2));
+
+        var entities = session.Query.All<TestEntity>()
+          .Select(e => new { e.VirtualList.String, e.VirtualList.Id })
+          .ToArray().OrderBy(x => x.Id).ToArray();
+
+        Assert.That(entities[0].String, Is.Null);
+        Assert.That(entities[0].Id, Is.EqualTo(Guid.Empty));
+
+        Assert.That(entities[1].String, Is.EqualTo("test"));
+        Assert.That(entities[1].Id, Is.Not.EqualTo(Guid.Empty));
+      }
+    }
+
+    [Test]
+    public void Case2()
+    {
+      using (var s = Domain.OpenSession())
+      using (s.Activate())
+      using (var t = s.OpenTransaction()) {
+        var count = s.Query.All<TestEntity>()
+          .Select(e => new { e.String, e.Id })
+          .Count();
+        Assert.That(count, Is.EqualTo(2));
+
+        var entities = s.Query.All<TestEntity>()
+          .Select(e => new { e.String, e.Id })
+          .ToArray().OrderBy(x => x.String).ToArray();
+
+        Assert.That(entities[0].String, Is.EqualTo("test"));
+        Assert.That(entities[0].Id, Is.Not.EqualTo(Guid.Empty));
+
+        Assert.That(entities[1].String, Is.EqualTo("test2"));
+        Assert.That(entities[1].Id, Is.Not.EqualTo(Guid.Empty));
+      }
+    }
+
+    [Test]
+    public void Case3()
+    {
+      using (var s = Domain.OpenSession())
+      using (s.Activate())
+      using (var t = s.OpenTransaction()) {
+        var count = s.Query.All<TestEntity>()
+          .Select(e => new { e.LinkOnList.String, e.LinkOnList.Id })
+          .Count();
+        Assert.That(count, Is.EqualTo(2));
+
+        var entities = s.Query.All<TestEntity>()
+          .Select(e => new { e.LinkOnList.String, e.LinkOnList.Id })
+          .ToArray()
+          .OrderBy(x => x.String)
+          .ToArray();
+
+        Assert.That(entities[0].String, Is.Null);
+        Assert.That(entities[0].Id, Is.EqualTo(Guid.Empty));
+
+        Assert.That(entities[1].String, Is.EqualTo("test"));
+        Assert.That(entities[1].Id, Is.Not.EqualTo(Guid.Empty));
+      }
+    }
+  }
+}

Orm/Xtensive.Orm/Orm/Linq/Translator.Expressions.cs

@@ -1,4 +1,4 @@
-// Copyright (C) 2009-2021 Xtensive LLC.
+// Copyright (C) 2009-2024 Xtensive LLC.
 // This code is distributed under MIT license terms.
 // See the License.txt file in the project root for more information.
 // Created by: Alexis Kochetov
@@ -1662,38 +1662,30 @@ private void EnsureEntityReferenceIsJoined(EntityFieldExpression entityFieldExpr
     {
       if (entityFieldExpression.Entity!=null)
         return;
-      TypeInfo typeInfo = entityFieldExpression.PersistentType;
-      IndexInfo joinedIndex = typeInfo.Indexes.PrimaryIndex;
+      var typeInfo = entityFieldExpression.PersistentType;
+      var joinedIndex = typeInfo.Indexes.PrimaryIndex;
       var joinedRs = joinedIndex.GetQuery().Alias(context.GetNextAlias());
-      Segment<int> keySegment = entityFieldExpression.Mapping;
-      Pair<int>[] keyPairs = keySegment.GetItems()
+      var keySegment = entityFieldExpression.Mapping;
+      var keyPairs = keySegment.GetItems()
         .Select((leftIndex, rightIndex) => new Pair<int>(leftIndex, rightIndex))
         .ToArray();
-      ItemProjectorExpression originalItemProjector = entityFieldExpression.OuterParameter==null
+      var originalItemProjector = entityFieldExpression.OuterParameter==null
         ? context.Bindings[state.Parameters[0]].ItemProjector
         : context.Bindings[entityFieldExpression.OuterParameter].ItemProjector;
-      int offset = originalItemProjector.DataSource.Header.Length;
+
       var oldDataSource = originalItemProjector.DataSource;
-      bool shouldUseLeftJoin = false;
-      var filterProvider = oldDataSource as FilterProvider;
-      if (filterProvider!=null) {
-        var applyProvider = filterProvider.Source as ApplyProvider;
-        if (applyProvider!=null)
-          shouldUseLeftJoin = applyProvider.ApplyType==JoinType.LeftOuter;
-        else {
-          var joinProvider = filterProvider.Source as JoinProvider; 
-          if (joinProvider!=null)
-            shouldUseLeftJoin = joinProvider.JoinType==JoinType.LeftOuter;
-        }
-      }
-      else {
-        var joinProvider = oldDataSource as JoinProvider;
-        if (joinProvider!=null)
-          shouldUseLeftJoin = joinProvider.JoinType==JoinType.LeftOuter;
+      var offset = oldDataSource.Header.Length;
+      var shouldUseLeftJoin = false;
+
+      var sourceToCheck = (oldDataSource is FilterProvider filterProvider) ? filterProvider.Source : oldDataSource;
+      if ((sourceToCheck is ApplyProvider applyProvider && applyProvider.ApplyType == JoinType.LeftOuter) ||
+          (sourceToCheck is JoinProvider joinProvider && joinProvider.JoinType == JoinType.LeftOuter)) {
+        shouldUseLeftJoin = true;
       }
+
       var newDataSource = entityFieldExpression.IsNullable || shouldUseLeftJoin
-        ? originalItemProjector.DataSource.LeftJoin(joinedRs, keyPairs)
-        : originalItemProjector.DataSource.Join(joinedRs, keyPairs);
+        ? oldDataSource.LeftJoin(joinedRs, keyPairs)
+        : oldDataSource.Join(joinedRs, keyPairs);
       originalItemProjector.DataSource = newDataSource;
       entityFieldExpression.RegisterEntityExpression(offset);
       context.RebindApplyParameter(oldDataSource, newDataSource);