Refactor JoinWalker and related subclasses to traverse the entity graph level by level.

Author: David Ellingsworth

src/NHibernate/Loader/AbstractEntityJoinWalker.cs

@@ -31,6 +31,7 @@ public AbstractEntityJoinWalker(string rootSqlAlias, IOuterJoinLoadable persiste
 		protected virtual void InitAll(SqlString whereString, SqlString orderByString, LockMode lockMode)
 		{
 			AddAssociations();
+			WalkTree();
 			IList<OuterJoinableAssociation> allAssociations = new List<OuterJoinableAssociation>(associations);
 			var rootAssociation = CreateRootAssociation();
 			allAssociations.Add(rootAssociation);

src/NHibernate/Loader/Criteria/CriteriaJoinWalker.cs

@@ -86,8 +86,16 @@ protected override void AddAssociations()
 				AddExplicitEntityJoinAssociation(persister, tableAlias, translator.GetJoinType(criteriaPath, criteriaPathAlias), criteriaPath, criteriaPathAlias);
 				IncludeInResultIfNeeded(persister, entityJoinInfo.Criteria, tableAlias, criteriaPath);
 				//collect mapped associations for entity join
-				WalkEntityTree(persister, tableAlias, criteriaPath, 1);
+				joinQueue.Enqueue(
+					new EntityQueueEntry()
+					{
+						Persister = persister,
+						Alias = tableAlias,
+						Path = criteriaPath,
+					}
+				);
 			}
+			joinQueue.Enqueue(null);
 		}
 
 		protected override void WalkEntityTree(IOuterJoinLoadable persister, string alias, string path, int currentDepth)

src/NHibernate/Loader/JoinWalker.cs

