Add support for left outer join via navigation property (NH-2379)

Author: hazzik

src/NHibernate.Test/Linq/JoinTests.cs

@@ -1,21 +1,12 @@
 using System;
 using System.Linq;
-using System.Linq.Expressions;
-using NHibernate.DomainModel.Northwind.Entities;
 using NUnit.Framework;
 
 namespace NHibernate.Test.Linq
 {
 	[TestFixture]
 	public class JoinTests : LinqTestCase
 	{
-		protected override void Configure(Cfg.Configuration configuration)
-		{
-			configuration.SetProperty(Cfg.Environment.ShowSql, "true");
-			base.Configure(configuration);
-		}
-
-
 		[Test]
 		public void OrderLinesWith2ImpliedJoinShouldProduce2JoinsInSql()
 		{

src/NHibernate.Test/NHSpecificTest/NH2379/Fixture.cs

@@ -0,0 +1,189 @@
+using System;
+using System.Linq;
+using NHibernate.Cfg.MappingSchema;
+using NHibernate.Linq;
+using NHibernate.Mapping.ByCode;
+using NUnit.Framework;
+
+namespace NHibernate.Test.NHSpecificTest.NH2379
+{
+	[TestFixture]
+	public class Fixture : TestCaseMappingByCode
+	{
+		protected override HbmMapping GetMappings()
+		{
+			var mapper = new ModelMapper();
+			mapper.Class<Order>(rc =>
+				{
+					rc.Table("Orders");
+					rc.Id(x => x.Id, m => m.Generator(Generators.GuidComb));
+					rc.Property(x => x.Name);
+					rc.Set(x => x.OrderLines, m =>
+						{
+							m.Inverse(true);
+							m.Key(k =>
+								{
+									k.Column("OrderId");
+									k.NotNullable(true);
+								});
+							m.Cascade(Mapping.ByCode.Cascade.All.Include(Mapping.ByCode.Cascade.DeleteOrphans));
+							m.Access(Accessor.NoSetter);
+						}, m => m.OneToMany());
+				});
+			mapper.Class<OrderLine>(rc =>
+				{
+					rc.Table("OrderLines");
+					rc.Id(x => x.Id, m => m.Generator(Generators.GuidComb));
+					rc.Property(x => x.Name);
+					rc.ManyToOne(x => x.Order, m => m.Column("OrderId"));
+				});
+
+			return mapper.CompileMappingForAllExplicitlyAddedEntities();
+		}
+
+		protected override void OnSetUp()
+		{
+			using (var session = OpenSession())
+			using (var transaction = session.BeginTransaction())
+			{
+				var o1 = new Order {Name = "Order 1"};
+				session.Save(o1);
+
+				var o2 = new Order {Name = "Order 2"};
+				session.Save(o2);
+
+				session.Save(new OrderLine {Name = "Order Line 2 - 1", Order = o2});
+
+				var o3 = new Order {Name = "Order 3"};
+				session.Save(o3);
+
+				session.Save(new OrderLine {Name = "Order Line 3 - 1", Order = o3});
+				session.Save(new OrderLine {Name = "Order Line 3 - 2", Order = o3});
+
+				var o4 = new Order {Name = "Order 4"};
+				session.Save(o4);
+
+				session.Save(new OrderLine {Name = "Order Line 4 - 1", Order = o4});
+				session.Save(new OrderLine {Name = "Order Line 4 - 2", Order = o4});
+				session.Save(new OrderLine {Name = "Order Line 4 - 3", Order = o4});
+
+				transaction.Commit();
+			}
+		}
+
+		protected override void OnTearDown()
+		{
+			using (var session = OpenSession())
+			using (var transaction = session.BeginTransaction())
+			{
+				session.Delete("from System.Object");
+
+				session.Flush();
+				transaction.Commit();
+			}
+		}
+
+		[Test]
+		public void InnerJoin()
+		{
+			// 
+			// select
+			//     order0_.Id as col_0_0_,
+			//     orderlines1_.Id as col_1_0_ 
+			// from
+			//     Orders order0_ 
+			// inner join
+			//     OrderLines orderlines1_ 
+			//         on order0_.Id=orderlines1_.OrderId
+			// 
+
+			using (var session = OpenSession())
+			using (session.BeginTransaction())
+			{
+				var result = (from o in session.Query<Order>()
+							  from ol in o.OrderLines
+							  select new {OrderId = o.Id, OrderLineId = (Guid?) ol.Id}).ToList();
+
+				Assert.AreEqual(6, result.Count);
+			}
+		}
+
+		[Test]
+		public void LeftOuterJoin()
+		{
+			// 
+			// select
+			//     order0_.Id as col_0_0_,
+			//     orderlines1_.Id as col_1_0_ 
+			// from
+			//     Orders order0_ 
+			// left outer join
+			//     OrderLines orderlines1_ 
+			//         on order0_.Id=orderlines1_.OrderId
+			// 
+
+			using (var session = OpenSession())
+			using (session.BeginTransaction())
+			{
+				var result = (from o in session.Query<Order>()
+							  from ol in o.OrderLines.DefaultIfEmpty()
+							  select new {OrderId = o.Id, OrderLineId = (Guid?) ol.Id}).ToList();
+
+				Assert.AreEqual(7, result.Count);
+			}
+		}
+
+		[Test, Ignore("Not fixed yet. (NH-3175)")]
+		public void LeftOuterJoinWithInnerRestriction()
+		{
+			// 
+			// select
+			//     order0_.Id as col_0_0_,
+			//     orderlines1_.Id as col_1_0_ 
+			// from
+			//     Orders order0_ 
+			// left outer join
+			//     OrderLines orderlines1_ 
+			//         on order0_.Id=orderlines1_.OrderId
+			//         and orderlines1_.Name like ('Order Line 3') 
+			// 
+
+			using (var session = OpenSession())
+			using (session.BeginTransaction())
+			{
+				var result = (from o in session.Query<Order>()
+							  from ol in o.OrderLines.Where(x => x.Name.StartsWith("Order Line 3")).DefaultIfEmpty()
+							  select new {OrderId = o.Id, OrderLineId = (Guid?) ol.Id}).ToList();
+
+				Assert.AreEqual(5, result.Count);
+			}
+		}
+
+		[Test]
+		public void LeftOuterJoinWithOuterRestriction()
+		{
+			// 
+			// select
+			//     order0_.Id as col_0_0_,
+			//     orderlines1_.Id as col_1_0_ 
+			// from
+			//     Orders order0_ 
+			// left outer join
+			//     OrderLines orderlines1_ 
+			//         on order0_.Id=orderlines1_.OrderId
+			// where
+			//     orderlines1_.Name like ('Order Line 3')
+			// 
+
+			using (var session = OpenSession())
+			using (session.BeginTransaction())
+			{
+				var result = (from o in session.Query<Order>()
+							  from ol in o.OrderLines.DefaultIfEmpty().Where(x => x.Name.StartsWith("Order Line 3"))
+							  select new {OrderId = o.Id, OrderLineId = (Guid?) ol.Id}).ToList();
+
+				Assert.AreEqual(2, result.Count);
+			}
+		}
+	}
+}

src/NHibernate.Test/NHSpecificTest/NH2379/Order.cs

@@ -0,0 +1,24 @@
+using System;
+using System.Collections.Generic;
+
+namespace NHibernate.Test.NHSpecificTest.NH2379
+{
+	public class Order
+	{
+		private readonly IEnumerable<OrderLine> _orderLines = new List<OrderLine>();
+		public virtual Guid Id { get; set; }
+		public virtual string Name { get; set; }
+
+		public virtual IEnumerable<OrderLine> OrderLines
+		{
+			get { return _orderLines; }
+		}
+	}
+
+	public class OrderLine
+	{
+		public virtual Guid Id { get; set; }
+		public virtual string Name { get; set; }
+		public virtual Order Order { get; set; }
+	}
+}

src/NHibernate.Test/NHibernate.Test.csproj

@@ -664,6 +664,8 @@
     <Compile Include="NHSpecificTest\BagWithLazyExtraAndFilter\Domain.cs" />
     <Compile Include="NHSpecificTest\BagWithLazyExtraAndFilter\Fixture.cs" />
     <Compile Include="Component\Basic\ComponentWithUniqueConstraintTests.cs" />
+    <Compile Include="NHSpecificTest\NH2379\Order.cs" />
+    <Compile Include="NHSpecificTest\NH2379\Fixture.cs" />
     <Compile Include="NHSpecificTest\NH3070\Fixture.cs" />
     <Compile Include="NHSpecificTest\NH2789\Entities.cs" />
     <Compile Include="NHSpecificTest\NH2789\Fixture.cs" />

src/NHibernate/Linq/Visitors/LeftJoinRewriter.cs

@@ -0,0 +1,61 @@
+using System.Collections.Generic;
+using NHibernate.Linq.Clauses;
+using Remotion.Linq;
+using Remotion.Linq.Clauses;
+using Remotion.Linq.Clauses.ExpressionTreeVisitors;
+using Remotion.Linq.Clauses.Expressions;
+using Remotion.Linq.Clauses.ResultOperators;
+
+namespace NHibernate.Linq.Visitors
+{
+	public class LeftJoinRewriter : QueryModelVisitorBase
+	{
+		public static void ReWrite(QueryModel queryModel)
+		{
+			new LeftJoinRewriter().VisitQueryModel(queryModel);
+		}
+
+		public override void VisitAdditionalFromClause(AdditionalFromClause fromClause, QueryModel queryModel, int index)
+		{
+			var subQuery = fromClause.FromExpression as SubQueryExpression;
+			if (subQuery == null)
+				return;
+
+			var subQueryModel = subQuery.QueryModel;
+			if (!IsLeftJoin(subQueryModel))
+				return;
+
+			var mainFromClause = subQueryModel.MainFromClause;
+			var join = NhJoinClause.Create(mainFromClause);
+
+			var innerSelectorMapping = new QuerySourceMapping();
+			innerSelectorMapping.AddMapping(fromClause, subQueryModel.SelectClause.Selector);
+
+			queryModel.TransformExpressions(ex => ReferenceReplacingExpressionTreeVisitor.ReplaceClauseReferences(ex, innerSelectorMapping, false));
+
+			queryModel.BodyClauses.RemoveAt(index);
+			queryModel.BodyClauses.Insert(index, @join);
+			InsertBodyClauses(subQueryModel.BodyClauses, queryModel, index + 1);
+
+			var innerBodyClauseMapping = new QuerySourceMapping();
+			innerBodyClauseMapping.AddMapping(mainFromClause, new QuerySourceReferenceExpression(@join));
+
+			queryModel.TransformExpressions(ex => ReferenceReplacingExpressionTreeVisitor.ReplaceClauseReferences(ex, innerBodyClauseMapping, false));
+		}
+
+		private static void InsertBodyClauses(IEnumerable<IBodyClause> bodyClauses, QueryModel destinationQueryModel, int destinationIndex)
+		{
+			foreach (var bodyClause in bodyClauses)
+			{
+				destinationQueryModel.BodyClauses.Insert(destinationIndex, bodyClause);
+				++destinationIndex;
+			}
+		}
+
+		private static bool IsLeftJoin(QueryModel subQueryModel)
+		{
+			return subQueryModel.ResultOperators.Count == 1 &&
+				   subQueryModel.ResultOperators[0] is DefaultIfEmptyResultOperator;
+		}
+	}
+}

src/NHibernate/Linq/Visitors/QueryModelVisitor.cs

@@ -22,6 +22,8 @@ public static ExpressionToHqlTranslationResults GenerateHqlQuery(QueryModel quer
 		{
 			SubQueryFromClauseFlattener.ReWrite(queryModel);
 
+			LeftJoinRewriter.ReWrite(queryModel);
+
 			NestedSelectRewriter.ReWrite(queryModel, parameters.SessionFactory);
 
 			// Remove unnecessary body operators

src/NHibernate/NHibernate.csproj

@@ -295,6 +295,7 @@
     <Compile Include="Linq\NestedSelects\Tuple.cs" />
     <Compile Include="Linq\NestedSelects\SelectClauseRewriter.cs" />
     <Compile Include="Linq\NestedSelects\ExpressionHolder.cs" />
+    <Compile Include="Linq\Visitors\LeftJoinRewriter.cs" />
     <Compile Include="Linq\Visitors\NhPartialEvaluatingExpressionTreeVisitor.cs" />
     <Compile Include="Linq\QuerySourceNamer.cs" />
     <Compile Include="Linq\ReWriters\AddJoinsReWriter.cs" />