NH-3435 - Ability to select the root entity in a criteria projection

Author: rjperes

src/NHibernate.Test/Criteria/ProjectionsTest.cs

@@ -4,6 +4,7 @@
 using System.Text.RegularExpressions;
 using NHibernate.Criterion;
 using NHibernate.Dialect;
+using NHibernate.SqlCommand;
 using NHibernate.SqlTypes;
 using NHibernate.Type;
 using NUnit.Framework;
@@ -432,5 +433,83 @@ public void UseSubquerySumWithNullResultWithProjection()
 				Assert.AreEqual(0, sum);
 			}
 		}
+
+		[Test]
+		public void UseRootProjection()
+		{
+			//NH-3435
+			using (ISession session = Sfi.OpenSession())
+			using (ITransaction tx = session.BeginTransaction())
+			{
+				Course course = new Course();
+				course.CourseCode = "HIB";
+				course.Description = "Hibernate Training";
+				session.Save(course);
+
+				Student gavin = new Student();
+				gavin.Name = "Gavin King";
+				gavin.StudentNumber = 667;
+				session.Save(gavin);
+
+				Enrolment enrolment = new Enrolment();
+				enrolment.Course = course;
+				enrolment.CourseCode = course.CourseCode;
+				enrolment.Semester = 1;
+				enrolment.Year = 1999;
+				enrolment.Student = gavin;
+				enrolment.StudentNumber = gavin.StudentNumber;
+				gavin.Enrolments.Add(enrolment);
+				session.Save(enrolment);
+
+				session.Flush();
+
+				Student g = session.CreateCriteria(typeof(Student))
+					.Add(Expression.IdEq(gavin.StudentNumber))
+					.SetFetchMode("Enrolments", FetchMode.Join)
+					.SetProjection(Projections.RootEntity())
+					.UniqueResult<Student>();
+
+				Assert.AreSame(gavin, g);
+			}
+		}
+
+		[Test]
+		public void UseEntityProjection()
+		{
+			//NH-3435
+			using (ISession session = Sfi.OpenSession())
+			using (ITransaction tx = session.BeginTransaction())
+			{
+				Course course = new Course();
+				course.CourseCode = "HIB";
+				course.Description = "Hibernate Training";
+				session.Save(course);
+
+				Student gavin = new Student();
+				gavin.Name = "Gavin King";
+				gavin.StudentNumber = 667;
+				session.Save(gavin);
+
+				Enrolment enrolment = new Enrolment();
+				enrolment.Course = course;
+				enrolment.CourseCode = course.CourseCode;
+				enrolment.Semester = 1;
+				enrolment.Year = 1999;
+				enrolment.Student = gavin;
+				enrolment.StudentNumber = gavin.StudentNumber;
+				gavin.Enrolments.Add(enrolment);
+				session.Save(enrolment);
+
+				session.Flush();
+
+				Student g = session.CreateCriteria(typeof(Enrolment))
+					.Add(Expression.And(Expression.Eq("StudentNumber", gavin.StudentNumber), Expression.Eq("CourseCode", course.CourseCode)))
+					.CreateAlias("Student", "s", JoinType.InnerJoin)
+					.SetProjection(Projections.Entity<Student>("s"))
+					.UniqueResult<Student>();
+
+				Assert.AreSame(gavin, g);
+			}
+		}
 	}
 }

src/NHibernate/Criterion/BaseEntityProjection.cs

