Add left join support for Linq query provider

Author: maca88

src/NHibernate.Test/Async/Linq/ByMethod/JoinTests.cs

@@ -13,10 +13,10 @@
 using System.Reflection;
 using NHibernate.Cfg;
 using NHibernate.Engine.Query;
+using NHibernate.Linq;
 using NHibernate.Util;
 using NSubstitute;
 using NUnit.Framework;
-using NHibernate.Linq;
 
 namespace NHibernate.Test.Linq.ByMethod
 {
@@ -27,15 +27,70 @@ public class JoinTestsAsync : LinqTestCase
 		[Test]
 		public async Task MultipleLinqJoinsWithSameProjectionNamesAsync()
 		{
-			var orders = await (db.Orders
+			using (var sqlSpy = new SqlLogSpy())
+			{
+				var orders = await (db.Orders
 						   .Join(db.Orders, x => x.OrderId, x => x.OrderId - 1, (order, order1) => new { order, order1 })
 						   .Select(x => new { First = x.order, Second = x.order1 })
 						   .Join(db.Orders, x => x.First.OrderId, x => x.OrderId - 2, (order, order1) => new { order, order1 })
 						   .Select(x => new { FirstId = x.order.First.OrderId, SecondId = x.order.Second.OrderId, ThirdId = x.order1.OrderId })
 						   .ToListAsync());
 
-			Assert.That(orders.Count, Is.EqualTo(828));
-			Assert.IsTrue(orders.All(x => x.FirstId == x.SecondId - 1 && x.SecondId == x.ThirdId - 1));
+				var sql = sqlSpy.GetWholeLog();
+				Assert.That(orders.Count, Is.EqualTo(828));
+				Assert.IsTrue(orders.All(x => x.FirstId == x.SecondId - 1 && x.SecondId == x.ThirdId - 1));
+				Assert.That(GetTotalOccurrences(sql, "inner join"), Is.EqualTo(2));
+			}
+		}
+
+		[Test]
+		public async Task MultipleLinqJoinsWithSameProjectionNamesWithLeftJoinAsync()
+		{
+			using (var sqlSpy = new SqlLogSpy())
+			{
+				var orders = await (db.Orders
+								.GroupJoin(db.Orders, x => x.OrderId, x => x.OrderId - 1, (order, order1) => new { order, order1 })
+								.SelectMany(x => x.order1.DefaultIfEmpty(), (x, order1) => new { First = x.order, Second = order1 })
+								.GroupJoin(db.Orders, x => x.First.OrderId, x => x.OrderId - 2, (order, order1) => new { order, order1 })
+								.SelectMany(x => x.order1.DefaultIfEmpty(), (x, order1) => new
+								{
+									FirstId = x.order.First.OrderId,
+									SecondId = (int?) x.order.Second.OrderId,
+									ThirdId = (int?) order1.OrderId
+								})
+								.ToListAsync());
+
+				var sql = sqlSpy.GetWholeLog();
+				Assert.That(orders.Count, Is.EqualTo(830));
+				Assert.IsTrue(orders.Where(x => x.SecondId.HasValue && x.ThirdId.HasValue)
+									.All(x => x.FirstId == x.SecondId - 1 && x.SecondId == x.ThirdId - 1));
+				Assert.That(GetTotalOccurrences(sql, "left outer join"), Is.EqualTo(2));
+			}
+		}
+
+		[Test]
+		public async Task MultipleLinqJoinsWithSameProjectionNamesWithLeftJoinExtensionMethodAsync()
+		{
+			using (var sqlSpy = new SqlLogSpy())
+			{
+				var orders = await (db.Orders
+								.LeftJoin(db.Orders, x => x.OrderId, x => x.OrderId - 1, (order, order1) => new { order, order1 })
+								.Select(x => new { First = x.order, Second = x.order1 })
+								.LeftJoin(db.Orders, x => x.First.OrderId, x => x.OrderId - 2, (order, order1) => new { order, order1 })
+								.Select(x => new
+								{
+									FirstId = x.order.First.OrderId,
+									SecondId = (int?) x.order.Second.OrderId,
+									ThirdId = (int?) x.order1.OrderId
+								})
+								.ToListAsync());
+
+				var sql = sqlSpy.GetWholeLog();
+				Assert.That(orders.Count, Is.EqualTo(830));
+				Assert.IsTrue(orders.Where(x => x.SecondId.HasValue && x.ThirdId.HasValue)
+									.All(x => x.FirstId == x.SecondId - 1 && x.SecondId == x.ThirdId - 1));
+				Assert.That(GetTotalOccurrences(sql, "left outer join"), Is.EqualTo(2));
+			}
 		}
 
 		[TestCase(false)]

src/NHibernate.Test/Async/Linq/LinqQuerySamples.cs

@@ -768,6 +768,26 @@ from o in c.Orders
 			}
 		}
 
