Fix query for joins/fetches on entity joins

* Allow With clause with no table references
* Adjust With clause processing for entity joins
* Fix SQLite test

Author: bahusoid

src/NHibernate.Test/Async/Hql/Ast/WithClauseFixture.cs

@@ -8,7 +8,9 @@
 //------------------------------------------------------------------------------
 
 
+using System;
 using System.Collections;
+using NHibernate.Exceptions;
 using NHibernate.Hql.Ast.ANTLR;
 using NUnit.Framework;
 
@@ -52,34 +54,41 @@ public async Task WithClauseFailsWithFetchAsync()
 		}
 
 		[Test]
-		public async Task InvalidWithSemanticsAsync()
+		public async Task ValidWithSemanticsAsync()
 		{
-			ISession s = OpenSession();
-			ITransaction txn = s.BeginTransaction();
-
-			// PROBLEM : f.bodyWeight is a reference to a column on the Animal table; however, the 'f'
-			// alias relates to the Human.friends collection which the aonther Human entity.  The issue
-			// here is the way JoinSequence and Joinable (the persister) interact to generate the
-			// joins relating to the sublcass/superclass tables
-			Assert.ThrowsAsync<InvalidWithClauseException>(
-				() =>
-				s.CreateQuery("from Human h inner join h.friends as f with f.bodyWeight < :someLimit").SetDouble("someLimit", 1).
-					ListAsync());
-
-			Assert.ThrowsAsync<InvalidWithClauseException>(
-				() =>
-				s.CreateQuery(
-					"from Animal a inner join a.offspring o inner join o.mother as m inner join m.father as f with o.bodyWeight > 1").
-					ListAsync());
-
-			Assert.ThrowsAsync<InvalidWithClauseException>(
-				async () =>
-				await (s.CreateQuery("from Human h inner join h.offspring o with o.mother.father = :cousin").SetEntity("cousin",
-				                                                                                                await (s.LoadAsync<Human>(123L)))
-					.ListAsync()));
+			using (var s = OpenSession())
+			{
+				await (s.CreateQuery(
+					"from Animal a inner join a.offspring o inner join o.mother as m inner join m.father as f with o.bodyWeight > 1").ListAsync());
+			}
+		}
 
-			await (txn.CommitAsync());
-			s.Close();
+		[Test]
+		public async Task InvalidWithSemanticsAsync()
+		{
+			using (ISession s = OpenSession())
+			{
+				// PROBLEM : f.bodyWeight is a reference to a column on the Animal table; however, the 'f'
+				// alias relates to the Human.friends collection which the aonther Human entity.  The issue
+				// here is the way JoinSequence and Joinable (the persister) interact to generate the
+				// joins relating to the sublcass/superclass tables
+				Assert.ThrowsAsync<InvalidWithClauseException>(
+					() =>
+						s.CreateQuery("from Human h inner join h.friends as f with f.bodyWeight < :someLimit").SetDouble("someLimit", 1).ListAsync());
+
+				//The query below is no longer throw InvalidWithClauseException but generates "invalid" SQL to better support complex with join clauses.
+				//Invalid SQL means that additional joins for "o.mother.father" are currently added after "offspring" join. Some DBs can process such query and some can't.
+				try
+				{
+					await (s.CreateQuery("from Human h inner join h.offspring o with o.mother.father = :cousin")
+					.SetInt32("cousin", 123)
+					.ListAsync());
+				}
+				catch (GenericADOException)
+				{
+					//Apparently SQLite can process queries with wrong join orders
+				}
+			}
 		}
 
 		[Test]
@@ -175,4 +184,4 @@ public TestData(WithClauseFixtureAsync tc)
 			}
 		}
 	}
-}
+}

src/NHibernate.Test/Async/Hql/EntityJoinHqlTest.cs

@@ -214,6 +214,67 @@ public async Task EntityJoinWithEntityAssociationComparison2ShouldAddJoinAsync()
 		}
 
 
