NH-3474 - Fix support of GroupBy with constant keys

* Remove the GROUP BY clause entirely if all keys are constant
* Re-write the GROUP BY clause using only non-constant keys

Author: PleasantD

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

@@ -549,6 +549,46 @@ public void GroupByComputedValueInObjectArray()
 			Assert.AreEqual(830, orderGroups.Sum(g => g.Count));
 		}
 
+		[Test(Description = "NH-3474")]
+		public void GroupByConstant()
+		{
+			var totals = db.Orders.GroupBy(o => 1).Select(g => new { Key = g.Key, Count = g.Count(), Sum = g.Sum(x => x.Freight) }).ToList();
+			Assert.That(totals.Count, Is.EqualTo(1));
+			Assert.That(totals, Has.All.With.Property("Key").EqualTo(1));
+		}
+
+		[Test(Description = "NH-3474")]
+		public void GroupByConstantAnonymousType()
+		{
+			var totals = db.Orders.GroupBy(o => new { A = 1 }).Select(g => new { Key = g.Key, Count = g.Count(), Sum = g.Sum(x => x.Freight) }).ToList();
+			Assert.That(totals.Count, Is.EqualTo(1));
+			Assert.That(totals, Has.All.With.Property("Key").With.Property("A").EqualTo(1));
+		}
+
+		[Test(Description = "NH-3474")]
+		public void GroupByConstantArray()
+		{
+			var totals = db.Orders.GroupBy(o => new object[] { 1 }).Select(g => new { Key = g.Key, Count = g.Count(), Sum = g.Sum(x => x.Freight) }).ToList();
+			Assert.That(totals.Count, Is.EqualTo(1));
+			Assert.That(totals, Has.All.With.Property("Key").EqualTo(new object[] { 1 }));
+		}
+
+		[Test(Description = "NH-3474")]
+		public void GroupByKeyWithConstantInAnonymousType()
+		{
+			var totals = db.Orders.GroupBy(o => new { A = 1, B = o.Shipper.ShipperId }).Select(g => new { Key = g.Key, Count = g.Count(), Sum = g.Sum(x => x.Freight) }).ToList();
+			Assert.That(totals.Count, Is.EqualTo(3));
+			Assert.That(totals, Has.All.With.Property("Key").With.Property("A").EqualTo(1));
+		}
+
+		[Test(Description = "NH-3474")]
+		public void GroupByKeyWithConstantInArray()
+		{
+			var totals = db.Orders.GroupBy(o => new[] { 1, o.Shipper.ShipperId }).Select(g => new { Key = g.Key, Count = g.Count(), Sum = g.Sum(x => x.Freight) }).ToList();
+			Assert.That(totals.Count, Is.EqualTo(3));
+			Assert.That(totals, Has.All.With.Property("Key").Contains(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

@@ -59,8 +59,8 @@ public static void ReWrite(QueryModel queryModel, IList<Expression> groupByKeys)
 					var groupBy = operators[0] as GroupResultOperator;
 					if (groupBy != null)
 					{
-						groupBy.ExtractKeyExpressions(groupByKeys);
 						FlattenSubQuery(queryModel, subQueryExpression.QueryModel, groupBy);
+						RemoveCostantGroupByKeys(queryModel, groupBy).ForEach(groupByKeys.Add);
 					}
 				}
 			}
@@ -104,5 +104,24 @@ private static void FlattenSubQuery(QueryModel queryModel, QueryModel subQueryMo
 			// Replace the outer query source
 			queryModel.MainFromClause = subQueryModel.MainFromClause;
 		}
+
+		private static IEnumerable<Expression> RemoveCostantGroupByKeys(QueryModel queryModel, GroupResultOperator groupBy)
+		{
+			var keys = groupBy.ExtractKeyExpressions().Where(x => !(x is ConstantExpression)).ToList();
+
+			if (!keys.Any())
+			{
+				// Remove the Group By clause completely if all the keys are constant (redundant)
+				queryModel.ResultOperators.Remove(groupBy);
+			}
+			else
+			{
+				// Re-write the KeySelector as an object array of the non-constant keys
+				// This should be safe because we've already re-written the select clause using the original keys
+				groupBy.KeySelector = Expression.NewArrayInit(typeof (object), keys.Select(x => x.Type.IsValueType ? Expression.Convert(x, typeof(object)) : x));
+			}
+
+			return keys;
+		}
 	}
 }

src/NHibernate/Linq/GroupResultOperatorExtensions.cs

@@ -10,14 +10,13 @@ namespace NHibernate.Linq
 {
 	internal static class GroupResultOperatorExtensions
 	{
-		public static void ExtractKeyExpressions(this GroupResultOperator groupResult, IList<Expression> groupByKeys)
+		public static IEnumerable<Expression> ExtractKeyExpressions(this GroupResultOperator groupResult)
 		{
 			if (groupResult.KeySelector is NewExpression)
-				(groupResult.KeySelector as NewExpression).Arguments.ForEach(groupByKeys.Add);
-			else if (groupResult.KeySelector is NewArrayExpression)
-				(groupResult.KeySelector as NewArrayExpression).Expressions.ForEach(groupByKeys.Add);
-			else
-				groupByKeys.Add(groupResult.KeySelector);
+				return (groupResult.KeySelector as NewExpression).Arguments;
+			if (groupResult.KeySelector is NewArrayExpression)
+				return (groupResult.KeySelector as NewArrayExpression).Expressions;
+			return new [] { groupResult.KeySelector };
 		}
 	}
 }