+		[Category("JOIN")]
+		[Test(Description = "This sample uses foreign key navigation in the " +
+							"from clause to select all orders for customers in London.")]
+		public async Task DLinqJoin1LeftJoinAsync()
+		{
+			IQueryable<Order> q =
+				from c in db.Customers
+				from o in c.Orders.DefaultIfEmpty()
+				where c.Address.City == "London"
+				select o;
+
+			using (var sqlSpy = new SqlLogSpy())
+			{
+				await (ObjectDumper.WriteAsync(q));
+
+				var sql = sqlSpy.GetWholeLog();
+				Assert.That(GetTotalOccurrences(sql, "left outer join"), Is.EqualTo(1));
+			}
+		}
+
 		[Category("JOIN")]
 		[Test(Description = "This sample shows how to construct a join where one side is nullable and the other isn't.")]
 		public async Task DLinqJoin10Async()
@@ -974,6 +994,26 @@ join o in db.Orders on c.CustomerId equals o.Customer.CustomerId
 			}
 		}
 
+		[Category("JOIN")]
+		[Test(Description = "This sample explictly joins two tables and projects results from both tables.")]
+		public async Task DLinqJoin5aLeftJoinAsync()
+		{
+			var q =
+				from c in db.Customers
+				join o in db.Orders on c.CustomerId equals o.Customer.CustomerId into orders
+				from o in orders.DefaultIfEmpty()
+				where o != null
+				select new { c.ContactName, o.OrderId };
+
+			using (var sqlSpy = new SqlLogSpy())
+			{
+				await (ObjectDumper.WriteAsync(q));
+
+				var sql = sqlSpy.GetWholeLog();
+				Assert.That(GetTotalOccurrences(sql, "left outer join"), Is.EqualTo(1));
+			}
+		}
+
 		[Category("JOIN")]
 		[Test(Description = "This sample explictly joins two tables and projects results from both tables using a group join.")]
 		public async Task DLinqJoin5bAsync()
@@ -1032,6 +1072,21 @@ join o in db.Orders on
 			}
 		}
 
+		[Category("JOIN")]
+		[Test(Description = "This sample explictly joins two tables with a composite key and projects results from both tables.")]
+		public void DLinqJoin5dLeftJoinAsync()
+		{
+			var q =
+				from c in db.Customers
+				join o in db.Orders on
+					new { c.CustomerId, HasContractTitle = c.ContactTitle != null } equals
+					new { o.Customer.CustomerId, HasContractTitle = o.Customer.ContactTitle != null } into orders
+				from o in orders.DefaultIfEmpty()
+				select new { c.ContactName, o.OrderId };
+
+			Assert.ThrowsAsync<NotSupportedException>(() => ObjectDumper.WriteAsync(q));
+		}
+
 		[Category("JOIN")]
 		[Test(Description = "This sample joins two tables and projects results from the first table.")]
 		public async Task DLinqJoin5eAsync()
@@ -1051,6 +1106,26 @@ join o in db.Orders on c.CustomerId equals o.Customer.CustomerId
 			}
 		}
 
+		[Category("JOIN")]
+		[Test(Description = "This sample joins two tables and projects results from the first table.")]
+		public async Task DLinqJoin5eLeftJoinAsync()
+		{
+			var q =
+				from c in db.Customers
+				join o in db.Orders on c.CustomerId equals o.Customer.CustomerId into orders
+				from o in orders.DefaultIfEmpty()
+				where c.ContactName != null
+				select o;
+
+			using (var sqlSpy = new SqlLogSpy())
+			{
+				await (ObjectDumper.WriteAsync(q));
+
+				var sql = sqlSpy.GetWholeLog();
+				Assert.That(GetTotalOccurrences(sql, "left outer join"), Is.EqualTo(1));
+			}
+		}
+
 		[Category("JOIN")]
 		[TestCase(Description = "This sample explictly joins two tables with a composite key and projects results from both tables.")]
 		public async Task DLinqJoin5fAsync()
@@ -1073,21 +1148,24 @@ join c in db.Customers on
 		}
 
 		[Category("JOIN")]
-		[Test(Description = "This sample joins two tables and projects results from the first table.")]
-		public async Task DLinqJoin5eAsync()
+		[TestCase(Description = "This sample explictly joins two tables with a composite key and projects results from both tables.")]
+		public async Task DLinqJoin5fLeftJoinAsync()
 		{
 			var q =
-				from c in db.Customers
-				join o in db.Orders on c.CustomerId equals o.Customer.CustomerId
-				where c.ContactName != null
-				select o;
+				from o in db.Orders
+				join c in db.Customers on
+					new { o.Customer.CustomerId, HasContractTitle = o.Customer.ContactTitle != null } equals
+					new { c.CustomerId, HasContractTitle = c.ContactTitle != null } into customers
+				from c in customers.DefaultIfEmpty()
+				select new { c.ContactName, o.OrderId };
 
 			using (var sqlSpy = new SqlLogSpy())
 			{
 				await (ObjectDumper.WriteAsync(q));
 
 				var sql = sqlSpy.GetWholeLog();
-				Assert.That(GetTotalOccurrences(sql, "inner join"), Is.EqualTo(1));
+				Assert.That(GetTotalOccurrences(sql, "left outer join"), Is.EqualTo(2));
+				Assert.That(GetTotalOccurrences(sql, "inner join"), Is.EqualTo(0));
 			}
 		}
 
