Allow projections in SelectGroup and CountDistinct expressions (#1987)

Fixes #1985

Author: bahusoid

src/NHibernate.Test/Async/Criteria/Lambda/ProjectIntegrationFixture.cs

@@ -99,6 +99,8 @@ public async Task ProjectTransformToDtoAsync()
 				var actual = await (s.QueryOver<Person>()
 					.SelectList(list => list
 						.SelectGroup(p => p.Name).WithAlias(() => summary.Name)
+						//GH1985: DateTime.xxxx are not supported in SelectGroup
+						.SelectGroup(p => p.BirthDate.Year).WithAlias(() => summary.BirthYear)
 						.Select(Projections.RowCount()).WithAlias(() => summary.Count))
 					.OrderByAlias(() => summary.Name).Asc
 					.TransformUsing(Transformers.AliasToBean<PersonSummary>())
@@ -111,5 +113,26 @@ public async Task ProjectTransformToDtoAsync()
 				Assert.That(actual[1].Count, Is.EqualTo(1));
 			}
 		}
+
+		[Test]
+		public async Task ProjecionCountDistinctAsync()
+		{
+			if (!TestDialect.SupportsCountDistinct)
+				Assert.Ignore("Dialect does not support count distinct");
+
+			using (var s = OpenSession())
+			using (s.BeginTransaction())
+			{
+				var actual
+					= (await (s.QueryOver<Person>()
+					.SelectList(l =>
+					l.SelectCountDistinct(p => p.BirthDate.Year)
+					.SelectCountDistinct(p => p.Name))
+					.ListAsync<object[]>())).FirstOrDefault();
+
+				Assert.That((int) actual[0], Is.EqualTo(1), "distinct count by birth year");
+				Assert.That((int) actual[1], Is.EqualTo(2), "distinct count by name");
+			}
+		}
 	}
 }

src/NHibernate.Test/Criteria/Lambda/Model.cs

@@ -94,6 +94,7 @@ public class PersonSummary
 	{
 		public string Name { get; set; }
 		public int Count { get; set; }
+		public int BirthYear { get; set; }
 	}
 
 	public class Parent

src/NHibernate.Test/Criteria/Lambda/ProjectIntegrationFixture.cs

@@ -88,6 +88,8 @@ public void ProjectTransformToDto()
 				var actual = s.QueryOver<Person>()
 					.SelectList(list => list
 						.SelectGroup(p => p.Name).WithAlias(() => summary.Name)
+						//GH1985: DateTime.xxxx are not supported in SelectGroup
+						.SelectGroup(p => p.BirthDate.Year).WithAlias(() => summary.BirthYear)
 						.Select(Projections.RowCount()).WithAlias(() => summary.Count))
 					.OrderByAlias(() => summary.Name).Asc
 					.TransformUsing(Transformers.AliasToBean<PersonSummary>())
@@ -100,5 +102,26 @@ public void ProjectTransformToDto()
 				Assert.That(actual[1].Count, Is.EqualTo(1));
 			}
 		}
+
+		[Test]
+		public void ProjecionCountDistinct()
+		{
+			if (!TestDialect.SupportsCountDistinct)
+				Assert.Ignore("Dialect does not support count distinct");
+
+			using (var s = OpenSession())
+			using (s.BeginTransaction())
+			{
+				var actual
+					= s.QueryOver<Person>()
+					.SelectList(l =>
+					l.SelectCountDistinct(p => p.BirthDate.Year)
+					.SelectCountDistinct(p => p.Name))
+					.List<object[]>().FirstOrDefault();
+
+				Assert.That((int) actual[0], Is.EqualTo(1), "distinct count by birth year");
+				Assert.That((int) actual[1], Is.EqualTo(2), "distinct count by name");
+			}
+		}
 	}
 }

src/NHibernate/Criterion/Lambda/QueryOverProjectionBuilder.cs

@@ -1,10 +1,8 @@
 
 using System;
-using System.Collections.Generic;
 using System.Linq.Expressions;
 
 using NHibernate.Impl;
-using NHibernate.SqlCommand;
 
 namespace NHibernate.Criterion.Lambda
 {
@@ -50,6 +48,15 @@ public QueryOverProjectionBuilder<T> WithAlias(Expression<Func<object>> alias)
 			lastProjection = Projections.Alias(lastProjection, aliasContainer);
 			return this;
 		}