@@ -0,0 +1,127 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using NHibernate;
+using NHibernate.Criterion;
+using NHibernate.Engine;
+using NHibernate.Persister.Entity;
+using NHibernate.SqlCommand;
+using NHibernate.Type;
+
+namespace NHibernate.Criterion
+{
+	[Serializable]
+	public abstract class BaseEntityProjection : IProjection
+	{
+		private string alias = null;
+		private string[] columnAliases = null;
+		private bool lazy = true;
+
+		protected BaseEntityProjection(System.Type rootEntity, string alias)
+		{
+			this.RootEntity = rootEntity;
+			this.alias = alias;
+		}
+
+		protected System.Type RootEntity
+		{
+			get;
+			private set;
+		}
+
+		public BaseEntityProjection SetLazy(bool lazy)
+		{
+			this.lazy = lazy;
+
+			return (this);
+		}
+
+		string[] IProjection.Aliases
+		{
+			get
+			{
+				return (this.columnAliases.ToArray());
+			}
+		}
+
+		TypedValue[] IProjection.GetTypedValues(ICriteria criteria, ICriteriaQuery criteriaQuery)
+		{
+			throw new NotImplementedException();
+		}
+
+		IType[] IProjection.GetTypes(string alias, ICriteria criteria, ICriteriaQuery criteriaQuery)
+		{
+			return (new IType[] { criteriaQuery.GetType(criteria, alias) });
+		}
+
+		private void SetFields(ICriteria criteria)
+		{
+			if (this.RootEntity == null)
+			{
+				this.RootEntity = criteria.GetRootEntityTypeIfAvailable();
+			}
+
+			if (this.alias == null)
+			{
+				this.alias = criteria.Alias;
+			}
+		}
+
+		IType[] IProjection.GetTypes(ICriteria criteria, ICriteriaQuery criteriaQuery)
+		{
+			this.SetFields(criteria);
+
+			return (new IType[] { new ManyToOneType(this.RootEntity.FullName, this.lazy) });
+		}
+
+		bool IProjection.IsAggregate
+		{
+			get { return (false); }
+		}
+
+		bool IProjection.IsGrouped
+		{
+			get { return (false); }
+		}
+
+		SqlString IProjection.ToGroupSqlString(ICriteria criteria, ICriteriaQuery criteriaQuery)
+		{
+			throw new NotImplementedException();
+		}
+
+		SqlString IProjection.ToSqlString(ICriteria criteria, int position, ICriteriaQuery criteriaQuery)
+		{
+			this.SetFields(criteria);
+
+			SqlStringBuilder builder = new SqlStringBuilder();
+			AbstractEntityPersister persister = criteriaQuery.Factory.TryGetEntityPersister(this.RootEntity.FullName) as AbstractEntityPersister;
+			ICriteria subcriteria = criteria.GetCriteriaByAlias(this.alias);
+
+			this.columnAliases = persister.GetIdentifierAliases(string.Empty);
+
+			string[] columnNames = persister.GetPropertyColumnNames(persister.IdentifierPropertyName).Select(x => string.Concat(criteriaQuery.GetSQLAlias(subcriteria, persister.IdentifierPropertyName), ".", criteriaQuery.Factory.Dialect.QuoteForColumnName(x))).ToArray();
+
+			for (int i = 0; i < columnNames.Length; ++i)
+			{
+				builder.Add(String.Format("{0} as {1}", columnNames[i], this.columnAliases[i]));
+
+				if (i < columnNames.Length - 1)
+				{
+					builder.Add(", ");
+				}
+			}
+
+			return (builder.ToSqlString());
+		}
+
+		public string[] GetColumnAliases(int position, ICriteria criteria, ICriteriaQuery criteriaQuery)
+		{
+			return ((this as IProjection).Aliases);
+		}
+
+		public string[] GetColumnAliases(string alias, int position, ICriteria criteria, ICriteriaQuery criteriaQuery)
+		{
+			return ((this as IProjection).Aliases);
+		}
+	}
+}

src/NHibernate/Criterion/EntityProjection.cs

@@ -0,0 +1,20 @@
+using System;
+
+namespace NHibernate.Criterion
+{
+	[Serializable]
+	public class EntityProjection : BaseEntityProjection
+	{
+		public EntityProjection(System.Type rootEntity, String alias) : base(rootEntity, alias)
+		{
+		}
+	}
+
+	[Serializable]
+	public class EntityProjection<T> : EntityProjection
+	{
+		public EntityProjection(String alias) : base(typeof(T), alias)
+		{
+		}
+	}
+}

src/NHibernate/Criterion/Projections.cs

@@ -16,6 +16,31 @@ namespace NHibernate.Criterion
 	/// </summary>
 	public static class Projections
 	{
+		/// <summary>
+		/// Return the root entity.
+		/// </summary>
+		/// <returns>The root entity.</returns>
+		public static IProjection RootEntity()
+		{
+			return (new RootEntityProjection());
+		}
+
+		/// <summary>
+		/// Return an aliased entity.
+		/// </summary>
+		/// <param name="type">The type of the entity.</param>
+		/// <param name="alias">The alias of the entity.</param>
+		/// <returns>A projection of the entity.</returns>
+		public static IProjection Entity(System.Type type, string alias)
+		{
+			return (new EntityProjection(type, alias));
+		}
+
+		public static IProjection Entity<T>(string alias)
+		{
+			return (new EntityProjection<T>(alias));
+		}
+
 		/// <summary>
 		/// Create a distinct projection from a projection
 		/// </summary>

src/NHibernate/Criterion/RootEntityProjection.cs

@@ -0,0 +1,12 @@
+using System;
+
+namespace NHibernate.Criterion
+{
+	[Serializable]
+	public class RootEntityProjection : BaseEntityProjection
+	{
+		public RootEntityProjection() : base(null, null)
+		{
+		}
+	}
+}