@@ -1113,6 +1191,28 @@ join e in db.Employees on c.Address.City equals e.Address.City into emps
 			}
 		}
 
+		[Category("JOIN")]
+		[Test(
+			Description =
+				"This sample shows how to get LEFT OUTER JOIN by using DefaultIfEmpty(). The DefaultIfEmpty() method returns null when there is no Order for the Employee."
+			)]
+		public async Task DLinqJoin7Async()
+		{
+			var q =
+				from e in db.Employees
+				join o in db.Orders on e equals o.Employee into ords
+				from o in ords.DefaultIfEmpty()
+				select new {e.FirstName, e.LastName, Order = o};
+
+			using (var sqlSpy = new SqlLogSpy())
+			{
+				await (ObjectDumper.WriteAsync(q));
+
+				var sql = sqlSpy.GetWholeLog();
+				Assert.That(GetTotalOccurrences(sql, "left outer join"), Is.EqualTo(1));
+			}
+		}
+
 		[Category("JOIN")]
 		[Test(Description = "This sample projects a 'let' expression resulting from a join.")]
 		public async Task DLinqJoin8Async()
@@ -1175,6 +1275,51 @@ from d in details
 			}
 		}
 
+		[Category("JOIN")]
+		[TestCase(true, Description = "This sample shows a group left join with a composite key.")]
+		[TestCase(false, Description = "This sample shows a group left join with a composite key.")]
+		public async Task DLinqJoin9LeftJoinAsync(bool useCrossJoin)
+		{
+			if (useCrossJoin && !Dialect.SupportsCrossJoin)
+			{
+				Assert.Ignore("Dialect does not support cross join.");
+			}
+
+			ICollection expected, actual;
+			expected =
+				(from o in db.Orders.ToList()
+				from p in db.Products.ToList()
+				join d in db.OrderLines.ToList()
+					on new {o.OrderId, p.ProductId} equals new {d.Order.OrderId, d.Product.ProductId}
+					into details
+				from d in details.DefaultIfEmpty()
+				where d != null && d.UnitPrice > 50
+				select new {o.OrderId, p.ProductId, d.UnitPrice}).ToList();
+
+			using (var substitute = SubstituteDialect())
+			using (var sqlSpy = new SqlLogSpy())
+			{
+				ClearQueryPlanCache();
+				substitute.Value.SupportsCrossJoin.Returns(useCrossJoin);
+
+				actual =
+					await ((from o in db.Orders
+					from p in db.Products
+					join d in db.OrderLines
+						on new {o.OrderId, p.ProductId} equals new {d.Order.OrderId, d.Product.ProductId}
+						into details
+					from d in details.DefaultIfEmpty()
+					where d != null && d.UnitPrice > 50
+					select new {o.OrderId, p.ProductId, d.UnitPrice}).ToListAsync());
+
+				var sql = sqlSpy.GetWholeLog();
+				Assert.That(sql, Does.Contain(useCrossJoin ? "cross join" : "inner join"));
+				Assert.That(GetTotalOccurrences(sql, "left outer join"), Is.EqualTo(1));
+			}
+
+			Assert.AreEqual(expected.Count, actual.Count);
+		}
+
 		[Category("JOIN")]
 		[Test(Description = "This sample shows a join which is then grouped")]
 		public async Task DLinqJoin9bAsync()
@@ -1205,5 +1350,26 @@ join s2 in db.Employees on s.Superior.EmployeeId equals s2.EmployeeId
 				Assert.That(GetTotalOccurrences(sql, "inner join"), Is.EqualTo(2));
 			}
 		}
+
+		[Category("JOIN")]
+		[Test(Description = "This sample shows how to join multiple tables using a left join.")]
+		public async Task DLinqJoin10aLeftJoinAsync()
+		{
+			var q =
+				from e in db.Employees
+				join s in db.Employees on e.Superior.EmployeeId equals s.EmployeeId into sup
+				from s in sup.DefaultIfEmpty()
+				join s2 in db.Employees on s.Superior.EmployeeId equals s2.EmployeeId into sup2
+				from s2 in sup2.DefaultIfEmpty()
+				select new { e.FirstName, SuperiorName = s.FirstName, Superior2Name = s2.FirstName };
+
+			using (var sqlSpy = new SqlLogSpy())
+			{
+				await (ObjectDumper.WriteAsync(q));
+
+				var sql = sqlSpy.GetWholeLog();
+				Assert.That(GetTotalOccurrences(sql, "left outer join"), Is.EqualTo(2));
+			}
+		}
 	}
 }