+		[Test]
+		public async Task WithClauseOnOtherAssociationAsync()
+		{
+			using (var sqlLog = new SqlLogSpy())
+			using (var session = OpenSession())
+			{
+				EntityComplex entityComplex = 
+				await (session
+					.CreateQuery("select ex " +
+						"from EntityComplex ex join fetch ex.SameTypeChild stc " +
+						"join ex.SameTypeChild2 stc2 with stc.Version != stc2.Version ")
+						.SetMaxResults(1)
+					.UniqueResultAsync<EntityComplex>());
+
+				Assert.That(entityComplex, Is.Null);
+				Assert.That(sqlLog.Appender.GetEvents().Length, Is.EqualTo(1), "Only one SQL select is expected");
+			}
+		}
+
+		[Test]
+		public async Task EntityJoinNoTablesInWithClauseAsync()
+		{
+			using (var sqlLog = new SqlLogSpy())
+			using (var session = OpenSession())
+			{
+				EntityComplex entityComplex = 
+				await (session
+					.CreateQuery("select ex " +
+						"from EntityWithNoAssociation root " +
+						"left join EntityComplex ex with 1 = 2")
+						.SetMaxResults(1)
+					.UniqueResultAsync<EntityComplex>());
+
+				Assert.That(entityComplex, Is.Null);
+				Assert.That(sqlLog.Appender.GetEvents().Length, Is.EqualTo(1), "Only one SQL select is expected");
+			}
+		}
+
+		[Test]
+		public async Task EntityJoinWithFetchesAsync()
+		{
+			using (var sqlLog = new SqlLogSpy())
+			using (var session = OpenSession())
+			{
+				EntityComplex entityComplex = 
+				await (session
+					.CreateQuery("select ex " +
+						"from EntityWithNoAssociation root " +
+						"left join EntityComplex ex with root.Complex1Id = ex.Id " +
+						"inner join fetch ex.SameTypeChild st")
+						.SetMaxResults(1)
+					.UniqueResultAsync<EntityComplex>());
+
+				Assert.That(entityComplex, Is.Not.Null);
+				Assert.That(NHibernateUtil.IsInitialized(entityComplex), Is.True);
+				Assert.That(entityComplex.SameTypeChild, Is.Not.Null);
+				Assert.That(NHibernateUtil.IsInitialized(entityComplex.SameTypeChild), Is.True);
+				Assert.That(sqlLog.Appender.GetEvents().Length, Is.EqualTo(1), "Only one SQL select is expected");
+			}
+		}
+
 		[Test, Ignore("Failing for unrelated reasons")]
 		public async Task CrossJoinAndWithClauseAsync()
 		{
@@ -248,6 +309,7 @@ protected override HbmMapping GetMappings()
 
 					rc.ManyToOne(ep => ep.SameTypeChild, m => m.Column("SameTypeChildId"));
 
+					rc.ManyToOne(ep => ep.SameTypeChild2, m => m.Column("SameTypeChild2Id"));
 
 				});
 
@@ -331,7 +393,12 @@ protected override void OnSetUp()
 					SameTypeChild = new EntityComplex()
 					{
 						Name = "ComplexEntityChild"
+					},
+					SameTypeChild2 = new EntityComplex()
+					{
+						Name = "ComplexEntityChild2"
 					}
+
 				};
 
 				_entityWithCompositeId = new EntityWithCompositeId
@@ -345,6 +412,7 @@ protected override void OnSetUp()
 				};
 
 				session.Save(parent.SameTypeChild);
+				session.Save(parent.SameTypeChild2);
 				session.Save(parent);
 				session.Save(_entityWithCompositeId);
 

src/NHibernate.Test/Hql/Ast/WithClauseFixture.cs

@@ -1,4 +1,6 @@
+using System;
 using System.Collections;
+using NHibernate.Exceptions;
 using NHibernate.Hql.Ast.ANTLR;
 using NUnit.Framework;
 
@@ -40,34 +42,41 @@ public void WithClauseFailsWithFetch()
 		}
 
 		[Test]
-		public void InvalidWithSemantics()
+		public void ValidWithSemantics()
 		{
-			ISession s = OpenSession();
-			ITransaction txn = s.BeginTransaction();
-
-			// PROBLEM : f.bodyWeight is a reference to a column on the Animal table; however, the 'f'
-			// alias relates to the Human.friends collection which the aonther Human entity.  The issue
-			// here is the way JoinSequence and Joinable (the persister) interact to generate the
-			// joins relating to the sublcass/superclass tables
-			Assert.Throws<InvalidWithClauseException>(
-				() =>
-				s.CreateQuery("from Human h inner join h.friends as f with f.bodyWeight < :someLimit").SetDouble("someLimit", 1).
-					List());
-
-			Assert.Throws<InvalidWithClauseException>(
-				() =>
+			using (var s = OpenSession())
+			{
 				s.CreateQuery(
-					"from Animal a inner join a.offspring o inner join o.mother as m inner join m.father as f with o.bodyWeight > 1").
-					List());
-
-			Assert.Throws<InvalidWithClauseException>(
-				() =>
-				s.CreateQuery("from Human h inner join h.offspring o with o.mother.father = :cousin").SetEntity("cousin",
-				                                                                                                s.Load<Human>(123L))
-					.List());
+					"from Animal a inner join a.offspring o inner join o.mother as m inner join m.father as f with o.bodyWeight > 1").List();
+			}
+		}
 
