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

src/NHibernate/Async/Impl/CriteriaImpl.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/Criterion/ISupportEntityJoinQueryOver.cs

@@ -0,0 +1,12 @@
+using System;
+using System.Linq.Expressions;
+using NHibernate.SqlCommand;
+
+namespace NHibernate.Criterion
+{
+	// 6.0 TODO: merge into IQueryOver<TRoot,TSubType>.
+	public interface ISupportEntityJoinQueryOver<TRoot>
+	{
+		IQueryOver<TRoot, U> JoinEntityQueryOver<U>(Expression<Func<U>> alias, ICriterion withClause, JoinType joinType, string entityName);
+	}
+}

src/NHibernate/Criterion/QueryOver.cs

@@ -65,6 +65,10 @@ internal static Exception GetDirectUsageException()
 	[Serializable]
 	public abstract partial class QueryOver<TRoot> : QueryOver, IQueryOver<TRoot>
 	{
+		protected internal QueryOver<TRoot, TSubType> Create<TSubType>(ICriteria criteria)
+		{
+			return new QueryOver<TRoot, TSubType>(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,16 @@ public QueryOver<TRoot,U> JoinQueryOver<U>(Expression<Func<IEnumerable<U>>> path
 					joinType));
 		}
 
+		public QueryOver<TRoot, U> JoinEntityQueryOver<U>(Expression<Func<U>> alias, Expression<Func<bool>> withClause, JoinType joinType = JoinType.InnerJoin, string entityName = null)
+		{
+			return JoinEntityQueryOver(alias, Restrictions.Where(withClause), joinType, entityName);
+		}
+
+		public QueryOver<TRoot, U> JoinEntityQueryOver<U>(Expression<Func<U>> alias, ICriterion withClause, JoinType joinType = JoinType.InnerJoin, string entityName = null)
+		{
+			return Create<U>(criteria.CreateEntityCriteria(alias, withClause, joinType, entityName));
+		}
+
 		public QueryOver<TRoot,TSubType> JoinAlias(Expression<Func<TSubType, object>> path, Expression<Func<object>> alias)
 		{
 			return AddAlias(
@@ -974,6 +989,11 @@ 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, ICriterion withClause, JoinType joinType, string entityName)
+		{
+			return JoinEntityQueryOver(alias, withClause, joinType, entityName);
+		}
+
 		IQueryOverJoinBuilder<TRoot,TSubType> IQueryOver<TRoot,TSubType>.Inner
 		{ get { return new IQueryOverJoinBuilder<TRoot,TSubType>(this, JoinType.InnerJoin); } }
 

src/NHibernate/EntityJoinExtensions.cs

@@ -0,0 +1,56 @@
+using System;
+using System.Linq.Expressions;
+using NHibernate.Criterion;
+using NHibernate.Impl;
+using NHibernate.SqlCommand;
+
+namespace NHibernate
+{
+	public static class EntityJoinExtensions
+	{
+		public static TThis JoinEntityAlias<TThis, TEntity>(this TThis queryOver, Expression<Func<TEntity>> alias, ICriterion withClause, JoinType joinType = JoinType.InnerJoin, string entityName = null) where TThis : IQueryOver
+		{
+			CreateEntityCriteria(queryOver.UnderlyingCriteria, alias, withClause, joinType, entityName);
+			return queryOver;
+		}
+
+		public static TThis JoinEntityAlias<TThis, TEntity>(this TThis queryOver, Expression<Func<TEntity>> alias, Expression<Func<bool>> withClause, JoinType joinType = JoinType.InnerJoin, string entityName = null) where TThis : IQueryOver
+		{
+			return JoinEntityAlias(queryOver, alias, Restrictions.Where(withClause), joinType, entityName);
+		}
+
+		public static IQueryOver<TRoot, TEntity> JoinEntityQueryOver<TRoot, TEntity>(this IQueryOver<TRoot> queryOver, Expression<Func<TEntity>> alias, Expression<Func<bool>> withClause, JoinType joinType = JoinType.InnerJoin, string entityName = null)
+		{
+			return JoinEntityQueryOver(queryOver, alias, Restrictions.Where(withClause), joinType, entityName);
+		}
+
+		public static IQueryOver<TRoot, TEntity> JoinEntityQueryOver<TRoot, TEntity>(this IQueryOver<TRoot> queryOver, Expression<Func<TEntity>> alias, ICriterion withClause, JoinType joinType = JoinType.InnerJoin, string entityName = null)
+		{
+			var q = CastOrThrow<ISupportEntityJoinQueryOver<TRoot>>(queryOver);
+			return q.JoinEntityQueryOver(alias, withClause, joinType, entityName);
+		}
+
+		public static ICriteria CreateEntityAlias(this ICriteria criteria, string alias, ICriterion withClause, JoinType joinType, string entityName)
+		{
+			CreateEntityCriteria(criteria, alias, withClause, joinType, entityName);
+			return criteria;
+		}
+
+		public static ICriteria CreateEntityCriteria(this ICriteria criteria, string alias, ICriterion withClause, JoinType joinType = JoinType.InnerJoin, string entityName = null)
+		{
+			var c = CastOrThrow<ISupportEntityJoinCriteria>(criteria);
+			return c.CreateEntityCriteria(alias, withClause, joinType, entityName);
+		}
+
+		public static ICriteria CreateEntityCriteria<U>(this ICriteria criteria, Expression<Func<U>> alias, ICriterion withClause, JoinType joinType = JoinType.InnerJoin, string entityName = null)
+		{
+			return CreateEntityCriteria(criteria, ExpressionProcessor.FindMemberExpression(alias.Body), withClause, joinType, entityName ?? typeof(U).FullName);
+		}
+
+		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/Impl/CriteriaImpl.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>();
@@ -371,6 +371,11 @@ public ICriteria CreateAlias(string associationPath, string alias, JoinType join
 			return this;
 		}
 
+		public ICriteria CreateEntityCriteria(string alias, ICriterion withClause, JoinType joinType, 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,14 +652,15 @@ 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);
 
@@ -668,6 +674,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 entity 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/Impl/ISupportEntityJoinCriteria.cs

@@ -0,0 +1,11 @@
+using NHibernate.Criterion;
+using NHibernate.SqlCommand;
+
+namespace NHibernate.Impl
+{
+	// 6.0 TODO: merge into 'ICriteria'.
+	public interface ISupportEntityJoinCriteria
+	{
+		ICriteria CreateEntityCriteria(string alias, ICriterion withClause, JoinType joinType, string entityName);
+	}
+}

src/NHibernate/Loader/AbstractEntityJoinWalker.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/Loader/Criteria/CriteriaJoinWalker.cs

@@ -76,6 +76,21 @@ public CriteriaJoinWalker(IOuterJoinLoadable persister, CriteriaQueryTranslator
 			}
 		}
 
+		protected override void AddAssociations()
+		{
+			base.AddAssociations();
+			foreach (var entityJoinInfo in translator.GetEntityJoins().Values)
+			{
+				var tableAlias = translator.GetSQLAlias(entityJoinInfo.Criteria);
+				var criteriaPath = entityJoinInfo.Criteria.Alias; //path for entity join is equal to alias
+				var persister = entityJoinInfo.Persister as IOuterJoinLoadable;
+				AddExplicitEntityJoinAssociation(persister, tableAlias, translator.GetJoinType(criteriaPath), GetWithClause(criteriaPath));
+				IncludeInResultIfNeeded(persister, entityJoinInfo.Criteria, tableAlias);
+				//collect mapped associations for entity join
+				WalkEntityTree(persister, tableAlias, criteriaPath, 1);
+			}
+		}
+
 		protected override void WalkEntityTree(IOuterJoinLoadable persister, string alias, string path, int currentDepth)
 		{
 			// NH different behavior (NH-1476, NH-1760, NH-1785)
@@ -199,19 +214,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 +223,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)
 		{