@@ -15,6 +15,8 @@ namespace NHibernate.Loader
 	public class JoinWalker
 	{
 		private readonly ISessionFactoryImplementor factory;
+		protected Queue<QueueEntry> joinQueue = new Queue<QueueEntry>();
+		private int depth;
 		protected readonly IList<OuterJoinableAssociation> associations = new List<OuterJoinableAssociation>();
 		private readonly HashSet<AssociationKey> visitedAssociationKeys = new HashSet<AssociationKey>();
 		private readonly IDictionary<string, IFilter> enabledFilters;
@@ -188,17 +190,28 @@ private void AddAssociationToJoinTree(IAssociationType type, string[] aliasedLhs
 			assoc.ValidateJoin(path);
 			AddAssociation(assoc);
 
-			int nextDepth = currentDepth + 1;
-
-			if (qc == null)
+			if (qc != null)
 			{
-				IOuterJoinLoadable pjl = joinable as IOuterJoinLoadable;
-				if (pjl != null)
-					WalkEntityTree(pjl, subalias, path, nextDepth);
+				joinQueue.Enqueue(
+					new CollectionQueueEntry()
+					{
+						Persister = qc,
+						Alias = subalias,
+						Path = path,
+						PathAlias = pathAlias,
+					}
+				);
 			}
-			else
+			else if (joinable is IOuterJoinLoadable jl)
 			{
-				WalkCollectionTree(qc, subalias, path, pathAlias, nextDepth);
+				joinQueue.Enqueue(
+					new EntityQueueEntry()
+					{
+						Persister = jl,
+						Alias = subalias,
+						Path = path,
+					}
+				);
 			}
 		}
 
@@ -299,16 +312,55 @@ private void AddAssociation(OuterJoinableAssociation association)
 		/// </summary>
 		protected void WalkEntityTree(IOuterJoinLoadable persister, string alias)
 		{
-			WalkEntityTree(persister, alias, string.Empty, 0);
+			joinQueue.Enqueue(
+				new EntityQueueEntry()
+				{
+					Persister = persister,
+					Alias = alias,
+				}
+			);
+
+			WalkTree();
 		}
 
 		/// <summary>
 		/// For a collection role, return a list of associations to be fetched by outerjoin
 		/// </summary>
 		protected void WalkCollectionTree(IQueryableCollection persister, string alias)
 		{
-			WalkCollectionTree(persister, alias, string.Empty, string.Empty, 0);
-			//TODO: when this is the entry point, we should use an INNER_JOIN for fetching the many-to-many elements!
+			joinQueue.Enqueue(
+				new CollectionQueueEntry()
+				{
+					Persister = persister,
+					Alias = alias,
+				}
+			);
+
+			WalkTree();
+		}
+
+		protected void WalkTree()
+		{
+			while(joinQueue.Count > 0)
+			{
+				QueueEntry entry = joinQueue.Dequeue();
+
+				switch(entry)
+				{
+					case CollectionQueueEntry ce:
+						WalkCollectionTree(ce.Persister, ce.Alias, ce.Path, ce.PathAlias, depth);
+						break;
+					case PropertyQueueEntry pe:
+						WalkPropertyTree(pe.Persister, pe.Type, pe.Index, pe.Alias, pe.Path, depth);
+						break;
+					case EntityQueueEntry eqe:
+						WalkEntityTree(eqe.Persister, eqe.Alias, eqe.Path, depth);
+						break;
+					default:
+						depth++;
+						break;
+				}
+			}
 		}
 
 		/// <summary>
@@ -442,21 +494,42 @@ private void WalkEntityAssociationTree(IAssociationType associationType, IOuterJ
 		protected virtual void WalkEntityTree(IOuterJoinLoadable persister, string alias, string path, int currentDepth)
 		{
 			int n = persister.CountSubclassProperties();
+
 			for (int i = 0; i < n; i++)
 			{
 				IType type = persister.GetSubclassPropertyType(i);
-				ILhsAssociationTypeSqlInfo associationTypeSQLInfo = JoinHelper.GetLhsSqlInfo(alias, i, persister, Factory);
-				if (type.IsAssociationType)
-				{
-					WalkEntityAssociationTree((IAssociationType) type, persister, i, alias, path,
-											  persister.IsSubclassPropertyNullable(i), currentDepth, associationTypeSQLInfo);
-				}
-				else if (type.IsComponentType)
+
+				if (type.IsAssociationType || type.IsComponentType)
 				{
-					WalkComponentTree((IAbstractComponentType) type, 0, alias, SubPath(path, persister.GetSubclassPropertyName(i)),
-									  currentDepth, associationTypeSQLInfo);
+					joinQueue.Enqueue(
+						new PropertyQueueEntry()
+						{
+							Persister = persister,
+							Alias = alias,
+							Path = path,
+							Index = i,
+							Type = type,
+						}
+					);
 				}
 			}
+			joinQueue.Enqueue(null);
+		}
+
+		protected void WalkPropertyTree(IOuterJoinLoadable persister, IType type, int index, string alias, string path, int currentDepth)
+		{
+			ILhsAssociationTypeSqlInfo associationTypeSQLInfo = JoinHelper.GetLhsSqlInfo(alias, index, persister, Factory);
+
+			if (type.IsAssociationType)
+			{
+				WalkEntityAssociationTree((IAssociationType) type, persister, index, alias, path,
+										  persister.IsSubclassPropertyNullable(index), currentDepth, associationTypeSQLInfo);
+			}
+			else if (type.IsComponentType)
+			{
+				WalkComponentTree((IAbstractComponentType) type, 0, alias, SubPath(path, persister.GetSubclassPropertyName(index)),
+								  currentDepth, associationTypeSQLInfo);
+			}
 		}
 
 		/// <summary>
@@ -1201,5 +1274,30 @@ protected static string GetSelectFragment(OuterJoinableAssociation join, string
 		{
 			return join.GetSelectFragment(entitySuffix, collectionSuffix, next);
 		}
+
+		protected abstract class QueueEntry { }
+
+		protected abstract class QueueEntry<T> : QueueEntry where T : IJoinable
+		{
+			public string Alias { get; set; }
+			public T Persister { get; set; }
+		}
+
+		protected class EntityQueueEntry<T> : QueueEntry<T> where T : IJoinable
+		{
+			public string Path { get; set; }
+		}
+		protected class EntityQueueEntry : EntityQueueEntry<IOuterJoinLoadable> {}
+
+		protected class CollectionQueueEntry : EntityQueueEntry<IQueryableCollection>
+		{
+			public string PathAlias { get; set; }
+		}
+
+		protected class PropertyQueueEntry : EntityQueueEntry
+		{
+			public int Index { get; set; }
+			public IType Type { get; set; }
+		}
 	}
 }