Add more left join support

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

@@ -1,8 +1,4 @@
-using System;
-using System.Linq;
-using System.Reflection;
-using NHibernate.Cfg;
-using NHibernate.Engine.Query;
+using System.Linq;
 using NHibernate.Linq;
 using NHibernate.Util;
 using NSubstitute;
@@ -103,6 +99,98 @@ public void LeftJoinExtensionMethodWithMultipleKeyProperties()
 			}
 		}
 
+		[Test]
+		public void LeftJoinExtensionMethodWithOuterReferenceInWhereClauseOnly()
+		{
+			using (var sqlSpy = new SqlLogSpy())
+			{
+				var animals = db.Animals
+							   .LeftJoin(
+								   db.Mammals,
+								   x => x.Id,
+								   x => x.Id,
+								   (animal, mammal) => new { animal, mammal })
+							   .Where(x => x.mammal.SerialNumber.StartsWith("9"))
+							   .Select(x => new { SerialNumber = x.animal.SerialNumber })
+							   .ToList();
+
+				var sql = sqlSpy.GetWholeLog();
+				Assert.That(animals.Count, Is.EqualTo(1));
+				Assert.That(GetTotalOccurrences(sql, "left outer join"), Is.EqualTo(1));
+			}
+		}
+
+		[KnownBug("GH-2379")]
+		public void NestedLeftJoinExtensionMethodWithOuterReferenceInWhereClauseOnly()
+		{
+			using (var sqlSpy = new SqlLogSpy())
+			{
+				var innerAnimals = db.Animals
+							   .LeftJoin(
+								   db.Mammals,
+								   x => x.Id,
+								   x => x.Id,
+								   (animal, mammal) => new { animal, mammal })
+							   .Where(x => x.mammal.SerialNumber.StartsWith("9"))
+							   .Select(x=>x.animal);
+
+				var animals = db.Animals
+							   .LeftJoin(
+								   innerAnimals,
+								   x => x.Id,
+								   x => x.Id,
+								   (animal, animal2) => new { animal, animal2 })
+							   .Select(x => new { SerialNumber = x.animal2.SerialNumber })
+							   .ToList();
+
+				var sql = sqlSpy.GetWholeLog();
+				Assert.That(animals.Count, Is.EqualTo(1));
+				Assert.That(GetTotalOccurrences(sql, "left outer join"), Is.EqualTo(1));
+			}
+		}
+
+		[KnownBug("GH-2738")]
+		public void LeftJoinExtensionMethodWithNoUseOfOuterReference()
+		{
+			using (var sqlSpy = new SqlLogSpy())
+			{
+				var animals = db.Animals
+							   .LeftJoin(
+								   db.Mammals,
+								   x => x.Id,
+								   x => x.Id,
+								   (animal, mammal) => new { animal, mammal })
+							   .Select(x => x.animal)
+							   .ToList();
+
+				var sql = sqlSpy.GetWholeLog();
+				Assert.That(animals.Count, Is.EqualTo(1));
+				Assert.That(GetTotalOccurrences(sql, "left outer join"), Is.EqualTo(6));
+			}
+		}
+
+		[Test]
+		public void LeftJoinExtensionMethodWithOuterReferenceInOrderByClauseOnly()
+		{
+			using (var sqlSpy = new SqlLogSpy())
+			{
+				var animals = db.Animals
+							   .LeftJoin(
+								   db.Mammals,
+								   x => x.Id,
+								   x => x.Id,
+								   (animal, mammal) => new { animal, mammal })
+							   .OrderBy(x => x.mammal.SerialNumber ?? "z")
+							   .Select(x => new { SerialNumber = x.animal.SerialNumber })
+							   .ToList();
+
+				var sql = sqlSpy.GetWholeLog();
+				Assert.That(animals.Count, Is.EqualTo(6));
+				Assert.That(animals[0].SerialNumber, Is.EqualTo("1121"));
+				Assert.That(GetTotalOccurrences(sql, "left outer join"), Is.EqualTo(1));
+			}
+		}
+
 		[TestCase(false)]
 		[TestCase(true)]
 		public void CrossJoinWithPredicateInWhereStatement(bool useCrossJoin)

src/NHibernate/Linq/GroupJoin/GroupJoinAggregateDetectionQueryModelVisitor.cs

