Linq - add ability to select first or single element from grouping (NH-3180)

Author: hazzik

src/NHibernate.Test/Linq/ByMethod/GroupByTests.cs

@@ -3,7 +3,6 @@
 using System.Collections.Generic;
 using System.Linq;
 using System.Text.RegularExpressions;
-using NHibernate.Cfg;
 using NHibernate.DomainModel.Northwind.Entities;
 using NUnit.Framework;
 
@@ -12,11 +11,6 @@ namespace NHibernate.Test.Linq.ByMethod
 	[TestFixture]
 	public class GroupByTests : LinqTestCase
 	{
-		protected override void Configure(Configuration configuration)
-		{
-			configuration.SetProperty(Cfg.Environment.ShowSql, "true");
-		}
-
 		[Test]
 		public void SingleKeyGroupAndCount()
 		{
@@ -272,6 +266,65 @@ into g
 		}
 
 
+		[Test]
+		public void SelectFirstElementFromProductsGroupedByUnitPrice()
+		{
+			//NH-3180
+			var result = db.Products
+				.GroupBy(x => x.UnitPrice)
+				.Select(x => new {x.Key, Count = x.Count()})
+				.OrderByDescending(x => x.Key)
+				.First();
+
+			Assert.That(result.Key, Is.EqualTo(263.5M));
+			Assert.That(result.Count, Is.EqualTo(1));
+		}
+
+		[Test]
+		public void SelectFirstOrDefaultElementFromProductsGroupedByUnitPrice()
+		{
+			//NH-3180
+			var result = db.Products
+				.GroupBy(x => x.UnitPrice)
+				.Select(x => new {x.Key, Count = x.Count()})
+				.OrderByDescending(x => x.Key)
+				.FirstOrDefault();
+
+			Assert.That(result.Key, Is.EqualTo(263.5M));
+			Assert.That(result.Count, Is.EqualTo(1));
+		}
+
+
+		[Test]
+		public void SelectSingleElementFromProductsGroupedByUnitPrice()
+		{
+			//NH-3180
+			var result = db.Products
+				.GroupBy(x => x.UnitPrice)
+				.Select(x => new {x.Key, Count = x.Count()})
+				.Where(x => x.Key == 263.5M)
+				.OrderByDescending(x => x.Key)
+				.Single();
+
+			Assert.That(result.Key, Is.EqualTo(263.5M));
+			Assert.That(result.Count, Is.EqualTo(1));
+		}
+
+		[Test]
+		public void SelectSingleOrDefaultElementFromProductsGroupedByUnitPrice()
+		{
+			//NH-3180
+			var result = db.Products
+				.GroupBy(x => x.UnitPrice)
+				.Select(x => new {x.Key, Count = x.Count()})
+				.Where(x => x.Key == 263.5M)
+				.OrderByDescending(x => x.Key)
+				.SingleOrDefault();
+
+			Assert.That(result.Key, Is.EqualTo(263.5M));
+			Assert.That(result.Count, Is.EqualTo(1));
+		}
+
 		private static void CheckGrouping<TKey, TElement>(IEnumerable<IGrouping<TKey, TElement>> groupedItems, Func<TElement, TKey> groupBy)
 		{
 			var used = new HashSet<object>();

src/NHibernate/Linq/GroupBy/AggregatingGroupByRewriter.cs

@@ -1,4 +1,5 @@
 using System;
+using System.Collections.Generic;
 using System.Linq;
 using NHibernate.Linq.Clauses;
 using NHibernate.Linq.Visitors;
@@ -26,47 +27,44 @@ namespace NHibernate.Linq.GroupBy
 	/// This class takes such queries, flattens out the re-linq sub-query and re-writes the outer select
 	/// </para>
 	/// </summary>
-	public class AggregatingGroupByRewriter
+	public static class AggregatingGroupByRewriter
 	{
-		private AggregatingGroupByRewriter() { }
+        private static readonly ICollection<System.Type> AcceptableOuterResultOperators = new HashSet<System.Type>
+	        {
+	            typeof (SkipResultOperator),
+	            typeof (TakeResultOperator),
+	            typeof (FirstResultOperator),
+	            typeof (SingleResultOperator)
+	        };
 
-		public static void ReWrite(QueryModel queryModel)
+	    public static void ReWrite(QueryModel queryModel)
 		{
 			var subQueryExpression = queryModel.MainFromClause.FromExpression as SubQueryExpression;
 
 			if ((subQueryExpression != null) &&
 				(subQueryExpression.QueryModel.ResultOperators.Count == 1) &&
 				(subQueryExpression.QueryModel.ResultOperators[0] is GroupResultOperator))
 			{
-				FlattenSubQuery(subQueryExpression, queryModel);
+				FlattenSubQuery(queryModel, subQueryExpression.QueryModel);
 			}
 		}
 
-
-		private static readonly System.Type[] AcceptableOuterResultOperators = new[]
-			{
-				typeof (SkipResultOperator),
-				typeof (TakeResultOperator),
-			};
-
-
-		private static void FlattenSubQuery(SubQueryExpression subQueryExpression, QueryModel queryModel)
+        private static void FlattenSubQuery(QueryModel queryModel, QueryModel subQueryModel)
 		{
-			foreach (var resultOperator in queryModel.ResultOperators)
+			foreach (var resultOperator in queryModel.ResultOperators.Where(resultOperator => !AcceptableOuterResultOperators.Contains(resultOperator.GetType())))
 			{
-				if (!AcceptableOuterResultOperators.Contains(resultOperator.GetType()))
-					throw new NotImplementedException("Cannot use group by with the "
-					                                  + resultOperator.GetType().Name + " result operator.");
+			    throw new NotImplementedException("Cannot use group by with the " + resultOperator.GetType().Name + " result operator.");
 			}
 
 			// Move the result operator up.
-			var groupBy = (GroupResultOperator) subQueryExpression.QueryModel.ResultOperators[0];
-			queryModel.ResultOperators.Insert(0, groupBy);
+			var groupBy = (GroupResultOperator) subQueryModel.ResultOperators[0];
+
+            queryModel.ResultOperators.Insert(0, groupBy);
 
 			for (int i = 0; i < queryModel.BodyClauses.Count; i++)
 			{
 				var clause = queryModel.BodyClauses[i];
-				clause.TransformExpressions(s => GroupBySelectClauseRewriter.ReWrite(s, groupBy, subQueryExpression.QueryModel));
+				clause.TransformExpressions(s => GroupBySelectClauseRewriter.ReWrite(s, groupBy, subQueryModel));
 
 				//all outer where clauses actually are having clauses
 				var whereClause = clause as WhereClause;
@@ -77,21 +75,19 @@ private static void FlattenSubQuery(SubQueryExpression subQueryExpression, Query
 				}
 			}
 
-			foreach (var bodyClause in subQueryExpression.QueryModel.BodyClauses)
-			{
+			foreach (var bodyClause in subQueryModel.BodyClauses)
 				queryModel.BodyClauses.Add(bodyClause);
-			}
 
 			// Replace the outer select clause...
 			queryModel.SelectClause.TransformExpressions(s => 
-				GroupBySelectClauseRewriter.ReWrite(s, groupBy, subQueryExpression.QueryModel));
+				GroupBySelectClauseRewriter.ReWrite(s, groupBy, subQueryModel));
 
 			// Point all query source references to the outer from clause
-			queryModel.TransformExpressions(s =>
-				new SwapQuerySourceVisitor(queryModel.MainFromClause, subQueryExpression.QueryModel.MainFromClause).Swap(s));
+            var visitor = new SwapQuerySourceVisitor(queryModel.MainFromClause, subQueryModel.MainFromClause);
+            queryModel.TransformExpressions(visitor.Swap);
 
 			// Replace the outer query source
-			queryModel.MainFromClause = subQueryExpression.QueryModel.MainFromClause;
+			queryModel.MainFromClause = subQueryModel.MainFromClause;
 		}
 	}
 }

src/NHibernate/Linq/Visitors/ResultOperatorProcessors/ProcessFirstOrSingleBase.cs

@@ -1,4 +1,6 @@
-using System.Linq.Expressions;
+using System.Collections.Generic;
+using System.Linq;
+using System.Linq.Expressions;
 using System.Reflection;
 
 namespace NHibernate.Linq.Visitors.ResultOperatorProcessors
@@ -7,9 +9,10 @@ public class ProcessFirstOrSingleBase
     {
         protected static void AddClientSideEval(MethodInfo target, QueryModelVisitor queryModelVisitor, IntermediateHqlTree tree)
         {
-            target = target.MakeGenericMethod(queryModelVisitor.CurrentEvaluationType.DataType);
+			var type = queryModelVisitor.Model.SelectClause.Selector.Type;
+			target = target.MakeGenericMethod(type);
 
-            var parameter = Expression.Parameter(queryModelVisitor.PreviousEvaluationType.DataType, null);
+			var parameter = Expression.Parameter(typeof(IQueryable<>).MakeGenericType(type), null);
 
             var lambda = Expression.Lambda(
                 Expression.Call(