-			txn.Commit();
-			s.Close();
+		[Test]
+		public void InvalidWithSemantics()
+		{
+			using (ISession s = OpenSession())
+			{
+				// PROBLEM : f.bodyWeight is a reference to a column on the Animal table; however, the 'f'
+				// alias relates to the Human.friends collection which the aonther Human entity.  The issue
+				// here is the way JoinSequence and Joinable (the persister) interact to generate the
+				// joins relating to the sublcass/superclass tables
+				Assert.Throws<InvalidWithClauseException>(
+					() =>
+						s.CreateQuery("from Human h inner join h.friends as f with f.bodyWeight < :someLimit").SetDouble("someLimit", 1).List());
+
+				//The query below is no longer throw InvalidWithClauseException but generates "invalid" SQL to better support complex with join clauses.
+				//Invalid SQL means that additional joins for "o.mother.father" are currently added after "offspring" join. Some DBs can process such query and some can't.
+				try
+				{
+					s.CreateQuery("from Human h inner join h.offspring o with o.mother.father = :cousin")
+					.SetInt32("cousin", 123)
+					.List();
+				}
+				catch (GenericADOException)
+				{
+					//Apparently SQLite can process queries with wrong join orders
+				}
+			}
 		}
 
 		[Test]
@@ -163,4 +172,4 @@ public void Cleanup()
 			}
 		}
 	}
-}
+}

src/NHibernate.Test/Hql/EntityJoinHqlTest.cs

@@ -203,6 +203,67 @@ public void EntityJoinWithEntityAssociationComparison2ShouldAddJoin()
 		}
 
 
+		[Test]
+		public void WithClauseOnOtherAssociation()
+		{
+			using (var sqlLog = new SqlLogSpy())
+			using (var session = OpenSession())
+			{
+				EntityComplex entityComplex = 
+				session
+					.CreateQuery("select ex " +
+						"from EntityComplex ex join fetch ex.SameTypeChild stc " +
+						"join ex.SameTypeChild2 stc2 with stc.Version != stc2.Version ")
+						.SetMaxResults(1)
+					.UniqueResult<EntityComplex>();
+
+				Assert.That(entityComplex, Is.Null);
+				Assert.That(sqlLog.Appender.GetEvents().Length, Is.EqualTo(1), "Only one SQL select is expected");
+			}
+		}
+
+		[Test]
+		public void EntityJoinNoTablesInWithClause()
+		{
+			using (var sqlLog = new SqlLogSpy())
+			using (var session = OpenSession())
+			{
+				EntityComplex entityComplex = 
+				session
+					.CreateQuery("select ex " +
+						"from EntityWithNoAssociation root " +
+						"left join EntityComplex ex with 1 = 2")
+						.SetMaxResults(1)
+					.UniqueResult<EntityComplex>();
+
+				Assert.That(entityComplex, Is.Null);
+				Assert.That(sqlLog.Appender.GetEvents().Length, Is.EqualTo(1), "Only one SQL select is expected");
+			}
+		}
+
+		[Test]
+		public void EntityJoinWithFetches()
+		{
+			using (var sqlLog = new SqlLogSpy())
+			using (var session = OpenSession())
+			{
+				EntityComplex entityComplex = 
+				session
+					.CreateQuery("select ex " +
+						"from EntityWithNoAssociation root " +
+						"left join EntityComplex ex with root.Complex1Id = ex.Id " +
+						"inner join fetch ex.SameTypeChild st")
+						.SetMaxResults(1)
+					.UniqueResult<EntityComplex>();
+
+				Assert.That(entityComplex, Is.Not.Null);
+				Assert.That(NHibernateUtil.IsInitialized(entityComplex), Is.True);
+				Assert.That(entityComplex.SameTypeChild, Is.Not.Null);
+				Assert.That(NHibernateUtil.IsInitialized(entityComplex.SameTypeChild), Is.True);
+				Assert.That(sqlLog.Appender.GetEvents().Length, Is.EqualTo(1), "Only one SQL select is expected");
+			}
+		}
+
 		[Test, Ignore("Failing for unrelated reasons")]
 		public void CrossJoinAndWithClause()
 		{
@@ -237,6 +298,7 @@ protected override HbmMapping GetMappings()
 
 					rc.ManyToOne(ep => ep.SameTypeChild, m => m.Column("SameTypeChildId"));
 
+					rc.ManyToOne(ep => ep.SameTypeChild2, m => m.Column("SameTypeChild2Id"));
 
 				});
 
@@ -320,7 +382,12 @@ protected override void OnSetUp()
 					SameTypeChild = new EntityComplex()
 					{
 						Name = "ComplexEntityChild"
+					},
+					SameTypeChild2 = new EntityComplex()
+					{
+						Name = "ComplexEntityChild2"
 					}
+
 				};
 
 				_entityWithCompositeId = new EntityWithCompositeId
@@ -334,6 +401,7 @@ protected override void OnSetUp()
 				};
 
 				session.Save(parent.SameTypeChild);
+				session.Save(parent.SameTypeChild2);
 				session.Save(parent);
 				session.Save(_entityWithCompositeId);
 

src/NHibernate.Test/Hql/EntityJoinHqlTestEntities.cs

@@ -13,6 +13,7 @@ public class EntityComplex
 		public virtual string LazyProp { get; set; }
 
 		public virtual EntityComplex SameTypeChild { get; set; }
+		public virtual EntityComplex SameTypeChild2 { get; set; }
 
 	}