@@ -0,0 +1,51 @@
+using System.Collections.Generic;
+using System.Linq.Expressions;
+using NHibernate.Linq.Visitors;
+using Remotion.Linq;
+using Remotion.Linq.Clauses;
+
+namespace NHibernate.Linq.GroupJoin
+{
+	internal class GroupJoinAggregateDetectionQueryModelVisitor : NhQueryModelVisitorBase
+	{
+		private HashSet<GroupJoinClause> _groupJoinClauses;
+		private readonly List<Expression> _nonAggregatingExpressions = new List<Expression>();
+		private readonly List<GroupJoinClause> _nonAggregatingGroupJoins = new List<GroupJoinClause>();
+		private readonly List<GroupJoinClause> _aggregatingGroupJoins = new List<GroupJoinClause>();
+		private GroupJoinAggregateDetectionQueryModelVisitor(IEnumerable<GroupJoinClause> groupJoinClauses)
+		{
+			_groupJoinClauses = new HashSet<GroupJoinClause>(groupJoinClauses);
+		}
+		public static IsAggregatingResults Visit(IEnumerable<GroupJoinClause> groupJoinClause, QueryModel queryModel)
+		{
+			var visitor = new GroupJoinAggregateDetectionQueryModelVisitor(groupJoinClause);
+
+			visitor.VisitQueryModel(queryModel);
+
+			return new IsAggregatingResults { NonAggregatingClauses = visitor._nonAggregatingGroupJoins, AggregatingClauses = visitor._aggregatingGroupJoins, NonAggregatingExpressions = visitor._nonAggregatingExpressions };
+		}
+		public override void VisitWhereClause(WhereClause whereClause, QueryModel queryModel, int index)
+		{
+			var results = GroupJoinAggregateDetectionVisitor.Visit(_groupJoinClauses, whereClause.Predicate);
+			AddResults(results);
+		}
+		public override void VisitSelectClause(SelectClause selectClause, QueryModel queryModel)
+		{
+			var results = GroupJoinAggregateDetectionVisitor.Visit(_groupJoinClauses, selectClause.Selector);
+			AddResults(results);
+		}
+
+		public override void VisitOrdering(Ordering ordering, QueryModel queryModel, OrderByClause orderByClause, int index)
+		{
+			var results = GroupJoinAggregateDetectionVisitor.Visit(_groupJoinClauses, ordering.Expression);
+			AddResults(results);
+		}
+
+		private void AddResults(IsAggregatingResults results)
+		{
+			_nonAggregatingExpressions.AddRange(results.NonAggregatingExpressions);
+			_nonAggregatingGroupJoins.AddRange(results.NonAggregatingClauses);
+			_aggregatingGroupJoins.AddRange(results.AggregatingClauses);
+		}
+	}
+}

src/NHibernate/Linq/GroupJoin/GroupJoinAggregateDetectionVisitor.cs

@@ -1,8 +1,10 @@
 using System;
 using System.Collections.Generic;
+using System.Collections.ObjectModel;
 using System.Linq.Expressions;
 using NHibernate.Linq.Expressions;
 using NHibernate.Linq.Visitors;
+using Remotion.Linq;
 using Remotion.Linq.Clauses;
 using Remotion.Linq.Clauses.Expressions;
 
@@ -34,6 +36,7 @@ public static IsAggregatingResults Visit(IEnumerable<GroupJoinClause> groupJoinC
 
 		protected override Expression VisitSubQuery(SubQueryExpression expression)
 		{
+			//Visit the entire query model?
 			Visit(expression.QueryModel.SelectClause.Selector);
 			return expression;
 		}

src/NHibernate/Linq/GroupJoin/NonAggregatingGroupJoinRewriter.cs

@@ -159,7 +159,7 @@ private bool IsHierarchicalJoin(GroupJoinClause nonAggregatingJoin, QuerySourceU
 		// TODO - rename this and share with the AggregatingGroupJoinRewriter
 		private IsAggregatingResults GetGroupJoinInformation(IEnumerable<GroupJoinClause> clause)
 		{
-			return GroupJoinAggregateDetectionVisitor.Visit(clause, _model.SelectClause.Selector);
+			return GroupJoinAggregateDetectionQueryModelVisitor.Visit(clause, _model);
 		}
 	}