Support to join not associated entities in Criteria API (aka Entity Join)

Author: bahusoid

src/NHibernate.Test/Async/Criteria/EntityJoinCriteriaTest.cs

@@ -22,7 +22,7 @@
 namespace NHibernate.Impl
 {
 	using System.Threading.Tasks;
-	public partial class CriteriaImpl : ICriteria
+	public partial class CriteriaImpl : ICriteria, ISupportEntityJoinCriteria
 	{
 
 		public async Task<IList> ListAsync(CancellationToken cancellationToken = default(CancellationToken))

src/NHibernate.Test/Criteria/EntityJoinCriteriaTest.cs

@@ -0,0 +1,17 @@
+using System;
+using System.Linq.Expressions;
+using NHibernate.SqlCommand;
+
+namespace NHibernate.Criterion
+{
+	//TODO: Make interface more flexible for changes (maybe it should take only 2 params alias + EntityJoinConfig)
+	public interface ISupportEntityJoinQueryOver
+	{
+		void JoinEntityAlias<U>(Expression<Func<U>> alias, JoinType joinType, ICriterion withClause, string entityName);
+	}
+	
+	public interface ISupportEntityJoinQueryOver<TRoot>: ISupportEntityJoinQueryOver
+	{
+		IQueryOver<TRoot, U> JoinEntityQueryOver<U>(Expression<Func<U>> alias, JoinType joinType, ICriterion withClause, string entityName);
+	}
+}

src/NHibernate/Async/Impl/CriteriaImpl.cs

@@ -65,6 +65,10 @@ internal static Exception GetDirectUsageException()
 	[Serializable]
 	public abstract partial class QueryOver<TRoot> : QueryOver, IQueryOver<TRoot>
 	{
+		protected internal QueryOver<TRoot, U> Create<U>(ICriteria criteria)
+		{
+			return new QueryOver<TRoot, U>(impl, criteria);
+		}
 
 		private IList<TRoot> List()
 		{
@@ -280,7 +284,8 @@ IQueryOver<TRoot> IQueryOver<TRoot>.ReadOnly()
 	/// Implementation of the <see cref="IQueryOver&lt;TRoot, TSubType&gt;"/> interface
 	/// </summary>
 	[Serializable]
-	public class QueryOver<TRoot,TSubType> : QueryOver<TRoot>, IQueryOver<TRoot,TSubType>
+	public class QueryOver<TRoot,TSubType> : QueryOver<TRoot>, IQueryOver<TRoot,TSubType>,
+		ISupportEntityJoinQueryOver<TRoot>
 	{
 
 		protected internal QueryOver()
@@ -658,6 +663,11 @@ public QueryOver<TRoot,U> JoinQueryOver<U>(Expression<Func<IEnumerable<U>>> path
 					joinType));
 		}
 
+		public QueryOver<TRoot,U> JoinEntityQueryOver<U>(Expression<Func<U>> alias, JoinType joinType, ICriterion withClause, string entityName)
+		{
+			return Create<U>(CreateEntityCriteria(alias, joinType, withClause, entityName));
+		}
+
 		public QueryOver<TRoot,TSubType> JoinAlias(Expression<Func<TSubType, object>> path, Expression<Func<object>> alias)
 		{
 			return AddAlias(
@@ -758,6 +768,11 @@ private QueryOver<TRoot,TSubType> AddAlias(string path, string alias, JoinType j
 			return this;
 		}
 
+		private ICriteria CreateEntityCriteria<U>(Expression<Func<U>> alias, JoinType joinType, ICriterion withClause, string entityName)
+		{
+			return criteria.CreateEntityCriteria(ExpressionProcessor.FindMemberExpression(alias.Body), joinType, withClause, entityName ?? typeof(U).FullName);
+		}
+
 		private QueryOver<TRoot,TSubType> Add(Expression<Func<TSubType, bool>> expression)
 		{
 			criteria.Add(ExpressionProcessor.ProcessExpression<TSubType>(expression));
@@ -974,6 +989,17 @@ IQueryOver<TRoot,TSubType> IQueryOver<TRoot,TSubType>.JoinAlias<U>(Expression<Fu
 		IQueryOver<TRoot,TSubType> IQueryOver<TRoot,TSubType>.JoinAlias<U>(Expression<Func<IEnumerable<U>>> path, Expression<Func<U>> alias, JoinType joinType, ICriterion withClause)
 		{ return JoinAlias(path, alias, joinType, withClause); }
 
+		IQueryOver<TRoot, U> ISupportEntityJoinQueryOver<TRoot>.JoinEntityQueryOver<U>(Expression<Func<U>> alias, JoinType joinType, ICriterion withClause, string entityName)
+		{
+			return JoinEntityQueryOver(alias, joinType, withClause, entityName);
+		}
+
+		//6.0 TODO: to remove and merge with extension EntityJoinExtensions.JoinEntityAlias
+		void ISupportEntityJoinQueryOver.JoinEntityAlias<U>(Expression<Func<U>> alias, JoinType joinType, ICriterion withClause, string entityName)
+		{
+			CreateEntityCriteria(alias, joinType, withClause, entityName);
+		}
+
 		IQueryOverJoinBuilder<TRoot,TSubType> IQueryOver<TRoot,TSubType>.Inner
 		{ get { return new IQueryOverJoinBuilder<TRoot,TSubType>(this, JoinType.InnerJoin); } }
 

src/NHibernate/Criterion/ISupportEntityJoinQueryOver.cs

@@ -0,0 +1,44 @@
+using System;
+using System.Linq.Expressions;
+using NHibernate.Criterion;
+using NHibernate.Impl;
+using NHibernate.SqlCommand;
+
+namespace NHibernate
+{
+	public static class EntityJoinExtensions
+	{
+		// 6.0 TODO: merge into 'IQueryOver<TType, TSubType>
+		public static TThis JoinEntityAlias<TThis, TAlias>(this TThis queryOver, Expression<Func<TAlias>> alias, JoinType joinType, ICriterion withClause, string entityName = null) where TThis : IQueryOver
+		{
+			var q = CastOrThrow<ISupportEntityJoinQueryOver>(queryOver);
+			q.JoinEntityAlias(alias, joinType, withClause, entityName);
+			return queryOver;
+		}
+
+		public static IQueryOver<TRoot, U> JoinEntityQueryOver<TRoot, U>(this IQueryOver<TRoot> queryOver, Expression<Func<U>> alias, JoinType joinType, ICriterion withClause, string entityName = null)
+		{
+			var q = CastOrThrow<ISupportEntityJoinQueryOver<TRoot>>(queryOver);
+			return q.JoinEntityQueryOver(alias, joinType, withClause, entityName);
+		}
+
+		// 6.0 TODO: merge into 'ICriteria'
+		public static ICriteria CreateEntityAlias(this ICriteria criteria, string alias, JoinType joinType, ICriterion withClause, string entityName)
+		{
+			CreateEntityCriteria(criteria, alias, joinType, withClause, entityName);
+			return criteria;
+		}
+
+		public static ICriteria CreateEntityCriteria(this ICriteria criteria, string alias, JoinType joinType, ICriterion withClause, string entityName)
+		{
+			var c = CastOrThrow<ISupportEntityJoinCriteria>(criteria);
+			return c.CreateEntityCriteria(alias, joinType, withClause, entityName);
+		}
+
+		private static T CastOrThrow<T>(object obj) where T: class
+		{
+			return obj as T
+					?? throw new ArgumentException($"{obj.GetType().FullName} requires to implement {nameof(T)} interface to support explicit entity joins.");
+		}
+	}
+}

src/NHibernate/Criterion/QueryOver.cs

@@ -15,7 +15,7 @@ namespace NHibernate.Impl
 	/// Implementation of the <see cref="ICriteria"/> interface
 	/// </summary>
 	[Serializable]
-	public partial class CriteriaImpl : ICriteria
+	public partial class CriteriaImpl : ICriteria, ISupportEntityJoinCriteria
 	{
 		private readonly System.Type persistentClass;
 		private readonly List<CriterionEntry> criteria = new List<CriterionEntry>();
@@ -42,6 +42,9 @@ public partial class CriteriaImpl : ICriteria
 
 		private readonly Dictionary<string, ICriteria> subcriteriaByPath = new Dictionary<string, ICriteria>();
 		private readonly Dictionary<string, ICriteria> subcriteriaByAlias = new Dictionary<string, ICriteria>();
+		
+		private readonly Dictionary<string,string> entityJoinAliasToEntityNameMap = new Dictionary<string, string>();
+
 		private readonly string entityOrClassName;
 
 		// Projection Fields
@@ -71,6 +74,11 @@ public CriteriaImpl(string entityOrClassName, string alias, ISessionImplementor
 			rootAlias = alias;
 			subcriteriaByAlias[alias] = this;
 		}
+		
+		public IDictionary<string,string> GetEntityJoinAliasToEntityNameMap()
+		{
+			return entityJoinAliasToEntityNameMap;
+		}
 
 		public ISessionImplementor Session
 		{
@@ -371,6 +379,11 @@ public ICriteria CreateAlias(string associationPath, string alias, JoinType join
 			return this;
 		}
 
+		public ICriteria CreateEntityCriteria(string alias, JoinType joinType, ICriterion withClause, string entityName)
+		{
+			return new Subcriteria(this, this, alias, alias, joinType, withClause, entityName);
+		}
+
 		public ICriteria Add(ICriteria criteriaInst, ICriterion expression)
 		{
 			criteria.Add(new CriterionEntry(expression, criteriaInst));
@@ -647,18 +660,23 @@ public sealed partial class Subcriteria : ICriteria
 			private readonly JoinType joinType;
 			private ICriterion withClause;
 
-			internal Subcriteria(CriteriaImpl root, ICriteria parent, string path, string alias, JoinType joinType, ICriterion withClause)
+			internal Subcriteria(CriteriaImpl root, ICriteria parent, string path, string alias, JoinType joinType, ICriterion withClause, string joinEntityName = null)
 			{
 				this.root = root;
 				this.parent = parent;
 				this.alias = alias;
 				this.path = path;
 				this.joinType = joinType;
 				this.withClause = withClause;
+				JoinEntityName = joinEntityName;
 
 				root.subcriteriaList.Add(this);
 
-				root.subcriteriaByPath[path] = this;
+				if (JoinEntityName == null)
+					root.subcriteriaByPath[path] = this;
+				else
+					root.entityJoinAliasToEntityNameMap[alias] = JoinEntityName;
+
 				SetAlias(alias);
 			}
 
@@ -668,6 +686,16 @@ internal Subcriteria(CriteriaImpl root, ICriteria parent, string path, string al
 			internal Subcriteria(CriteriaImpl root, ICriteria parent, string path, JoinType joinType)
 				: this(root, parent, path, null, joinType) { }
 
+			/// <summary>
+			/// Entity name for "Entity Join" - join for enitity with not mapped association
+			/// </summary>
+			public string JoinEntityName { get; }
+
+			/// <summary>
+			/// Is this an Entity join for not mapped association
+			/// </summary>
+			public bool IsEntityJoin => JoinEntityName != null;
+
 			public ICriterion WithClause
 			{
 				get { return withClause; }

src/NHibernate/EntityJoinExtensions.cs

@@ -0,0 +1,11 @@
+using NHibernate.Criterion;
+using NHibernate.SqlCommand;
+
+namespace NHibernate.Impl
+{
+	public interface ISupportEntityJoinCriteria
+	{
+		//TODO: Make interface more flexible for changes (maybe it should be as simple as CreateEntityCriteria(EntityJoinConfig join)
+		ICriteria CreateEntityCriteria(string alias, JoinType joinType, ICriterion withClause, string entityName);
+	}
+}

src/NHibernate/Impl/CriteriaImpl.cs

@@ -31,7 +31,7 @@ public AbstractEntityJoinWalker(string rootSqlAlias, IOuterJoinLoadable persiste
 
 		protected virtual void InitAll(SqlString whereString, SqlString orderByString, LockMode lockMode)
 		{
-			WalkEntityTree(persister, Alias);
+			AddAssociations();
 			IList<OuterJoinableAssociation> allAssociations = new List<OuterJoinableAssociation>(associations);
 			allAssociations.Add(CreateAssociation(persister.EntityType, alias));
 
@@ -48,7 +48,7 @@ protected void InitProjection(SqlString projectionString, SqlString whereString,
 
 		protected void InitProjection(SqlString projectionString, SqlString whereString, SqlString orderByString, SqlString groupByString, SqlString havingString, IDictionary<string, IFilter> enabledFilters, LockMode lockMode, IList<EntityProjection> entityProjections)
 		{
-			WalkEntityTree(persister, Alias);
+			AddAssociations();
 
 			int countEntities = entityProjections.Count;
 			if (countEntities > 0)
@@ -81,6 +81,11 @@ protected void InitProjection(SqlString projectionString, SqlString whereString,
 			InitStatementString(projectionString, whereString, orderByString, groupByString, havingString, lockMode);
 		}
 
+		protected virtual void AddAssociations()
+		{
+			WalkEntityTree(persister, Alias);
+		}
+
 		private OuterJoinableAssociation CreateAssociation(EntityType entityType, string tableAlias)
 		{
 			return new OuterJoinableAssociation(

src/NHibernate/Impl/ISupportEntityJoinCriteria.cs

@@ -76,6 +76,19 @@ public CriteriaJoinWalker(IOuterJoinLoadable persister, CriteriaQueryTranslator
 			}
 		}
 
+		protected override void AddAssociations()
+		{
+			base.AddAssociations();
+			foreach (var x in translator.GetEntityJoins())
+			{
+				CriteriaQueryTranslator.EntityJoinInfo info = x.Value;
+				AddExplicitEntityJoinAssociation(info.Persister, info.TableAlias, info.JoinType, info.WithClause);
+				IncludeInResultIfNeeded(info.Persister, info.Criteria, info.TableAlias);
+				//collect mapped associations for entity join
+				WalkEntityTree(info.Persister, info.TableAlias, info.Criteria.Alias, 1);
+			}
+		}
+
 		protected override void WalkEntityTree(IOuterJoinLoadable persister, string alias, string path, int currentDepth)
 		{
 			// NH different behavior (NH-1476, NH-1760, NH-1785)
@@ -199,19 +212,7 @@ protected override string GenerateTableAlias(int n, string path, IJoinable joina
 				ICriteria subcriteria = translator.GetCriteria(path);
 				sqlAlias = subcriteria == null ? null : translator.GetSQLAlias(subcriteria);
 
-				if (joinable.ConsumesEntityAlias() && !translator.HasProjection)
-				{
-					includeInResultRowList.Add(subcriteria != null && subcriteria.Alias != null);
-
-					if (sqlAlias != null)
-					{
-						if (subcriteria.Alias != null)
-						{
-							userAliasList.Add(subcriteria.Alias); //alias may be null
-							resultTypeList.Add(translator.ResultType(subcriteria));
-						}
-					}
-				}
+				IncludeInResultIfNeeded(joinable, subcriteria, sqlAlias);
 			}
 
 			if (sqlAlias == null)
@@ -220,6 +221,22 @@ protected override string GenerateTableAlias(int n, string path, IJoinable joina
 			return sqlAlias;
 		}
 
+		private void IncludeInResultIfNeeded(IJoinable joinable, ICriteria subcriteria, string sqlAlias)
+		{
+			if (joinable.ConsumesEntityAlias() && !translator.HasProjection)
+			{
+				includeInResultRowList.Add(subcriteria != null && subcriteria.Alias != null);
+
+				if (sqlAlias != null)
+				{
+					if (subcriteria.Alias != null)
+					{
+						userAliasList.Add(subcriteria.Alias); //alias may be null
+						resultTypeList.Add(translator.ResultType(subcriteria));
+					}
+				}
+			}
+		}
 
 		protected override string GenerateRootAlias(string tableName)
 		{