+		
+		/// <summary>
+		/// Create an alias for the previous projection
+		/// </summary>
+		public QueryOverProjectionBuilder<T> WithAlias(string alias)
+		{
+			lastProjection = Projections.Alias(lastProjection, alias);
+			return this;
+		}
 
 		/// <summary>
 		/// Select an arbitrary projection
@@ -119,7 +126,7 @@ public QueryOverProjectionBuilder<T> SelectCountDistinct(Expression<Func<object>
 		/// </summary>
 		public QueryOverProjectionBuilder<T> SelectGroup(Expression<Func<T, object>> expression)
 		{
-			PushProjection(Projections.Group(expression));
+			PushProjection(Projections.GroupProjection(expression));
 			return this;
 		}
 
@@ -128,7 +135,7 @@ public QueryOverProjectionBuilder<T> SelectGroup(Expression<Func<T, object>> exp
 		/// </summary>
 		public QueryOverProjectionBuilder<T> SelectGroup(Expression<Func<object>> expression)
 		{
-			PushProjection(Projections.Group(expression));
+			PushProjection(Projections.GroupProjection(expression));
 			return this;
 		}
 

src/NHibernate/Criterion/Projections.cs

@@ -113,6 +113,16 @@ public static CountProjection Count(string propertyName)
 			return new CountProjection(propertyName);
 		}
 
+		/// <summary>
+		/// A distinct projection value count
+		/// </summary>
+		/// <param name="projection"></param>
+		/// <returns></returns>
+		public static CountProjection CountDistinct(IProjection projection)
+		{
+			return Count(projection).SetDistinct();
+		}
+
 		/// <summary>
 		/// A distinct property value count
 		/// </summary>
@@ -392,15 +402,15 @@ public static CountProjection Count(Expression<Func<object>> expression)
 		/// </summary>
 		public static CountProjection CountDistinct<T>(Expression<Func<T, object>> expression)
 		{
-			return Projections.CountDistinct(ExpressionProcessor.FindMemberExpression(expression.Body));
+			return Count(expression).SetDistinct();
 		}
 
 		/// <summary>
 		/// A distinct property value count
 		/// </summary>
 		public static CountProjection CountDistinct(Expression<Func<object>> expression)
 		{
-			return Projections.CountDistinct(ExpressionProcessor.FindMemberExpression(expression.Body));
+			return Count(expression).SetDistinct();
 		}
 
 		/// <summary>
@@ -410,6 +420,14 @@ public static PropertyProjection Group<T>(Expression<Func<T, object>> expression
 		{
 			return Projections.GroupProperty(ExpressionProcessor.FindMemberExpression(expression.Body));
 		}
+		
+		/// <summary>
+		/// A grouping property projection
+		/// </summary>
+		public static IProjection GroupProjection<T>(Expression<Func<T, object>> expression)
+		{
+			return Create<T, IProjection>(expression, Projections.GroupProperty, Projections.GroupProperty);
+		}
 
 		/// <summary>
 		/// A grouping property value
@@ -419,6 +437,14 @@ public static PropertyProjection Group(Expression<Func<object>> expression)
 			return Projections.GroupProperty(ExpressionProcessor.FindMemberExpression(expression.Body));
 		}
 
+		/// <summary>
+		/// A grouping property projection
+		/// </summary>
+		public static IProjection GroupProjection(Expression<Func<object>> expression)
+		{
+			return Create<IProjection>(expression, Projections.GroupProperty, Projections.GroupProperty);
+		}
+
 		/// <summary>
 		/// A property maximum value
 		/// </summary>
@@ -507,5 +533,15 @@ internal static IProjection ProcessConcat(MethodCallExpression methodCallExpress
 
 			return Projections.SqlFunction("concat", NHibernateUtil.String, projections);
 		}
+
+		private static TProjection Create<T, TProjection>(Expression<Func<T, object>> expression, Func<string, TProjection> stringFunc, Func<IProjection, TProjection> projectionFunc)
+		{
+			return ExpressionProcessor.FindMemberProjection(expression.Body).Create(stringFunc, projectionFunc);
+		}
+
+		private static TProjection Create<TProjection>(Expression<Func<object>> expression, Func<string, TProjection> stringFunc, Func<IProjection, TProjection> projectionFunc)
+		{
+			return ExpressionProcessor.FindMemberProjection(expression.Body).Create(stringFunc, projectionFunc);
+		}
 	}
 }