WIP Table group joins support for subclasses with withClause in hql

Author: bahusoid

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

@@ -8,9 +8,7 @@
 //------------------------------------------------------------------------------
 
 
-using System;
 using System.Collections;
-using NHibernate.Exceptions;
 using NHibernate.Hql.Ast.ANTLR;
 using NUnit.Framework;
 
@@ -54,40 +52,30 @@ public async Task WithClauseFailsWithFetchAsync()
 		}
 
 		[Test]
-		public async Task ValidWithSemanticsAsync()
+		public void ValidWithSemanticsAsync()
 		{
 			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());
-			}
-		}
-
-		[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>(
+				
+				Assert.Multiple(
 					() =>
-						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
-				}
+					{
+						return Task.FromResult<object>(Assert.DoesNotThrowAsync(
+							() =>				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()
+						));
+
+						return Task.FromResult<object>(Assert.DoesNotThrowAsync(
+							() =>
+								s.CreateQuery("from Human h inner join h.friends as f with f.bodyWeight < :someLimit").SetDouble("someLimit", 1).ListAsync(), "Failed query 1"));
+
+						return Task.FromResult<object>(Assert.DoesNotThrowAsync(
+							() =>
+								s.CreateQuery("from Human h inner join h.offspring o with o.mother.father = :cousin")
+								.SetInt32("cousin", 123)
+								.ListAsync(), 
+							"Failed query 2"));
+					});
 			}
 		}
 

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

@@ -1,6 +1,4 @@
-using System;
 using System.Collections;
-using NHibernate.Exceptions;
 using NHibernate.Hql.Ast.ANTLR;
 using NUnit.Framework;
 
@@ -46,36 +44,26 @@ public void ValidWithSemantics()
 		{
 			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();
-			}
-		}
-
-		[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>(
+				
+				Assert.Multiple(
 					() =>
-						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
-				}
+					{
+						Assert.DoesNotThrow(
+							() =>				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.DoesNotThrow(
+							() =>
+								s.CreateQuery("from Human h inner join h.friends as f with f.bodyWeight < :someLimit").SetDouble("someLimit", 1).List(), "Failed query 1");
+
+						Assert.DoesNotThrow(
+							() =>
+								s.CreateQuery("from Human h inner join h.offspring o with o.mother.father = :cousin")
+								.SetInt32("cousin", 123)
+								.List(), 
+							"Failed query 2");
+					});
 			}
 		}